eric/notarius
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adopt registry-backed item occurrences

Browse Source
This commit is contained in:
Eric Rakestraw
2026-08-05 19:55:34 +00:00
parent f91237e9c0
commit 3dfefd0e14
46 changed files with 996 additions and 1034 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
internal/modules/dnd/itemevents/itemevents.go
View File

@@ -14,14 +14,14 @@ import (
const partyHolder = "party"
// SupportedKind reports whether kind is one of the durable item-event kinds.
func SupportedKind(kind dnd.ItemEventKind) bool {
// SupportedKind reports whether kind is one of the durable item occurrence kinds.
func SupportedKind(kind dnd.ItemOccurrenceKind) bool {
switch kind {
case dnd.ItemEventKindDiscovered,
dnd.ItemEventKindAcquired,
dnd.ItemEventKindLost,
dnd.ItemEventKindConsumed,
dnd.ItemEventKindTransferred:
case dnd.ItemOccurrenceKindDiscovered,
dnd.ItemOccurrenceKindAcquired,
dnd.ItemOccurrenceKindLost,
dnd.ItemOccurrenceKindConsumed,
dnd.ItemOccurrenceKindTransferred:
return true
default:
return false
@@ -45,18 +45,18 @@ func IsPartyHolder(value string) bool { return ComparisonKey(value) == partyHold
// ValidHolderCombination reports whether the optional holder fields satisfy
// the durable rules for kind. Blank holders are treated as absent so callers
// can preserve invalid extraction candidates for their owning validators.
func ValidHolderCombination(kind dnd.ItemEventKind, from, to string) bool {
func ValidHolderCombination(kind dnd.ItemOccurrenceKind, from, to string) bool {
hasFrom := HolderPresent(from)
hasTo := HolderPresent(to)
switch kind {
case dnd.ItemEventKindDiscovered:
case dnd.ItemOccurrenceKindDiscovered:
return !hasFrom && !hasTo
case dnd.ItemEventKindAcquired:
case dnd.ItemOccurrenceKindAcquired:
return !hasFrom && hasTo
case dnd.ItemEventKindLost, dnd.ItemEventKindConsumed:
case dnd.ItemOccurrenceKindLost, dnd.ItemOccurrenceKindConsumed:
return hasFrom && !hasTo
case dnd.ItemEventKindTransferred:
case dnd.ItemOccurrenceKindTransferred:
return hasFrom && hasTo && !IsPartyHolder(from) && !IsPartyHolder(to) && ComparisonKey(from) != ComparisonKey(to)
default:
return false
@@ -93,7 +93,7 @@ func ValidSourceRefs(index source.DocumentIndex, refs []source.SourceRef) bool {
// Less defines the canonical event order. Invalid source references remain
// comparable through SourceRefOrder's literal fallback so malformed candidates
// are still safe to sort and diagnose.
func Less(order shared.SourceRefOrder, left, right dnd.ItemEvent) bool {
func Less(order shared.SourceRefOrder, left, right dnd.ItemOccurrence) bool {
leftPosition, leftHasEvidence := order.EarliestValid(left.SourceRefs)
rightPosition, rightHasEvidence := order.EarliestValid(right.SourceRefs)
if leftHasEvidence != rightHasEvidence {
@@ -102,6 +102,9 @@ func Less(order shared.SourceRefOrder, left, right dnd.ItemEvent) bool {
if leftHasEvidence && leftPosition != rightPosition {
return leftPosition < rightPosition
}
if left.ItemID != right.ItemID {
return left.ItemID < right.ItemID
}
if leftKey, rightKey := ComparisonKey(left.Name), ComparisonKey(right.Name); leftKey != rightKey {
return leftKey < rightKey
}
@@ -125,8 +128,8 @@ func Less(order shared.SourceRefOrder, left, right dnd.ItemEvent) bool {
// ExactEqual reports whether events are exact duplicates after their display
// fields and evidence have been canonicalized for the supplied source order.
func ExactEqual(order shared.SourceRefOrder, left, right dnd.ItemEvent) bool {
if DisplayValue(left.Name) != DisplayValue(right.Name) || left.Kind != right.Kind ||
func ExactEqual(order shared.SourceRefOrder, left, right dnd.ItemOccurrence) bool {
if left.ItemID != right.ItemID || DisplayValue(left.Name) != DisplayValue(right.Name) || left.Kind != right.Kind ||
DisplayValue(left.From) != DisplayValue(right.From) || DisplayValue(left.To) != DisplayValue(right.To) ||
(left.Quantity == nil) != (right.Quantity == nil) {
return false
@@ -140,8 +143,9 @@ func ExactEqual(order shared.SourceRefOrder, left, right dnd.ItemEvent) bool {
// ExactIdentity returns a collision-safe duplicate key after display and
// evidence canonicalization. It is intended for callers that have already
// decided the event is eligible for duplicate handling.
func ExactIdentity(order shared.SourceRefOrder, event dnd.ItemEvent) string {
func ExactIdentity(order shared.SourceRefOrder, event dnd.ItemOccurrence) string {
var key strings.Builder
writeKeyString(&key, event.ItemID)
writeKeyString(&key, DisplayValue(event.Name))
writeKeyString(&key, string(event.Kind))
writeKeyString(&key, DisplayValue(event.From))

74
internal/modules/dnd/itemevents/itemevents_test.go
View File

@@ -11,14 +11,14 @@ import (
func TestValidHolderCombination(t *testing.T) {
valid := []struct {
kind dnd.ItemEventKind
kind dnd.ItemOccurrenceKind
from, to string
}{
{dnd.ItemEventKindDiscovered, "", ""},
{dnd.ItemEventKindAcquired, "", "party"},
{dnd.ItemEventKindLost, "party", ""},
{dnd.ItemEventKindConsumed, "party", ""},
{dnd.ItemEventKindTransferred, "Aria", "Borin"},
{dnd.ItemOccurrenceKindDiscovered, "", ""},
{dnd.ItemOccurrenceKindAcquired, "", "party"},
{dnd.ItemOccurrenceKindLost, "party", ""},
{dnd.ItemOccurrenceKindConsumed, "party", ""},
{dnd.ItemOccurrenceKindTransferred, "Aria", "Borin"},
}
for _, test := range valid {
if !ValidHolderCombination(test.kind, test.from, test.to) {
@@ -27,17 +27,17 @@ func TestValidHolderCombination(t *testing.T) {
}
invalid := []struct {
kind dnd.ItemEventKind
kind dnd.ItemOccurrenceKind
from, to string
}{
{dnd.ItemEventKindDiscovered, "Aria", ""},
{dnd.ItemEventKindAcquired, "", ""},
{dnd.ItemEventKindLost, "", ""},
{dnd.ItemEventKindConsumed, "", "Borin"},
{dnd.ItemEventKindTransferred, "party", "Borin"},
{dnd.ItemEventKindTransferred, "Aria", "Party"},
{dnd.ItemEventKindTransferred, "Aria", "aria"},
{dnd.ItemEventKindTransferred, "Åria", "Åria"},
{dnd.ItemOccurrenceKindDiscovered, "Aria", ""},
{dnd.ItemOccurrenceKindAcquired, "", ""},
{dnd.ItemOccurrenceKindLost, "", ""},
{dnd.ItemOccurrenceKindConsumed, "", "Borin"},
{dnd.ItemOccurrenceKindTransferred, "party", "Borin"},
{dnd.ItemOccurrenceKindTransferred, "Aria", "Party"},
{dnd.ItemOccurrenceKindTransferred, "Aria", "aria"},
{dnd.ItemOccurrenceKindTransferred, "Åria", "Åria"},
{"unsupported", "", ""},
}
for _, test := range invalid {
@@ -53,16 +53,16 @@ func TestLessUsesEveryCanonicalTieBreaker(t *testing.T) {
return []source.SourceRef{{SourceID: "session", StartUnitID: start, EndUnitID: end}}
}
quantity := func(value int) *int { return &value }
base := dnd.ItemEvent{Name: "Amulet", Kind: dnd.ItemEventKindAcquired, To: "Borin", SourceRefs: ref(20, 20)}
base := dnd.ItemOccurrence{ItemID: "item", Name: "Amulet", Kind: dnd.ItemOccurrenceKindAcquired, To: "Borin", SourceRefs: ref(20, 20)}
tests := []struct {
name string
left, right dnd.ItemEvent
left, right dnd.ItemOccurrence
}{
{"earlier evidence", withRefs(base, ref(10, 10)), base},
{"valid evidence before malformed", base, withRefs(base, ref(999, 999))},
{"normalized name", withName(base, "Amulet"), withName(base, "Blade")},
{"exact trimmed name", withName(base, "Amulet"), withName(base, "amulet")},
{"kind", withKind(base, dnd.ItemEventKindAcquired), withKind(base, dnd.ItemEventKindLost)},
{"kind", withKind(base, dnd.ItemOccurrenceKindAcquired), withKind(base, dnd.ItemOccurrenceKindLost)},
{"from presence", withFrom(base, ""), withFrom(base, "Aria")},
{"from normalized value", withFrom(base, "Aria"), withFrom(base, "Borin")},
{"from exact value", withFrom(base, "Aria"), withFrom(base, "aria")},
@@ -84,16 +84,16 @@ func TestLessUsesEveryCanonicalTieBreaker(t *testing.T) {
func TestLessAndExactEqualityCanonicalizeEvidence(t *testing.T) {
order := testOrder()
first := dnd.ItemEvent{
Name: " Silver Coin ", Kind: dnd.ItemEventKindAcquired, To: " party ",
first := dnd.ItemOccurrence{ItemID: "item",
Name: " Silver Coin ", Kind: dnd.ItemOccurrenceKindAcquired, To: " party ",
SourceRefs: []source.SourceRef{
{SourceID: "session", StartUnitID: 30, EndUnitID: 30},
{SourceID: "session", StartUnitID: 10, EndUnitID: 10},
{SourceID: "session", StartUnitID: 10, EndUnitID: 10},
},
}
second := dnd.ItemEvent{
Name: "Silver Coin", Kind: dnd.ItemEventKindAcquired, To: "party",
second := dnd.ItemOccurrence{ItemID: "item",
Name: "Silver Coin", Kind: dnd.ItemOccurrenceKindAcquired, To: "party",
SourceRefs: []source.SourceRef{
{SourceID: "session", StartUnitID: 10, EndUnitID: 10},
{SourceID: "session", StartUnitID: 30, EndUnitID: 30},
@@ -136,10 +136,9 @@ func TestSourceReferenceHelpers(t *testing.T) {
func TestLessSortsMalformedReferencesDeterministically(t *testing.T) {
order := testOrder()
events := []dnd.ItemEvent{
{Name: "A", Kind: dnd.ItemEventKindDiscovered, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 999, EndUnitID: 999}}},
{Name: "A", Kind: dnd.ItemEventKindDiscovered, SourceRefs: []source.SourceRef{{SourceID: "other", StartUnitID: 1, EndUnitID: 1}}},
{Name: "A", Kind: dnd.ItemEventKindDiscovered, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 10, EndUnitID: 10}}},
events := []dnd.ItemOccurrence{{ItemID: "item", Name: "A", Kind: dnd.ItemOccurrenceKindDiscovered, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 999, EndUnitID: 999}}},
{ItemID: "item", Name: "A", Kind: dnd.ItemOccurrenceKindDiscovered, SourceRefs: []source.SourceRef{{SourceID: "other", StartUnitID: 1, EndUnitID: 1}}},
{ItemID: "item", Name: "A", Kind: dnd.ItemOccurrenceKindDiscovered, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 10, EndUnitID: 10}}},
}
sort.SliceStable(events, func(left, right int) bool { return Less(order, events[left], events[right]) })
if events[0].SourceRefs[0].StartUnitID != 10 || events[1].SourceRefs[0].SourceID != "other" || events[2].SourceRefs[0].StartUnitID != 999 {
@@ -151,19 +150,28 @@ func testOrder() shared.SourceRefOrder {
return shared.NewSourceRefOrder(&source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 10}, {ID: 20}, {ID: 30}}})
}
func withName(event dnd.ItemEvent, value string) dnd.ItemEvent { event.Name = value; return event }
func withKind(event dnd.ItemEvent, value dnd.ItemEventKind) dnd.ItemEvent {
func withName(event dnd.ItemOccurrence, value string) dnd.ItemOccurrence {
event.Name = value
return event
}
func withKind(event dnd.ItemOccurrence, value dnd.ItemOccurrenceKind) dnd.ItemOccurrence {
event.Kind = value
return event
}
func withFrom(event dnd.ItemEvent, value string) dnd.ItemEvent { event.From = value; return event }
func withTo(event dnd.ItemEvent, value string) dnd.ItemEvent { event.To = value; return event }
func withoutTo(event dnd.ItemEvent) dnd.ItemEvent { event.To = ""; return event }
func withQuantity(event dnd.ItemEvent, value *int) dnd.ItemEvent {
func withFrom(event dnd.ItemOccurrence, value string) dnd.ItemOccurrence {
event.From = value
return event
}
func withTo(event dnd.ItemOccurrence, value string) dnd.ItemOccurrence {
event.To = value
return event
}
func withoutTo(event dnd.ItemOccurrence) dnd.ItemOccurrence { event.To = ""; return event }
func withQuantity(event dnd.ItemOccurrence, value *int) dnd.ItemOccurrence {
event.Quantity = value
return event
}
func withRefs(event dnd.ItemEvent, value []source.SourceRef) dnd.ItemEvent {
func withRefs(event dnd.ItemOccurrence, value []source.SourceRef) dnd.ItemOccurrence {
event.SourceRefs = value
return event
}