conformance

type Doc ¶

type Doc struct {
	Title  string            `json:"title"`
	Status string            `json:"status"`
	Score  int               `json:"score"`
	Meta   Meta              `json:"meta"`
	Items  []Item            `json:"items"`
	Tags   []string          `json:"tags"`
	Fields map[string]string `json:"fields"`
}

Doc is the corpus model: scalars, a nested struct, a keyed slice, a plain slice, and a map — one of each shape a patch has to address.

No field uses `omitempty`, deliberately. It makes a zero value and an absent field the same bytes, so a patch that sets a field to its zero produces JSON a receiver cannot distinguish from one where the field was never there — and a JavaScript replica then disagrees with Go about the document while both applied the same operations. A model that syncs across languages should leave it off; see docs/wire-patch.md.

func (t *Doc) Clone() *Doc

func (t *Doc) Diff(other *Doc) deep.Patch[Doc]

func (t *Doc) Equal(other *Doc) bool

func (t *Doc) Patch(p deep.Patch[Doc], logger *slog.Logger) error

type Item ¶

type Item struct {
	ID    string `deep:"key" json:"id"`
	Label string `json:"label"`
	Count int    `json:"count"`
	Done  bool   `json:"done"`
}

Item is an element with an identity: diffs address it as /items/<id>.

func (t *Item) Clone() *Item

func (t *Item) Diff(other *Item) deep.Patch[Item]

func (t *Item) Equal(other *Item) bool

func (t *Item) Patch(p deep.Patch[Item], logger *slog.Logger) error

type Meta ¶

type Meta struct {
	Owner string `json:"owner"`
	Level int    `json:"level"`
}

Meta is a nested object.

func (t *Meta) Clone() *Meta

func (t *Meta) Diff(other *Meta) deep.Patch[Meta]

func (t *Meta) Equal(other *Meta) bool

func (t *Meta) Patch(p deep.Patch[Meta], logger *slog.Logger) error

type Odd ¶

type Odd struct {
	Ratio int    `json:"a/b"`
	Tilde int    `json:"c~d"`
	Plain string `json:"plain"`
}

Odd carries JSON names that need RFC 6901 escaping when they become path tokens. It is generated, so its case covers the generator's escaping; the reflection engine's is covered by a unit test in the root package. Both must produce the same paths, or a patch means one thing to a Go peer and another to everyone else.

func (t *Odd) Clone() *Odd

func (t *Odd) Diff(other *Odd) deep.Patch[Odd]

func (t *Odd) Equal(other *Odd) bool

func (t *Odd) Patch(p deep.Patch[Odd], logger *slog.Logger) error

type Plain ¶

type Plain struct {
	Label  string         `json:"label"`
	Depth  int            `json:"depth"`
	Nested PlainNested    `json:"nested"`
	Values map[string]int `json:"values"`
	// No json tag: there is nothing to call this but its Go name.
	Untagged string
	// Kept out of the document, and so out of patches, equality and clones.
	Secret string `json:"-"`
}

Plain is deliberately absent from the go:generate list above, so a diff of it goes through the reflection engine. Its cases prove that both engines name fields the same way — a reflection engine that named them the Go way would produce patches no other language could apply.

type PlainNested ¶

type PlainNested struct {
	Owner string `json:"owner"`
}

PlainNested is likewise ungenerated.