feat: add MergePatch generation

Author: wI2L

.codecov.yml

@@ -4,5 +4,5 @@ coverage:
     # Prevent small variations of coverage from failing CI.
     project:
       default:
-        threshold: 3%
+        threshold: 5%
     patch: off

README.md

@@ -384,7 +384,7 @@ The resulting patch is empty, because all changes are ignored.
 
 [Run this example](https://pkg.go.dev/github.com/wI2L/jsondiff#example-Ignores).
 
-> See the actual [testcases](testdata/tests/options/ignore.json) for more examples.
+> See the actual [testcases](testdata/tests/jsonpatch/options/ignore.json) for more examples.
 
 #### MarshalFunc / UnmarshalFunc
 

differ.go

@@ -238,7 +238,6 @@ func (d *Differ) compareObjects(ptr pointer, src, tgt map[string]interface{}, do
 		cmpSet[k] |= 1 << 1
 	}
 	keys := make([]string, 0, len(cmpSet))
-
 	for k := range cmpSet {
 		keys = append(keys, k)
 	}

differ_test.go

@@ -26,10 +26,12 @@ type testcase struct {
 
 type patchGetter func(tc *testcase) Patch
 
-func TestRFCCases(t *testing.T)    { runCasesFromFile(t, "testdata/tests/rfc.json", Factorize(), LCS()) } // https://datatracker.ietf.org/doc/html/rfc6902#appendix-A
-func TestArrayCases(t *testing.T)  { runCasesFromFile(t, "testdata/tests/array.json") }
-func TestObjectCases(t *testing.T) { runCasesFromFile(t, "testdata/tests/object.json") }
-func TestRootCases(t *testing.T)   { runCasesFromFile(t, "testdata/tests/root.json") }
+func TestRFCCases(t *testing.T) {
+	runCasesFromFile(t, "testdata/tests/jsonpatch/rfc.json", Factorize(), LCS())
+}                                  // https://datatracker.ietf.org/doc/html/rfc6902#appendix-A
+func TestArrayCases(t *testing.T)  { runCasesFromFile(t, "testdata/tests/jsonpatch/array.json") }
+func TestObjectCases(t *testing.T) { runCasesFromFile(t, "testdata/tests/jsonpatch/object.json") }
+func TestRootCases(t *testing.T)   { runCasesFromFile(t, "testdata/tests/jsonpatch/root.json") }
 
 func TestDiffer_Reset(t *testing.T) {
 	d := &Differ{
@@ -59,28 +61,24 @@ func TestDiffer_Reset(t *testing.T) {
 }
 
 func TestOptions(t *testing.T) {
-	makeopts := func(opts ...Option) []Option { return opts }
+	makeOpts := func(opts ...Option) []Option { return opts }
 
 	for _, tc := range []struct {
-		testfile string
+		testFile string
 		options  []Option
 	}{
-		{"testdata/tests/options/invertible.json", makeopts(Invertible())},
-		{"testdata/tests/options/factorization.json", makeopts(Factorize())},
-		{"testdata/tests/options/rationalization.json", makeopts(Rationalize())},
-		{"testdata/tests/options/equivalence.json", makeopts(Equivalent())},
-		{"testdata/tests/options/ignore.json", makeopts()},
-		{"testdata/tests/options/lcs.json", makeopts(LCS(), Factorize())},
-		{"testdata/tests/options/all.json", makeopts(Factorize(), Rationalize(), Invertible(), Equivalent())},
-		{"testdata/tests/options/lcs+equivalence.json", makeopts(LCS(), Equivalent())},
+		{"testdata/tests/jsonpatch/options/invertible.json", makeOpts(Invertible())},
+		{"testdata/tests/jsonpatch/options/factorization.json", makeOpts(Factorize())},
+		{"testdata/tests/jsonpatch/options/rationalization.json", makeOpts(Rationalize())},
+		{"testdata/tests/jsonpatch/options/equivalence.json", makeOpts(Equivalent())},
+		{"testdata/tests/jsonpatch/options/ignore.json", makeOpts()},
+		{"testdata/tests/jsonpatch/options/lcs.json", makeOpts(LCS(), Factorize())},
+		{"testdata/tests/jsonpatch/options/all.json", makeOpts(Factorize(), Rationalize(), Invertible(), Equivalent())},
+		{"testdata/tests/jsonpatch/options/lcs+equivalence.json", makeOpts(LCS(), Equivalent())},
 	} {
-		var (
-			ext  = filepath.Ext(tc.testfile)
-			base = filepath.Base(tc.testfile)
-			name = strings.TrimSuffix(base, ext)
-		)
+		name := strings.TrimSuffix(filepath.Base(tc.testFile), filepath.Ext(tc.testFile))
 		t.Run(name, func(t *testing.T) {
-			runCasesFromFile(t, tc.testfile, tc.options...)
+			runCasesFromFile(t, tc.testFile, tc.options...)
 		})
 	}
 }
@@ -112,12 +110,12 @@ func runTestCases(t *testing.T, cases []testcase, opts ...Option) {
 		})
 		if tc.Ignores != nil {
 			name = fmt.Sprintf("%s_with_ignore", name)
-			xopts := append(opts, Ignores(tc.Ignores...)) //nolint:gocritic
+			extendedOpts := append(opts, Ignores(tc.Ignores...)) //nolint:gocritic
 
 			t.Run(name, func(t *testing.T) {
 				runTestCase(t, tc, func(tc *testcase) Patch {
 					return tc.PartialPatch
-				}, xopts...)
+				}, extendedOpts...)
 			})
 		}
 	}

example_test.go

@@ -244,3 +244,35 @@ func ExampleUnmarshalFunc() {
 	// {"value":3.14159,"op":"replace","path":"/B"}
 	// {"value":true,"op":"replace","path":"/C"}
 }
+
+func ExampleMergePatch() {
+	src := map[string]interface{}{
+		"foo": "baz",
+		"bar": []string{"a", "b", "c"},
+		"baz": 3.14159,
+	}
+	tgt := map[string]interface{}{
+		"foo": "bar",
+		"bar": []string{"y", "y", "z"},
+	}
+	patch, err := jsondiff.MergePatch(src, tgt)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(patch))
+	// Output:
+	// {"bar":["y","y","z"],"baz":null,"foo":"bar"}
+}
+
+func ExampleMergePatchJSON() {
+	src := `{"a":[1,2,3],"b":{"foo":"bar"}}`
+	tgt := `{"a":[1,2,3],"c":[1,2,3],"d":{"foo":"bar"}}`
+
+	patch, err := jsondiff.MergePatchJSON([]byte(src), []byte(tgt))
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(patch))
+	// Output:
+	// {"b":null,"c":[1,2,3],"d":{"foo":"bar"}}
+}

merge.go

@@ -0,0 +1,99 @@
+package jsondiff
+
+import (
+	"encoding/json"
+)
+
+// MergePatch returns a JSON Merge Patch (RFC 7386)
+// of the differences between the JSON representations
+// of the given values.
+func MergePatch(src, tgt interface{}) ([]byte, error) {
+	opts := options{
+		marshal:   json.Marshal,
+		unmarshal: json.Unmarshal,
+	}
+	si, _, err := marshalUnmarshal(src, opts)
+	if err != nil {
+		return nil, err
+	}
+	ti, _, err := marshalUnmarshal(tgt, opts)
+	if err != nil {
+		return nil, err
+	}
+	patch := mergePatch(si, ti)
+	if patch == nil {
+		return nil, nil
+	}
+	return json.Marshal(patch)
+}
+
+// MergePatchJSON compares the given JSON documents
+// and returns the differences relative to the former
+// as a JSON Merge Patch (RFC 7386)
+func MergePatchJSON(src, tgt []byte) ([]byte, error) {
+	var si, ti interface{}
+	if err := json.Unmarshal(src, &si); err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(tgt, &ti); err != nil {
+		return nil, err
+	}
+	patch := mergePatch(si, ti)
+	if patch == nil {
+		return nil, nil
+	}
+	return json.Marshal(patch)
+}
+
+func mergePatch(src, tgt interface{}) interface{} {
+	if src == nil || tgt == nil {
+		return tgt
+	}
+	// If the target is not of the same type as the source,
+	// or both are not objects, the patch replaces the entire
+	// source with the target.
+	// https://datatracker.ietf.org/doc/html/rfc7386#section-2
+	if jsonTypeSwitch(src) != jsonObject || jsonTypeSwitch(tgt) != jsonObject {
+		return tgt
+	}
+	sm := src.(map[string]interface{})
+	tm := tgt.(map[string]interface{})
+
+	cmpSet := make(map[string]uint8, max(len(sm), len(tm)))
+
+	for k := range sm {
+		cmpSet[k] |= 1 << 0
+	}
+	for k := range tm {
+		cmpSet[k] |= 1 << 1
+	}
+	keys := make([]string, 0, len(cmpSet))
+	for k := range cmpSet {
+		keys = append(keys, k)
+	}
+	sortStrings(keys)
+
+	patch := make(map[string]interface{}, len(sm))
+
+	for _, k := range keys {
+		v := cmpSet[k]
+		inOld := v&(1<<0) != 0
+		inNew := v&(1<<1) != 0
+
+		switch {
+		case inOld && inNew:
+			if !deepEqual(sm[k], tm[k]) {
+				patch[k] = mergePatch(sm[k], tm[k])
+			}
+		case inOld:
+			// Null values in the merge patch are given
+			// special meaning to indicate the removal
+			// of existing values in the target.
+			// https://datatracker.ietf.org/doc/html/rfc7386#section-1
+			patch[k] = nil
+		case inNew:
+			patch[k] = tm[k]
+		}
+	}
+	return patch
+}

merge_test.go

@@ -0,0 +1,46 @@
+package jsondiff
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func Test_mergePatch(t *testing.T) {
+	type testcase struct {
+		Name string      `json:"name"`
+		B    interface{} `json:"before"`
+		A    interface{} `json:"after"`
+		P    interface{} `json:"patch"`
+	}
+	for _, testFile := range []string{
+		"testdata/tests/mergepatch/rfc.json",
+		"testdata/tests/mergepatch/array.json",
+		"testdata/tests/mergepatch/object.json",
+	} {
+		name := strings.TrimSuffix(filepath.Base(testFile), filepath.Ext(testFile))
+
+		t.Run(name, func(t *testing.T) {
+			b, err := os.ReadFile(testFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var cases []testcase
+			if err := json.Unmarshal(b, &cases); err != nil {
+				t.Fatal(err)
+			}
+			for _, tc := range cases {
+				t.Run(tc.Name, func(t *testing.T) {
+					patch := mergePatch(tc.B, tc.A)
+					if !deepEqual(tc.P, patch) {
+						t.Errorf("got %v, want %v", patch, tc.P)
+						t.Logf("source: %v", tc.B)
+						t.Logf("target %v", tc.A)
+					}
+				})
+			}
+		})
+	}
+}

patch_test.go

@@ -55,7 +55,7 @@ func TestPatch_Invert(t *testing.T) {
 		}
 	})
 	t.Run("object", func(t *testing.T) {
-		cases, err := testCasesFromFile(t, "testdata/tests/object.json")
+		cases, err := testCasesFromFile(t, "testdata/tests/jsonpatch/object.json")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -64,7 +64,7 @@ func TestPatch_Invert(t *testing.T) {
 		}
 	})
 	t.Run("array", func(t *testing.T) {
-		cases, err := testCasesFromFile(t, "testdata/tests/array.json")
+		cases, err := testCasesFromFile(t, "testdata/tests/jsonpatch/array.json")
 		if err != nil {
 			t.Fatal(err)
 		}