Files
audita/internal/core/schema/source_members.go

141 lines
3.0 KiB
Go
Raw Normal View History

package schema
import (
"encoding/json"
"fmt"
"maps"
"slices"
"strings"
)
func decodeSourceSegments(raw []byte) ([]SourceSegment, error) {
if !needsMemberResolution(raw, 2) {
var segments []SourceSegment
err := json.Unmarshal(raw, &segments)
return segments, err
}
var decoded []sourceSegmentWithAliases
if err := json.Unmarshal(raw, &decoded); err != nil {
return nil, err
}
segments := make([]SourceSegment, len(decoded))
for i, segment := range decoded {
segments[i] = SourceSegment(segment)
}
return segments, nil
}
type sourceSegmentWithAliases SourceSegment
// Resolve repeated exact names before field conversion, then apply case
// variants in the same key order as the original object round trip.
func (s *sourceSegmentWithAliases) UnmarshalJSON(raw []byte) error {
if !needsMemberResolution(raw, 1) {
return json.Unmarshal(raw, (*SourceSegment)(s))
}
var members map[string]json.RawMessage
if err := json.Unmarshal(raw, &members); err != nil {
return err
}
for _, key := range slices.Sorted(maps.Keys(members)) {
var field any
switch sourceMemberFor(key) {
case memberID:
field = &s.ID
case memberSpeaker:
field = &s.Speaker
case memberStart:
field = &s.Start
case memberEnd:
field = &s.End
case memberText:
field = &s.Text
case memberCategories:
field = &s.Categories
default:
continue
}
if err := json.Unmarshal(members[key], field); err != nil {
return fmt.Errorf("field %q: %w", key, err)
}
}
return nil
}
type sourceMember uint8
const (
memberID sourceMember = 1 << iota
memberSpeaker
memberStart
memberEnd
memberText
memberCategories
)
func sourceMemberFor(key string) sourceMember {
switch {
case strings.EqualFold(key, "id"):
return memberID
case strings.EqualFold(key, "speaker"):
return memberSpeaker
case strings.EqualFold(key, "start"):
return memberStart
case strings.EqualFold(key, "end"):
return memberEnd
case strings.EqualFold(key, "text"):
return memberText
case strings.EqualFold(key, "categories"):
return memberCategories
}
return 0
}
// needsMemberResolution looks for repeated recognized keys in valid JSON.
// segmentDepth locates members within the array or a single segment.
// Escaped keys use the compatibility decoder to resolve their spelling.
func needsMemberResolution(raw []byte, segmentDepth int) bool {
depth := 0
wantKey := false
var seen sourceMember
for i := 0; i < len(raw); i++ {
switch raw[i] {
case '{':
depth++
if depth == segmentDepth {
seen, wantKey = 0, true
}
case '[':
depth++
case '}', ']':
depth--
case ',':
if depth == segmentDepth {
wantKey = true
}
case '"':
start := i + 1
escaped := false
for i++; raw[i] != '"'; i++ {
if raw[i] == '\\' {
escaped = true
i++
}
}
if depth != segmentDepth || !wantKey {
continue
}
wantKey = false
if escaped {
return true
}
member := sourceMemberFor(string(raw[start:i]))
if seen&member != 0 {
return true
}
seen |= member
}
}
return false
}