11package jsondiff
22
33import (
4- "encoding/json"
5- "reflect"
64 "sort"
75 "strings"
86)
97
108type differ struct {
119 patch Patch
1210 hasher hasher
13- hashmap map [uint64 ]* jsonNode
11+ hashmap map [uint64 ]jsonNode
1412 factorize bool
1513 rationalize bool
1614 invertible bool
15+ targetBytes []byte
1716}
1817
1918func (d * differ ) diff (src , tgt interface {}) {
@@ -24,7 +23,7 @@ func (d *differ) diff(src, tgt interface{}) {
2423}
2524
2625func (d * differ ) compare (ptr pointer , src , tgt interface {}) {
27- if reflect . DeepEqual ( src , tgt ) {
26+ if src == nil && tgt == nil {
2827 return
2928 }
3029 if ! areComparable (src , tgt ) {
@@ -40,6 +39,9 @@ func (d *differ) compare(ptr pointer, src, tgt interface{}) {
4039 }
4140 return
4241 }
42+ if deepValueEqual (src , tgt , typeSwitchKind (src )) {
43+ return
44+ }
4345 size := len (d .patch )
4446
4547 // Values are comparable, but are not
@@ -52,8 +54,10 @@ func (d *differ) compare(ptr pointer, src, tgt interface{}) {
5254 default :
5355 // Generate a replace operation for
5456 // scalar types.
55- d .replace (ptr , src , tgt )
56- return
57+ if ! deepValueEqual (src , tgt , typeSwitchKind (src )) {
58+ d .replace (ptr , src , tgt )
59+ return
60+ }
5761 }
5862 // Rationalize any new operations.
5963 if d .rationalize && len (d .patch ) > size {
@@ -67,29 +71,28 @@ func (d *differ) prepare(ptr pointer, src, tgt interface{}) {
6771 }
6872 // When both values are deeply equals, save
6973 // the location indexed by the value hash.
70- if reflect .DeepEqual (src , tgt ) {
74+ if ! areComparable (src , tgt ) {
75+ return
76+ } else if deepValueEqual (src , tgt , typeSwitchKind (src )) {
7177 k := d .hasher .digest (tgt )
7278 if d .hashmap == nil {
73- d .hashmap = make (map [uint64 ]* jsonNode )
79+ d .hashmap = make (map [uint64 ]jsonNode )
7480 }
75- d .hashmap [k ] = & jsonNode {ptr : ptr , val : tgt }
76- return
77- }
78- if ! areComparable (src , tgt ) {
81+ d .hashmap [k ] = jsonNode {ptr : ptr , val : tgt }
7982 return
8083 }
8184 // At this point, the source and target values
8285 // are non-nil and have comparable types.
83- switch src .(type ) {
86+ switch vsrc := src .(type ) {
8487 case []interface {}:
85- oarr := src .([] interface {})
88+ oarr := vsrc
8689 narr := tgt .([]interface {})
8790
8891 for i := 0 ; i < min (len (oarr ), len (narr )); i ++ {
8992 d .prepare (ptr .appendIndex (i ), oarr [i ], narr [i ])
9093 }
9194 case map [string ]interface {}:
92- oobj := src .( map [ string ] interface {})
95+ oobj := vsrc
9396 nobj := tgt .(map [string ]interface {})
9497
9598 for k , v1 := range oobj {
@@ -103,10 +106,10 @@ func (d *differ) prepare(ptr pointer, src, tgt interface{}) {
103106}
104107
105108func (d * differ ) rationalizeLastOps (ptr pointer , src , tgt interface {}, lastOpIdx int ) {
106- ops := make (Patch , 0 , 2 )
109+ newOps := make (Patch , 0 , 2 )
107110
108111 if d .invertible {
109- ops = ops .append (OperationTest , emptyPtr , ptr , nil , src )
112+ newOps = newOps .append (OperationTest , emptyPtr , ptr , nil , src )
110113 }
111114 // replaceOp represents a single operation that
112115 // replace the source document with the target.
@@ -115,17 +118,18 @@ func (d *differ) rationalizeLastOps(ptr pointer, src, tgt interface{}, lastOpIdx
115118 Path : ptr ,
116119 Value : tgt ,
117120 }
118- ops = append (ops , replaceOp )
121+ newOps = append (newOps , replaceOp )
122+ curOps := d .patch [lastOpIdx :]
119123
120- b2 , _ := json . Marshal ( replaceOp )
121- b1 , _ := json . Marshal (d .patch [ lastOpIdx :] )
124+ newLen := replaceOp . jsonLength ( d . targetBytes )
125+ curLen := curOps . jsonLength (d .targetBytes )
122126
123- // If one operation is cheapest than many small
127+ // If one operation is cheaper than many small
124128 // operations that represents the changes between
125129 // the two objects, replace the last operations.
126- if len ( b1 ) > len ( b2 ) + 2 {
130+ if curLen > newLen {
127131 d .patch = d .patch [:lastOpIdx ]
128- d .patch = append (d .patch , ops ... )
132+ d .patch = append (d .patch , newOps ... )
129133 }
130134}
131135
@@ -135,10 +139,10 @@ func (d *differ) compareObjects(ptr pointer, src, tgt map[string]interface{}) {
135139 cmpSet := make (map [string ]uint8 )
136140
137141 for k := range src {
138- cmpSet [k ] |= ( 1 << 0 )
142+ cmpSet [k ] |= 1 << 0
139143 }
140144 for k := range tgt {
141- cmpSet [k ] |= ( 1 << 1 )
145+ cmpSet [k ] |= 1 << 1
142146 }
143147 for _ , k := range sortedObjectKeys (cmpSet ) {
144148 v := cmpSet [k ]
@@ -189,32 +193,30 @@ func (d *differ) add(ptr pointer, v interface{}) {
189193 idx := d .findRemoved (v )
190194 if idx != - 1 {
191195 op := d .patch [idx ]
196+
192197 // https://tools.ietf.org/html/rfc6902#section-4.4
193198 // The "from" location MUST NOT be a proper prefix
194199 // of the "path" location; i.e., a location cannot
195200 // be moved into one of its children.
196- if ! strings .HasPrefix (ptr . String ( ), op .Path . String ( )) {
201+ if ! strings .HasPrefix (string ( ptr ), string ( op .Path )) {
197202 d .patch = d .patch .remove (idx )
198203 d .patch = d .patch .append (OperationMove , op .Path , ptr , v , v )
199204 }
200205 return
201206 }
202207 uptr := d .findUnchanged (v )
203- if uptr != emptyPtr && ! d .invertible {
208+ if ! uptr . isRoot () && ! d .invertible {
204209 d .patch = d .patch .append (OperationCopy , uptr , ptr , nil , v )
205210 } else {
206211 d .patch = d .patch .append (OperationAdd , emptyPtr , ptr , nil , v )
207212 }
208213}
209214
210- // areComparable returns whether the interfaces values
215+ // areComparable returns whether the interface values
211216// i1 and i2 can be compared. The values are comparable
212217// only if they are both non-nil and share the same kind.
213218func areComparable (i1 , i2 interface {}) bool {
214- typ1 := reflect .TypeOf (i1 )
215- typ2 := reflect .TypeOf (i2 )
216-
217- return typ1 != nil && typ2 != nil && typ1 .Kind () == typ2 .Kind ()
219+ return typeSwitchKind (i1 ) == typeSwitchKind (i2 )
218220}
219221
220222func (d * differ ) replace (ptr pointer , src , tgt interface {}) {
@@ -245,7 +247,7 @@ func (d *differ) findUnchanged(v interface{}) pointer {
245247func (d * differ ) findRemoved (v interface {}) int {
246248 for i := 0 ; i < len (d .patch ); i ++ {
247249 op := d .patch [i ]
248- if op .Type == OperationRemove && reflect . DeepEqual (op .OldValue , v ) {
250+ if op .Type == OperationRemove && deepEqual (op .OldValue , v ) {
249251 return i
250252 }
251253 }
0 commit comments