hashdiff 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 284b7371148ba31499e35fdfb3783faced5a8498
-  data.tar.gz: 3d902c91f2d00eb00df4cb96d27f5d6c242e9ee8
+  metadata.gz: 4ba86448df8842fe6323572feb2c89110954b775
+  data.tar.gz: e3d610f32c07e65e06f825e107371caaaf2e5896
 SHA512:
-  metadata.gz: e80104dc13c931f44352337d0027fd774f8a54a67c2ae15b2870e05723c41aafbe00be06d5073078ccfcf44b320e3ae03693623f0d61cab95fa040671e708599
-  data.tar.gz: 8efef12e5b3ff1c9a78dfc7655f121211d91e6b7d62521d33a5376b202e31913da440e2754f5ae0a3f1cba7189e2006db033027786c7402410ecf5dac58d44f2
+  metadata.gz: 7e7b28d277160a603df99c83022f6b8bd7bb27ac5d467e351e5834ba955195ed493249b7a7e213dafe0cb1aa630c5de46fe11a95b5942de4ba9c1f4e66262ec3
+  data.tar.gz: d5290cbc0b5c97038cce213e627fc20fcaf4e7405888c217c78b949c8fc98990ab6d3ae18b0f91d2909c069ffccc20a9d0d45aa572419252aa6eae960df6491d

data/Gemfile

@@ -3,4 +3,5 @@ gemspec
 
 group :test do
   gem 'rake', '< 11'
+  gem 'codecov'
 end

data/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,8 +82,8 @@ 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
@@ -91,8 +91,9 @@ 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.

data/changelog.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## v0.3.5 2017-08-06
+
+* add option `array_path` #34
+
 ## v0.3.4 2017-05-01
 
 * performance improvement of HashDiff#similar? #31

data/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 @@ 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.
   #
@@ -74,9 +76,12 @@ module HashDiff
       :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,23 +109,20 @@ module HashDiff
       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
@@ -128,27 +130,32 @@ module HashDiff
 
       # 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

data/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
 

data/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 @@ module HashDiff
     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 @@ module HashDiff
     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]

data/lib/hashdiff/util.rb

@@ -55,19 +55,17 @@ module HashDiff
   #
   # 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 @@ module HashDiff
       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

data/lib/hashdiff/version.rb

@@ -1,3 +1,3 @@
 module HashDiff
-  VERSION = '0.3.4'
+  VERSION = '0.3.5'
 end

data/spec/hashdiff/best_diff_spec.rb

@@ -62,4 +62,13 @@ describe HashDiff do
       ['+', '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

data/spec/hashdiff/diff_spec.rb

@@ -274,4 +274,40 @@ describe HashDiff do
       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

data/spec/hashdiff/patch_spec.rb

@@ -157,5 +157,27 @@ describe HashDiff do
     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

data/spec/spec_helper.rb

@@ -1,3 +1,10 @@
+require 'simplecov'
+SimpleCov.start
+if ENV['CI'] == 'true'
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rubygems'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-01 00:00:00.000000000 Z
+date: 2017-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec