Merge pull request #34 from kevindew/array_path

Introduce an array_path option

Author: liufengyun

README.md

@@ -72,8 +72,8 @@ diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-
 patch example:
 
 ```ruby
-a = {a: 3}
-b = {a: {a1: 1, a2: 2}}
+a = {'a' => 3}
+b = {'a' => {'a1' => 1, 'a2' => 2}}
 
 diff = HashDiff.diff(a, b)
 HashDiff.patch!(a, diff).should == b
@@ -82,17 +82,18 @@ HashDiff.patch!(a, diff).should == b
 unpatch example:
 
 ```ruby
-a = [{a: 1, b: 2, c: 3, d: 4, e: 5}, {x: 5, y: 6, z: 3}, 1]
-b = [1, {a: 1, b: 2, c: 3, e: 5}]
+a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, {'x' => 5, 'y' => 6, 'z' => 3}, 1]
+b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
 
 diff = HashDiff.diff(a, b) # diff two array is OK
 HashDiff.unpatch!(b, diff).should == a
 ```
 
 ### Options
 
-There are six options available: `:delimiter`, `:similarity`,
-`:strict`, `:numeric_tolerance`, `:strip` and `:case_insensitive`.
+There are seven options available: `:delimiter`, `:similarity`,
+`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`
+and `:array_path`.
 
 #### `:delimiter`
 
@@ -140,7 +141,7 @@ diff.should == [["~", "x", 5, 6]]
 
 #### `:case_insensitive`
 
-The :case_insensitive option makes string comparisions ignore case.
+The :case_insensitive option makes string comparisons ignore case.
 
 ```ruby
 a = {x:5, s:'FooBar'}
@@ -150,6 +151,39 @@ diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_ins
 diff.should == [["~", "x", 5, 6]]
 ```
 
+#### `:array_path`
+
+The :array_path option represents the path of the diff in an array rather than
+a string. This can be used to show differences in between hash key types and
+is useful for `patch!` when used on hashes without string keys.
+
+```ruby
+a = {x:5}
+b = {'x'=>6}
+
+diff = HashDiff.diff(a, b, :array_path => true)
+diff.should == [['-', [:x], 5], ['+', ['x'], 6]]
+```
+
+For cases where there are arrays in paths their index will be added to the path.
+```ruby
+a = {x:[0,1]}
+b = {x:[0,2]}
+
+diff = HashDiff.diff(a, b, :array_path => true)
+diff.should == [["-", [:x, 1], 1], ["+", [:x, 1], 2]]
+```
+
+This shouldn't cause problems if you are comparing an array with a hash:
+
+```ruby
+a = {x:{0=>1}}
+b = {x:[1]}
+
+diff = HashDiff.diff(a, b, :array_path => true)
+diff.should == [["~", [:a], [1], {0=>1}]]
+```
+
 #### Specifying a custom comparison method
 
 It's possible to specify how the values of a key should be compared.
@@ -186,6 +220,8 @@ diff.should == [["~", "a", "car", "bus"], ["~", "b[1]", "plane", " plan"], ["-",
 
 When a comparison block is given, it'll be given priority over other specified options. If the block returns value other than `true` or `false`, then the two values will be compared with other specified options.
 
+When used in conjunction with the `array_path` option, the path passed in as an argument will be an array. When determining the ordering of an array a key of `"*"` will be used in place of the `key[*]` field. It is possible, if you have hashes with integer or `"*"` keys, to have problems distinguishing between arrays and hashes - although this shouldn't be an issue unless your data is very difficult to predict and/or your custom rules are very specific.
+
 #### Sorting arrays before comparison
 
 An order difference alone between two arrays can create too many diffs to be useful. Consider sorting them prior to diffing.

lib/hashdiff/diff.rb

@@ -11,6 +11,7 @@ module HashDiff
   #   * :delimiter (String) ['.'] the delimiter used when returning nested key references
   #   * :numeric_tolerance (Numeric) [0] should be a positive numeric value.  Value by which numeric differences must be greater than.  By default, numeric values are compared exactly; with the :tolerance option, the difference between numeric values must be greater than the given value.
   #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
+  #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
   #
   # @yield [path, value1, value2] Optional block is used to compare each value, instead of default #==. If the block returns value other than true of false, then other specified comparison options will be used to do the comparison.
   #
@@ -53,6 +54,7 @@ def self.best_diff(obj1, obj2, options = {}, &block)
   #   * :delimiter (String) ['.'] the delimiter used when returning nested key references
   #   * :numeric_tolerance (Numeric) [0] should be a positive numeric value.  Value by which numeric differences must be greater than.  By default, numeric values are compared exactly; with the :tolerance option, the difference between numeric values must be greater than the given value.
   #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
+  #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
   #
   # @yield [path, value1, value2] Optional block is used to compare each value, instead of default #==. If the block returns value other than true of false, then other specified comparison options will be used to do the comparison.
   #
@@ -74,9 +76,12 @@ def self.diff(obj1, obj2, options = {}, &block)
       :delimiter   =>   '.',
       :strict      =>   true,
       :strip       =>   false,
-      :numeric_tolerance => 0
+      :numeric_tolerance => 0,
+      :array_path  =>   false
     }.merge!(options)
 
+    opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
+
     opts[:comparison] = block if block_given?
 
     # prefer to compare with provided block
@@ -104,51 +109,53 @@ def self.diff(obj1, obj2, options = {}, &block)
       changeset = diff_array(obj1, obj2, opts) do |lcs|
         # use a's index for similarity
         lcs.each do |pair|
-          result.concat(diff(obj1[pair[0]], obj2[pair[1]], opts.merge(:prefix => "#{opts[:prefix]}[#{pair[0]}]")))
+          prefix = prefix_append_array_index(opts[:prefix], pair[0], opts)
+          result.concat(diff(obj1[pair[0]], obj2[pair[1]], opts.merge(:prefix => prefix)))
         end
       end
 
       changeset.each do |change|
+        change_key = prefix_append_array_index(opts[:prefix], change[1], opts)
         if change[0] == '-'
-          result << ['-', "#{opts[:prefix]}[#{change[1]}]", change[2]]
+          result << ['-', change_key, change[2]]
         elsif change[0] == '+'
-          result << ['+', "#{opts[:prefix]}[#{change[1]}]", change[2]]
+          result << ['+', change_key, change[2]]
         end
       end
     elsif obj1.is_a?(Hash)
-      if opts[:prefix].empty?
-        prefix = ""
-      else
-        prefix = "#{opts[:prefix]}#{opts[:delimiter]}"
-      end
 
       deleted_keys = obj1.keys - obj2.keys
       common_keys = obj1.keys & obj2.keys
       added_keys = obj2.keys - obj1.keys
 
       # add deleted properties
       deleted_keys.sort_by{|k,v| k.to_s }.each do |k|
-        custom_result = custom_compare(opts[:comparison], "#{prefix}#{k}", obj1[k], nil)
+        change_key = prefix_append_key(opts[:prefix], k, opts)
+        custom_result = custom_compare(opts[:comparison], change_key, obj1[k], nil)
 
         if custom_result
           result.concat(custom_result)
         else
-          result << ['-', "#{prefix}#{k}", obj1[k]]
+          result << ['-', change_key, obj1[k]]
         end
       end
 
       # recursive comparison for common keys
-      common_keys.sort_by{|k,v| k.to_s }.each {|k| result.concat(diff(obj1[k], obj2[k], opts.merge(:prefix => "#{prefix}#{k}"))) }
+      common_keys.sort_by{|k,v| k.to_s }.each do |k|
+        prefix = prefix_append_key(opts[:prefix], k, opts)
+        result.concat(diff(obj1[k], obj2[k], opts.merge(:prefix => prefix)))
+      end
 
       # added properties
       added_keys.sort_by{|k,v| k.to_s }.each do |k|
+        change_key = prefix_append_key(opts[:prefix], k, opts)
         unless obj1.key?(k)
-          custom_result = custom_compare(opts[:comparison], "#{prefix}#{k}", nil, obj2[k])
+          custom_result = custom_compare(opts[:comparison], change_key, nil, obj2[k])
 
           if custom_result
             result.concat(custom_result)
           else
-            result << ['+', "#{prefix}#{k}", obj2[k]]
+            result << ['+', change_key, obj2[k]]
           end
         end
       end

lib/hashdiff/lcs.rb

@@ -6,7 +6,7 @@ module HashDiff
   def self.lcs(a, b, options = {})
     opts = { :similarity => 0.8 }.merge!(options)
 
-    opts[:prefix] = "#{opts[:prefix]}[*]"
+    opts[:prefix] = prefix_append_array_index(opts[:prefix], '*', opts)
 
     return [] if a.size == 0 or b.size == 0
 

lib/hashdiff/patch.rb

@@ -1,4 +1,4 @@
-# 
+#
 # This module provides methods to diff two hash, patch and unpatch hash
 #
 module HashDiff
@@ -17,19 +17,21 @@ def self.patch!(obj, changes, options = {})
     delimiter = options[:delimiter] || '.'
 
     changes.each do |change|
-      parts = decode_property_path(change[1], delimiter)
+      parts = change[1]
+      parts = decode_property_path(parts, delimiter) unless parts.is_a?(Array)
+
       last_part = parts.last
 
       parent_node = node(obj, parts[0, parts.size-1])
 
       if change[0] == '+'
-        if last_part.is_a?(Integer)
+        if parent_node.is_a?(Array)
           parent_node.insert(last_part, change[2])
         else
           parent_node[last_part] = change[2]
         end
       elsif change[0] == '-'
-        if last_part.is_a?(Integer)
+        if parent_node.is_a?(Array)
           parent_node.delete_at(last_part)
         else
           parent_node.delete(last_part)
@@ -56,19 +58,21 @@ def self.unpatch!(obj, changes, options = {})
     delimiter = options[:delimiter] || '.'
 
     changes.reverse_each do |change|
-      parts = decode_property_path(change[1], delimiter)
+      parts = change[1]
+      parts = decode_property_path(parts, delimiter) unless parts.is_a?(Array)
+
       last_part = parts.last
 
       parent_node = node(obj, parts[0, parts.size-1])
 
       if change[0] == '+'
-        if last_part.is_a?(Integer)
+        if parent_node.is_a?(Array)
           parent_node.delete_at(last_part)
         else
           parent_node.delete(last_part)
         end
       elsif change[0] == '-'
-        if last_part.is_a?(Integer)
+        if parent_node.is_a?(Array)
           parent_node.insert(last_part, change[2])
         else
           parent_node[last_part] = change[2]

lib/hashdiff/util.rb

@@ -55,19 +55,17 @@ def self.count_nodes(obj)
   #
   # e.g. "a.b[3].c" => ['a', 'b', 3, 'c']
   def self.decode_property_path(path, delimiter='.')
-    parts = path.split(delimiter).collect do |part|
+    path.split(delimiter).inject([]) do |memo, part|
       if part =~ /^(.*)\[(\d+)\]$/
         if $1.size > 0
-          [$1, $2.to_i]
+          memo + [$1, $2.to_i]
         else
-          $2.to_i
+          memo + [$2.to_i]
         end
       else
-        part
+        memo + [part]
       end
     end
-
-    parts.flatten
   end
 
   # @private
@@ -129,4 +127,20 @@ def self.custom_compare(method, key, obj1, obj2)
       end
     end
   end
+
+  def self.prefix_append_key(prefix, key, opts)
+    if opts[:array_path]
+      prefix + [key]
+    else
+      prefix.empty? ? "#{key}" : "#{prefix}#{opts[:delimiter]}#{key}"
+    end
+  end
+
+  def self.prefix_append_array_index(prefix, array_index, opts)
+    if opts[:array_path]
+      prefix + [array_index]
+    else
+      "#{prefix}[#{array_index}]"
+    end
+  end
 end

spec/hashdiff/best_diff_spec.rb

@@ -62,4 +62,13 @@
       ['+', 'menu.popup.menuitem[1]', {"value" => "Open", "onclick" => "OpenDoc()"}]
     ]
   end
+
+  it "should be able to have an array_path specified" do
+    a = {'x' => [{'a' => 1, 'c' => 3, 'e' => 5}, {'y' => 3}]}
+    b = {'x' => [{'a' => 1, 'b' => 2, 'e' => 5}] }
+
+    diff = HashDiff.best_diff(a, b, :array_path => true)
+    diff.should == [["-", ["x", 0, "c"], 3], ["+", ["x", 0, "b"], 2], ["-", ["x", 1], {"y"=>3}]]
+  end
+
 end

spec/hashdiff/diff_spec.rb

@@ -274,4 +274,40 @@
       diff.should == [['~', 'b', 'boat', 'truck'], ['~', 'c', 'plane', ' plan']]
     end
   end
+
+  context 'when :array_path is true' do
+    it 'should return the diff path in an array rather than a string' do
+      x = { 'a' => 'foo' }
+      y = { 'a' => 'bar' }
+      diff = HashDiff.diff(x, y, :array_path => true)
+
+      diff.should == [['~', ['a'], 'foo', 'bar']]
+    end
+
+    it 'should show array indexes in paths' do
+      x = { 'a' => [0, 1, 2] }
+      y = { 'a' => [0, 1, 2, 3] }
+
+      diff = HashDiff.diff(x, y, :array_path => true)
+
+      diff.should == [['+', ['a', 3], 3]]
+    end
+
+    it 'should show differences with string and symbol keys' do
+      x = { 'a' => 'foo' }
+      y = { :a => 'bar' }
+
+      diff = HashDiff.diff(x, y, :array_path => true)
+      diff.should == [['-', ['a'], 'foo'], ['+', [:a], 'bar']]
+    end
+
+    it 'should support other key types' do
+      time = Time.now
+      x = { time => 'foo' }
+      y = { 0 => 'bar' }
+
+      diff = HashDiff.diff(x, y, :array_path => true)
+      diff.should == [['-', [time], 'foo'], ['+', [0], 'bar']]
+    end
+  end
 end

spec/hashdiff/patch_spec.rb

@@ -157,5 +157,27 @@
     HashDiff.unpatch!(b, diff, :delimiter => "\n").should == a
   end
 
+  it "should be able to patch when the diff is generated with an array_path" do
+    a = {"a" => 1, "b" => 1}
+    b = {"a" => 1, "b" => 2}
+    diff = HashDiff.diff(a, b, :array_path => true)
 
+    HashDiff.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => 1}
+    b = {"a" => 1, "b" => 2}
+    HashDiff.unpatch!(b, diff).should == a
+  end
+
+  it "should be able to use non string keys when diff is generated with an array_path" do
+    a = {"a" => 1, :a => 2, 0 => 3}
+    b = {"a" => 5, :a => 6, 0 => 7}
+    diff = HashDiff.diff(a, b, :array_path => true)
+
+    HashDiff.patch!(a, diff).should == b
+
+    a = {"a" => 1, :a => 2, 0 => 3}
+    b = {"a" => 5, :a => 6, 0 => 7}
+    HashDiff.unpatch!(b, diff).should == a
+  end
 end