json-diff 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29a90b679f5bf30e17ce0b2cabd2963a9a68ea03
-  data.tar.gz: 06c46f1cb99d0564522c30507df1f65fbcca003b
+  metadata.gz: 2079e5281095664f9827f175517045a3164b675b
+  data.tar.gz: 6a7d698b88209ed747f621ab609d3a735270fec0
 SHA512:
-  metadata.gz: 613a0223292d0d84d7bf32a46b5f58468336251351fb1d243032172162c24a53c22f56474c1873898c492930d2283227302345febbfccdbdd9cad4c152474174
-  data.tar.gz: c1457cdf32d04f6f368b49b7dde261751ac1c9ef7350578e766ae63a598afa37d10d7e8edb4eb30a2590df9c0cec3bfb3f5dcdfb64b54dcd30f1211161525ee7
+  metadata.gz: bb9cf0f504e1e0892697bee3d5b4beefa7f0eff93fadc57c9bbfccc852a7f4f5c3210a02a74d1d0bc0141887437224182ee5116c9d9e92c2a5506f634d77da0e
+  data.tar.gz: a045d4d6507b8834ce9bc92f8be212777777b94cc15068a362649b608887af9dcb92e8172913bfb82a2230f9c279e366ba99eff972af2a04221cba60ae17d04f

data/.gitignore

@@ -0,0 +1 @@
+json-diff*.gem

data/README.md

@@ -17,6 +17,15 @@ Outputs [RFC6902][]. Look at [hana][] for a JSON patch algorithm that can use th
 [RFC6902]: http://www.rfc-editor.org/rfc/rfc6902.txt
 [hana]: https://github.com/tenderlove/hana
 
+# Options
+
+- `include_was`: include a `was` field in remove and replace operations, to show the old value. Allows computing reverse operations without the source JSON.
+- `moves`\*: include move operations. Set it to false to remove clutter.
+- `additions`\*: include add operations. Se it to false to remove clutter.
+- `original_indices`\*: array indices are those from the source array (for `from` fields, or `path` fields on remove operations) or the target array (for other `path` fields). It eases manual checking of differences.
+
+\* Changing this option prevents the use of the output for JSON patching.
+
 # Heart
 
 - Recursive similarity computation between any two Ruby values.
@@ -34,6 +43,51 @@ Cons:
 - This approach's quality is heavily reliant on how good the similarity algorithm is. Empirically, it yields sensible output. It can be improved by a user-defined procedure.
 - There is a computational overhead to the default similarity computation that scales with the total number of entities in the structure.
 
+# Comparisons
+
+[HashDiff](https://github.com/liufengyun/hashdiff) — LCS, no move operation.
+
+```ruby
+require "json-diff"
+JsonDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2])
+# [{'op' => 'remove', 'path' => '/4'},
+#  {'op' => 'remove', 'path' => '/0'},
+#  {'op' => 'move', 'from' => '/0', 'path' => '/2'},
+#  {'op' => 'move', 'from' => '/1', 'path' => '/0'},
+#  {'op' => 'add', 'path' => '/0', 'value' => 6}]
+
+require "hashdiff"
+HashDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2])
+# [["-", "[0]", 1],
+#  ["+", "[0]", 6],
+#  ["+", "[1]", 4],
+#  ["+", "[2]", 3],
+#  ["-", "[6]", 5],
+#  ["-", "[5]", 4],
+#  ["-", "[4]", 3]]
+```
+
+[jsondiff](https://github.com/francois2metz/jsondiff) — no similitude, no LCS.
+
+```ruby
+require "json-diff"
+JsonDiff.diff(
+  [{'code' => "ABW", 'name' => "Abbey Wood"}, {'code' => "KGX", 'name' => "Kings Cross"}],
+  [{'code' => "KGX", 'name' => "Kings Cross"}, {'code' => "ABW", 'name' => "Abbey Wood"}]
+)
+# [{'op' => 'move', 'from' => '/0', 'path' => '/1'}]
+
+require "jsondiff"
+JsonDiff.generate(
+  [{'code' => "ABW", 'name' => "Abbey Wood"}, {'code' => "KGX", 'name' => "Kings Cross"}],
+  [{'code' => "KGX", 'name' => "Kings Cross"}, {'code' => "ABW", 'name' => "Abbey Wood"}]
+)
+# [{:op => :replace, :path => '/0/code', :value => 'KGX'},
+#  {:op => :replace, :path => '/0/name', :value => 'Kings Cross'},
+#  {:op => :replace, :path => '/1/code', :value => 'ABW'},
+#  {:op => :replace, :path => '/1/name', :value => 'Abbey Wood'}]
+```
+
 # Plans & Bugs
 
 Roughly ordered by priority.

data/lib/json-diff/diff.rb

@@ -4,17 +4,19 @@ module JsonDiff
     path = opts[:path] || '/'
     include_addition = (opts[:additions] == nil) ? true : opts[:additions]
     include_moves = (opts[:moves] == nil) ? true : opts[:moves]
+    include_was = (opts[:include_was] == nil) ? false : opts[:include_was]
+    original_indices = (opts[:original_indices] == nil) ? false : opts[:original_indices]
 
     changes = []
 
     if before.is_a?(Hash)
       if !after.is_a?(Hash)
-        changes << replace(path, before, after)
+        changes << replace(path, include_was ? before : nil, after)
       else
         lost = before.keys - after.keys
         lost.each do |key|
           inner_path = extend_json_pointer(path, key)
-          changes << remove(inner_path, before[key])
+          changes << remove(inner_path, include_was ? before[key] : nil)
         end
 
         if include_addition
@@ -33,7 +35,7 @@ module JsonDiff
       end
     elsif before.is_a?(Array)
       if !after.is_a?(Array)
-        changes << replace(path, before, after)
+        changes << replace(path, include_was ? before : nil, after)
       elsif before.size == 0
         if include_addition
           after.each_with_index do |item, index|
@@ -45,7 +47,7 @@ module JsonDiff
         before.each do |item|
           # Delete elements from the start.
           inner_path = extend_json_pointer(path, 0)
-          changes << remove(inner_path, item)
+          changes << remove(inner_path, include_was ? item : nil)
         end
       else
         pairing = array_pairing(before, after)
@@ -63,22 +65,31 @@ module JsonDiff
           kept
         end
 
-        array_changes(pairing)
+        pairing[:pairs].each do |pair|
+          before_index, after_index = pair
+          inner_path = extend_json_pointer(path, before_index)
+          changes += diff(before[before_index], after[after_index], opts.merge(path: inner_path))
+        end
+
+        if !original_indices
+          # Recompute indices to account for offsets from insertions and
+          # deletions.
+          pairing = array_changes(pairing)
+        end
 
         pairing[:removed].each do |before_index|
           inner_path = extend_json_pointer(path, before_index)
-          changes << remove(inner_path, before[before_index])
+          changes << remove(inner_path, include_was ? before[before_index] : nil)
         end
 
         pairing[:pairs].each do |pair|
-          before_index, after_index, orig_before, orig_after = pair
+          before_index, after_index = pair
           inner_before_path = extend_json_pointer(path, before_index)
           inner_after_path = extend_json_pointer(path, after_index)
 
           if before_index != after_index && include_moves
             changes << move(inner_before_path, inner_after_path)
           end
-          changes += diff(before[orig_before], after[orig_after], opts.merge(path: inner_after_path))
         end
 
         if include_addition
@@ -90,7 +101,7 @@ module JsonDiff
       end
     else
       if before != after
-        changes << replace(path, before, after)
+        changes << replace(path, include_was ? before : nil, after)
       end
     end
 
@@ -168,7 +179,8 @@ module JsonDiff
     }
   end
 
-  # Compute an arbitrary notion of how probable it is that
+  # Compute an arbitrary notion of how probable it is that one object is the
+  # result of modifying the other.
   def self.similarity(before, after)
     return 0.0 if before.class != after.class
 
@@ -189,6 +201,11 @@ module JsonDiff
       before.each do |before_key, before_item|
         similarities << similarity(before_item, after[before_key])
       end
+      # Also consider keys' names.
+      before_keys = before.keys
+      after_keys = after.keys
+      key_similarity = (before_keys & after_keys).size / (before_keys | after_keys).size
+      similarities << key_similarity
 
       similarities.reduce(:+) / similarities.size
     elsif before.is_a?(Array)

data/lib/json-diff/operation.rb

@@ -24,24 +24,28 @@ module JsonDiff
     end
   end
 
+  def self.replace(path, before, after)
+    if before != nil
+      {'op' => 'replace', 'path' => path, 'was' => before, 'value' => after}
+    else
+      {'op' => 'replace', 'path' => path, 'value' => after}
+    end
+  end
+
   def self.add(path, value)
-    {op: :add, path: path, value: value}
+    {'op' => 'add', 'path' => path, 'value' => value}
   end
 
   def self.remove(path, value)
     if value != nil
-      {op: :remove, path: path, value: value}
+      {'op' => 'remove', 'path' => path, 'was' => value}
     else
-      {op: :remove, path: path}
+      {'op' => 'remove', 'path' => path}
     end
   end
 
-  def self.replace(path, value)
-    {op: :replace, path: path, value: value}
-  end
-
   def self.move(source, target)
-    {op: :move, from: source, path: target}
+    {'op' => 'move', 'from' => source, 'path' => target}
   end
 
 end

data/lib/json-diff/version.rb

@@ -1,3 +1,3 @@
 module JsonDiff
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/json-diff/diff_spec.rb

@@ -1,57 +1,119 @@
 require 'spec_helper'
 
 describe JsonDiff do
+  # Arrays
+
   it "should be able to diff two empty arrays" do
     diff = JsonDiff.diff([], [])
     expect(diff).to eql([])
   end
 
   it "should be able to diff an empty array with a filled one" do
-    diff = JsonDiff.diff([], [1, 2, 3])
+    diff = JsonDiff.diff([], [1, 2, 3], include_was: true)
     expect(diff).to eql([
-      {op: :add, path: "/0", value: 1},
-      {op: :add, path: "/1", value: 2},
-      {op: :add, path: "/2", value: 3},
+      {'op' => 'add', 'path' => "/0", 'value' => 1},
+      {'op' => 'add', 'path' => "/1", 'value' => 2},
+      {'op' => 'add', 'path' => "/2", 'value' => 3},
     ])
   end
 
   it "should be able to diff a filled array with an empty one" do
-    diff = JsonDiff.diff([1, 2, 3], [])
+    diff = JsonDiff.diff([1, 2, 3], [], include_was: true)
     expect(diff).to eql([
-      {op: :remove, path: "/0", value: 1},
-      {op: :remove, path: "/0", value: 2},
-      {op: :remove, path: "/0", value: 3},
+      {'op' => 'remove', 'path' => "/0", 'was' => 1},
+      {'op' => 'remove', 'path' => "/0", 'was' => 2},
+      {'op' => 'remove', 'path' => "/0", 'was' => 3},
     ])
   end
 
   it "should be able to diff a 1-array with a filled one" do
-    diff = JsonDiff.diff([0], [1, 2, 3])
+    diff = JsonDiff.diff([0], [1, 2, 3], include_was: true)
     expect(diff).to eql([
-      {op: :remove, path: "/0", value: 0},
-      {op: :add, path: "/0", value: 1},
-      {op: :add, path: "/1", value: 2},
-      {op: :add, path: "/2", value: 3},
+      {'op' => 'remove', 'path' => "/0", 'was' => 0},
+      {'op' => 'add', 'path' => "/0", 'value' => 1},
+      {'op' => 'add', 'path' => "/1", 'value' => 2},
+      {'op' => 'add', 'path' => "/2", 'value' => 3},
     ])
   end
 
   it "should be able to diff a filled array with a 1-array" do
-    diff = JsonDiff.diff([1, 2, 3], [0])
+    diff = JsonDiff.diff([1, 2, 3], [0], include_was: true)
     expect(diff).to eql([
-      {op: :remove, path: "/2", value: 3},
-      {op: :remove, path: "/1", value: 2},
-      {op: :remove, path: "/0", value: 1},
-      {op: :add, path: "/0", value: 0},
+      {'op' => 'remove', 'path' => "/2", 'was' => 3},
+      {'op' => 'remove', 'path' => "/1", 'was' => 2},
+      {'op' => 'remove', 'path' => "/0", 'was' => 1},
+      {'op' => 'add', 'path' => "/0", 'value' => 0},
     ])
   end
 
   it "should be able to diff two integer arrays" do
-    diff = JsonDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2])
+    diff = JsonDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2], include_was: true)
+    expect(diff).to eql([
+      {'op' => 'remove', 'path' => "/4", 'was' => 5},
+      {'op' => 'remove', 'path' => "/0", 'was' => 1},
+      {'op' => 'move', 'from' => "/0", 'path' => "/2"},
+      {'op' => 'move', 'from' => "/1", 'path' => "/0"},
+      {'op' => 'add', 'path' => "/0", 'value' => 6},
+    ])
+  end
+
+  it "should be able to diff two arrays with mixed content" do
+    diff = JsonDiff.diff(["laundry", 12, {'pillar' => 0}, true], [true, {'pillar' => 1}, 3, 12], include_was: true)
+    expect(diff).to eql([
+      {'op' => 'replace', 'path' => "/2/pillar", 'was' => 0, 'value' => 1},
+      {'op' => 'remove', 'path' => "/0", 'was' => "laundry"},
+      {'op' => 'move', 'from' => "/2", 'path' => "/0"},
+      {'op' => 'move', 'from' => "/1", 'path' => "/2"},
+      {'op' => 'add', 'path' => "/2", 'value' => 3},
+    ])
+  end
+
+  # Objects
+
+  it "should be able to diff two objects with mixed content" do
+    diff = JsonDiff.diff(
+      {'string' => "laundry", 'number' => 12, 'object' => {'pillar' => 0}, 'list' => [2, 4, 1], 'bool' => false, 'null' => nil},
+      {'string' => "laundry", 'number' => 12, 'object' => {'pillar' => 1}, 'list' => [1, 2, 3], 'bool' => true, 'null' => nil},
+      include_was: true)
+    expect(diff).to eql([
+      {'op' => 'replace', 'path' => "/object/pillar", 'was' => 0, 'value' => 1},
+      {'op' => 'remove', 'path' => "/list/1", 'was' => 4},
+      {'op' => 'move', 'from' => "/list/0", 'path' => "/list/1"},
+      {'op' => 'add', 'path' => "/list/2", 'value' => 3},
+      {'op' => 'replace', 'path' => "/bool", 'was' => false, 'value' => true},
+    ])
+  end
+
+  # Options
+
+  it "should be able to diff two integer arrays with original indices" do
+    diff = JsonDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2], original_indices: true)
+    expect(diff).to eql([
+      {'op' => 'remove', 'path' => "/4"},
+      {'op' => 'remove', 'path' => "/0"},
+      {'op' => 'move', 'from' => "/1", 'path' => "/3"},
+      {'op' => 'move', 'from' => "/3", 'path' => "/1"},
+      {'op' => 'add', 'path' => "/0", 'value' => 6},
+    ])
+  end
+
+  it "should be able to diff two integer arrays without move operations" do
+    diff = JsonDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2], moves: false)
+    expect(diff).to eql([
+      {'op' => 'remove', 'path' => "/4"},
+      {'op' => 'remove', 'path' => "/0"},
+      {'op' => 'add', 'path' => "/0", 'value' => 6},
+    ])
+  end
+
+  it "should be able to diff two integer arrays without add operations" do
+    diff = JsonDiff.diff([1, 2, 3, 4, 5], [6, 4, 3, 2], additions: false)
     expect(diff).to eql([
-      {op: :remove, path: "/4", value: 5},
-      {op: :remove, path: "/0", value: 1},
-      {op: :move, from: "/0", path: "/2"},
-      {op: :move, from: "/1", path: "/0"},
-      {op: :add, path: "/0", value: 6},
+      {'op' => 'remove', 'path' => "/4"},
+      {'op' => 'remove', 'path' => "/0"},
+      {'op' => 'move', 'from' => "/0", 'path' => "/2"},
+      {'op' => 'move', 'from' => "/1", 'path' => "/0"},
     ])
   end
+
 end

data/spec/json-diff/index-map_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe JsonDiff do
+  # AdditionIndexMap
+
+  it "should be able to offset an index" do
+    aim = JsonDiff::AdditionIndexMap.new(3)
+    expect(aim.map(2)).to eql(2)
+    expect(aim.map(3)).to eql(4)
+    expect(aim.map(4)).to eql(5)
+  end
+
+  it "should be able to offset an index negatively" do
+    rim = JsonDiff::RemovalIndexMap.new(3)
+    expect(rim.map(2)).to eql(2)
+    expect(rim.map(3)).to eql(2)
+    expect(rim.map(4)).to eql(3)
+  end
+
+  # IndexMaps
+
+  it "should be able to offset an index with a deletion and an insertion" do
+    im = JsonDiff::IndexMaps.new
+    im.removal(2)
+    im.addition(4)
+    expect(im.map(1)).to eql(1)
+    expect(im.map(2)).to eql(1)
+    expect(im.map(3)).to eql(2)
+    expect(im.map(4)).to eql(3)
+    expect(im.map(5)).to eql(5)
+  end
+
+  it "should be able to offset an index with an insertion and a deletion" do
+    im = JsonDiff::IndexMaps.new
+    im.addition(2)
+    im.removal(4)
+    expect(im.map(1)).to eql(1)
+    expect(im.map(2)).to eql(3)
+    expect(im.map(3)).to eql(3)
+    expect(im.map(4)).to eql(4)
+    expect(im.map(5)).to eql(5)
+  end
+
+end

data/spec/json-diff/operation_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe JsonDiff do
+  it "should convert the root to a JSON pointer" do
+    json_pointer = JsonDiff.json_pointer([])
+    expect(json_pointer).to eql("/")
+  end
+
+  it "should convert a path to a JSON pointer" do
+    json_pointer = JsonDiff.json_pointer(["path", "to", 1, "soul"])
+    expect(json_pointer).to eql("/path/to/1/soul")
+  end
+
+  it "should escape a path" do
+    json_pointer = JsonDiff.json_pointer(["a/b", "c%d", "e^f", "g|h", "i\\j", "k\"l", " ", "m~n"])
+    expect(json_pointer).to eql("/a~1b/c%d/e^f/g|h/i\\j/k\"l/ /m~0n")
+  end
+
+  it "should expand a path" do
+    json_pointer = JsonDiff.json_pointer(["path", "to", 1, "soul"])
+    json_pointer = JsonDiff.extend_json_pointer(json_pointer, "further")
+    expect(json_pointer).to eql("/path/to/1/soul/further")
+  end
+
+  it "should expand an empty path" do
+    json_pointer = JsonDiff.json_pointer([])
+    json_pointer = JsonDiff.extend_json_pointer(json_pointer, "further")
+    expect(json_pointer).to eql("/further")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-diff
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Captain Train
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-11 00:00:00.000000000 Z
+date: 2016-06-13 00:00:00.000000000 Z
 dependencies: []
 description: Take two Ruby objects that can be serialized to JSON. Output an array
   of operations (additions, deletions, moves) that would convert the first one to
@@ -19,6 +19,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
 - .rspec
 - Gemfile
 - LICENSE
@@ -32,6 +33,8 @@ files:
 - lib/json-diff/operation.rb
 - lib/json-diff/version.rb
 - spec/json-diff/diff_spec.rb
+- spec/json-diff/index-map_spec.rb
+- spec/json-diff/operation_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/captaintrain/json-diff
 licenses: