first commit

Author: 520MianXiangDuiXiang520

.gitignore

@@ -0,0 +1,19 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Go template
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+.idea
+

README.md

@@ -0,0 +1,127 @@
+# Json-Diff
+
+[RFC 6092](https://tools.ietf.org/html/rfc6902) 的 Go 语言实现
+
+## 功能：
+
+* 不依赖于 `struct` 的 JSON 的序列化与反序列化
+* 两个 JSON 串的差异比较
+* 根据差异还原原 JSON 串
+
+## 使用
+
+```shell
+go get -u github.com/520MianXiangDuiXiang520/json-diff
+```
+
+### 序列化与反序列化
+
+```go
+func ExampleUnmarshal() {
+    json := `{
+        "A": 2,
+        "B": [1, 2, 4],
+        "C": {
+          "CA": {"CAA": 1}
+        }
+      }`
+    jsonNode := Unmarshal([]byte(json))
+    fmt.Println(jsonNode)
+}
+```
+
+`Unmarshal()` 将任意合法的 JSON 串反序列化成 `*JsonNode` 类型，基于该类型，可以更方便地操作 JSON 对象
+
+`JsonNode` 包含以下方法：
+
+* `Find(path string)`: 从当前 `JsonNode` 中找到满足 path 的子对象并返回， 如要查找 `CAA`, path 为 `/C/CA/CAA`
+* `Equal(*JsonNode)`: 判断两个对象是否相等
+* `ADD(key interface{}, value *JsonNode)`: 根据 key 向当前对象插入一个子对象
+* `Replace(key interface{}, value *JsonNode)`: 根据 key 替换
+* `Remove(key interface{})`: 根据 key shanc
+* ...
+
+`JsonNode` 对象可以使用 `Marshal()` 方法序列化成 JSON 字符数组
+
+### diff
+
+diff 遵循 RFC 6092 规范，两个 JSON 串的差异被分为 6 类：
+
+1. `add`: 新增
+2. `replace`: 替换
+3. `remove`: 删除
+4. `move`: 移动
+5. `copy`: 复制
+6. `test`: 测试
+
+他们的格式如下：
+
+```json
+   [
+     { "op": "test", "path": "/a/b/c", "value": "foo" },
+     { "op": "remove", "path": "/a/b/c" },
+     { "op": "add", "path": "/a/b/c", "value": [ "foo", "bar" ] },
+     { "op": "replace", "path": "/a/b/c", "value": 42 },
+     { "op": "move", "from": "/a/b/c", "path": "/a/b/d" },
+     { "op": "copy", "from": "/a/b/d", "path": "/a/b/e" }
+   ]
+```
+
+> * `test` 用于还原时测试路径下的值是否与 value 相等
+
+```go
+func ExampleAsDiffs() {
+    json1 := `{
+        "A": 1,
+        "B": [1, 2, 3],
+        "C": {
+          "CA": 1
+        }
+      }`
+    json2 := `{
+        "A": 2,
+        "B": [1, 2, 4],
+        "C": {
+          "CA": {"CAA": 1}
+        }
+      }`
+    res, _ := AsDiffs([]byte(json1), []byte(json2))
+    fmt.Println(res)
+}
+```
+
+使用 `AsDiffs()` 函数获取两个 JSON 串的差异，`AsDiffs()` 接收一组可选的参数 `JsonDiffOption` 他们的取值如下：
+
+```go
+   // 返回差异时使用 Copy, 当发现新增的子串出现在原串中时，使用该选项可以将 Add 行为替换为 Copy 行为
+    // 以减少差异串的大小，但这需要额外的计算，默认不开启
+    UseCopyOption JsonDiffOption = 1 << iota
+    
+    // 仅在 UseCopyOption 选项开启时有效，替换前会添加 Test 行为，以确保 Copy 的路径存在
+    UseCheckCopyOption
+    
+    // 返回差异时使用 Copy, 当发现差异串中两个 Add 和 Remove 的值相等时，会将他们合并为一个 Move 行为
+    // 以此减少差异串的大小，默认不开启
+    UseMoveOption
+    
+    // Remove 时除了返回 path, 还返回删除了的值，默认不开启
+    UseFullRemoveOption
+```
+
+即默认情况下，差异串只有 `add, replace, remove` 三种， `remove` 也只会返回 path, 更改默认行为可以传入需要的 JsonDiffOption, 如：
+
+```go
+res, _ := AsDiffs([]byte(json1), []byte(json2), UseMoveOption, UseCopyOption, UseFullRemoveOption)
+fmt.Println(res)
+```
+
+## 其他
+
+什么样的两个 JSON 对象被认为是相等的：
+
+* 对于一个对象 `{}`，顺序无关
+* 对于一个列表 `[]`, 顺序相关
+
+## 参考
+
+[https://github.com/flipkart-incubator/zjsonpatch](https://github.com/flipkart-incubator/zjsonpatch)

deepcopy.go

@@ -0,0 +1,14 @@
+package json_diff
+
+import (
+	"bytes"
+	"encoding/gob"
+)
+
+func DeepCopy(dst, src interface{}) error {
+	var buf bytes.Buffer
+	if err := gob.NewEncoder(&buf).Encode(src); err != nil {
+		return err
+	}
+	return gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
+}

deepcopy_test.go

@@ -0,0 +1,44 @@
+package json_diff
+
+import (
+	"io/ioutil"
+	"testing"
+)
+
+func TestDeepCopy(t *testing.T) {
+	fileName := "./test_data/mergeSmoke.json"
+	input, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		t.Error("fail to open the ", fileName)
+	}
+	src := Unmarshal(input)
+	type args struct {
+		dst interface{}
+		src interface{}
+	}
+	dst := new(JsonNode)
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{name: "smoke", args: args{
+			dst: dst,
+			src: src,
+		}, wantErr: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := DeepCopy(tt.args.dst, tt.args.src); (err != nil) != tt.wantErr {
+				t.Errorf("DeepCopy() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if dst == nil || !dst.Equal(src) {
+				t.Errorf("Values are not equal after DeepCopy, dst is %v, but src is %v", dst, src)
+			}
+			dst.Value = "dst"
+			if dst.Value == src.Value {
+				t.Errorf("dst and src point to the same object")
+			}
+		})
+	}
+}

diffdoc.go

@@ -0,0 +1,65 @@
+package json_diff
+
+type DiffType int
+
+// RFC6902 https://tools.ietf.org/html/rfc6902
+const (
+	DiffTypeAdd = iota + 1
+	DiffTypeRemove
+	DiffTypeReplace
+	DiffTypeMove
+	DiffTypeCopy
+	DiffTypeTest
+)
+
+func translateDiffType(t DiffType) string {
+	switch t {
+	case DiffTypeAdd:
+		return "add"
+	case DiffTypeCopy:
+		return "copy"
+	case DiffTypeMove:
+		return "move"
+	case DiffTypeRemove:
+		return "remove"
+	case DiffTypeReplace:
+		return "replace"
+	case DiffTypeTest:
+		return "test"
+	}
+	return ""
+}
+
+var diffTypeTable = map[string]DiffType{
+	"add":     DiffTypeAdd,
+	"remove":  DiffTypeRemove,
+	"move":    DiffTypeMove,
+	"replace": DiffTypeReplace,
+	"copy":    DiffTypeCopy,
+	"test":    DiffTypeTest,
+}
+
+func stringToDiffType(s string) (DiffType, bool) {
+	v, ok := diffTypeTable[s]
+	return v, ok
+}
+
+func newDiffNode(diffType DiffType, path string, value *JsonNode, from string, opt JsonDiffOption) *JsonNode {
+	n := &JsonNode{
+		Type:        JsonNodeTypeObject,
+		ChildrenMap: make(map[string]*JsonNode),
+	}
+	_ = n.ADD("op", NewValueNode(translateDiffType(diffType), 1))
+	_ = n.ADD("path", NewValueNode(path, 1))
+	switch diffType {
+	case DiffTypeAdd, DiffTypeTest, DiffTypeReplace:
+		_ = n.ADD("value", value)
+	case DiffTypeMove, DiffTypeCopy:
+		_ = n.ADD("from", NewValueNode(from, 1))
+	case DiffTypeRemove:
+		if opt&UseFullRemoveOption == UseFullRemoveOption {
+			_ = n.ADD("value", value)
+		}
+	}
+	return n
+}

doc.go

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2021 Junebao
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package json-diff : Go language implementation of RFC6902 https://tools.ietf.org/html/rfc6902
+package json_diff

go.mod

@@ -0,0 +1,3 @@
+module github.com/520MianXiangDuiXiang520/json-diff
+
+go 1.14

hash.go

@@ -0,0 +1,58 @@
+package json_diff
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"sort"
+	"strings"
+)
+
+func hashByMD5(s []byte) string {
+	h := md5.New()
+	h.Write(s)
+	cipherStr := h.Sum(nil)
+	return hex.EncodeToString(cipherStr)
+
+}
+
+func hash(v interface{}) string {
+	return hashByMD5([]byte(fmt.Sprintf("%v", v)))
+}
+
+func setHash(node *JsonNode) string {
+	var hashCode string
+	switch node.Type {
+	case JsonNodeTypeObject:
+		hashCode = setObjectHash(node)
+	case JsonNodeTypeSlice:
+		hashCode = setSliceHash(node)
+	case JsonNodeTypeValue:
+		hashCode = hash(node.Value)
+		node.Hash = hashCode
+	}
+	return hashCode
+}
+
+func setObjectHash(node *JsonNode) string {
+	hashList := make([]string, len(node.ChildrenMap))
+	for _, v := range node.ChildrenMap {
+		hc := setHash(v)
+		hashList = append(hashList, hc)
+	}
+	sort.Strings(hashList)
+	hashCode := hash(strings.Join(hashList, ""))
+	node.Hash = hashCode
+	return hashCode
+}
+
+func setSliceHash(node *JsonNode) string {
+	h := bytes.NewBufferString("")
+	for _, v := range node.Children {
+		hc := setHash(v)
+		h.WriteString(hc)
+	}
+	node.Hash = hash(h)
+	return node.Hash
+}

hash_test.go

@@ -0,0 +1,23 @@
+package json_diff
+
+import (
+	"io/ioutil"
+	"testing"
+)
+
+func Test_setHash(t *testing.T) {
+	fileName := "./test_data/hash_test.json"
+	input, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		t.Error("fail to open the ", fileName)
+	}
+	inputNode := Unmarshal(input)
+	hashCode := setHash(inputNode)
+	for i := 0; i < 100; i++ {
+		inputNode := Unmarshal(input)
+		hc := setHash(inputNode)
+		if hc != hashCode {
+			t.Errorf("Get a different hashcode(%s)", hc)
+		}
+	}
+}