Merged with the original to update the gem, but keep our customizations

.travis.yml

@@ -1,6 +1,13 @@
+sudo: false
 language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.1
+  - 2.1.10
+  - 2.2.8
+  - 2.3.4
+  - 2.4.2
 script: "bundle exec rake spec"
+
+before_install:
+  - gem install bundler

Gemfile

@@ -2,5 +2,5 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem 'rake'
+  gem 'rake', '< 11'
 end

README.md

@@ -2,7 +2,9 @@
 
 HashDiff is a ruby library to compute the smallest difference between two hashes.
 
-**Demo**: [HashDiff](http://hashdiff.herokuapp.com/)
+It also supports comparing two arrays.
+
+HashDiff does not monkey-patch any existing class. All features are contained inside the `HashDiff` module.
 
 **Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
 
@@ -70,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
@@ -80,16 +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 five options available: `:delimiter`, `:similarity`, `:strict`, `:numeric_tolerance` and `:strip`.
+There are eight options available: `:delimiter`, `:similarity`,
+`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path`
+and `:use_lcs`
 
 #### `:delimiter`
 
@@ -135,6 +139,73 @@ diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip =>
 diff.should == [["~", "x", 5, 6]]
 ```
 
+#### `:case_insensitive`
+
+The :case_insensitive option makes string comparisons ignore case.
+
+```ruby
+a = {x:5, s:'FooBar'}
+b = {x:6, s:'foobar'}
+
+diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_insensitive => true })
+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}]]
+```
+
+#### `:use_lcs`
+
+The :use_lcs option is used to specify whether a
+[Longest common subsequence](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)
+(LCS) algorithm is used to determine differences in arrays. This defaults to
+`true` but can be changed to `false` for significantly faster array comparisons
+(O(n) complexity rather than O(n<sup>2</sup>) for LCS).
+
+When :use_lcs is false the results of array comparisons have a tendency to
+show changes at indexes rather than additions and subtractions when :use_lcs is
+true.
+
+Note, currently the :similarity option has no effect when :use_lcs is false.
+
+```ruby
+a = {x: [0, 1, 2]}
+b = {x: [0, 2, 2, 3]}
+
+diff = HashDiff.diff(a, b, :use_lcs => false)
+diff.should == [["~", "x[1]", 1, 2], ["+", "x[3]", 3]]
+```
+
 #### Specifying a custom comparison method
 
 It's possible to specify how the values of a key should be compared.
@@ -171,6 +242,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.
@@ -186,23 +259,6 @@ b[:b].sort!
 HashDiff.diff(a, b) => []
 ```
 
-### Special use cases
-
-#### Using HashDiff on JSON API results
-
-```ruby
-require 'uri'
-require 'net/http'
-require 'json'
-
-uri = URI('http://time.jsontest.com/')
-json_resp = ->(uri) { JSON.parse(Net::HTTP.get_response(uri).body) }
-a = json_resp.call(uri)
-b = json_resp.call(uri)
-
-HashDiff.diff(a,b) => [["~", "milliseconds_since_epoch", 1410542545874, 1410542545985]]
-```
-
 ## License
 
 HashDiff is distributed under the MIT-LICENSE.

changelog.md

@@ -1,5 +1,41 @@
 # Change Log
 
+## v0.3.7 2017-10-08
+
+* remove 1.8.7 support from gemspec #39
+
+## v0.3.6 2017-08-22
+
+* add option `use_lcs` #35
+
+## v0.3.5 2017-08-06
+
+* add option `array_path` #34
+
+## v0.3.4 2017-05-01
+
+* performance improvement of HashDiff#similar? #31
+
+## v0.3.2 2016-12-27
+
+* replace `Fixnum` by `Integer` #28
+
+## v0.3.1 2016-11-24
+
+* fix an error when a hash has mixed types #26
+
+## v0.3.0 2016-2-11
+
+* support `:case_insensitive` option
+
+## v0.2.3 2015-11-5
+
+* improve performance of LCS algorithm #12
+
+## v0.2.2 2014-10-6
+
+* make library 1.8.7 compatible
+
 ## v0.2.1 2014-7-13
 
 * yield added/deleted keys for custom comparison

hashdiff.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- Appraisals {spec}/*`.split("\n")
 
   s.require_paths = ['lib']
-  s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
 
   s.authors = ["Liu Fengyun"]
   s.email   = ["[email protected]"]

lib/hashdiff.rb

@@ -1,5 +1,6 @@
 require 'hashdiff/util'
 require 'hashdiff/lcs'
+require 'hashdiff/linear_compare_array'
 require 'hashdiff/diff'
 require 'hashdiff/patch'
 require 'hashdiff/version'

lib/hashdiff/diff.rb

@@ -7,10 +7,12 @@ module HashDiff
   # @param [Array, Hash] obj1
   # @param [Array, Hash] obj2
   # @param [Hash] options the options to use when comparing
-  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Fixnum, Float, BigDecimal to each other
+  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Integer, Float, BigDecimal to each other
   #   * :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.
+  #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
   #
   # @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.
   #
@@ -27,15 +29,15 @@ module HashDiff
   def self.best_diff(obj1, obj2, options = {}, &block)
     options[:comparison] = block if block_given?
 
-    opts = {similarity: 0.3}.merge!(options)
+    opts = { :similarity => 0.3 }.merge!(options)
     diffs_1 = diff(obj1, obj2, opts)
     count_1 = count_diff diffs_1
 
-    opts = {similarity: 0.5}.merge!(options)
+    opts = { :similarity => 0.5 }.merge!(options)
     diffs_2 = diff(obj1, obj2, opts)
     count_2 = count_diff diffs_2
 
-    opts = {similarity: 0.8}.merge!(options)
+    opts = { :similarity => 0.8 }.merge!(options)
     diffs_3 = diff(obj1, obj2, opts)
     count_3 = count_diff diffs_3
 
@@ -48,11 +50,14 @@ def self.best_diff(obj1, obj2, options = {}, &block)
   # @param [Array, Hash] obj1
   # @param [Array, Hash] obj2
   # @param [Hash] options the options to use when comparing
-  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Fixnum, Float, BigDecimal to each other
+  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Integer, Float, BigDecimal to each other
   #   * :similarity (Numeric) [0.8] should be between (0, 1]. Meaningful if there are similar hashes in arrays. See {best_diff}.
   #   * :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.
+  #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
+  #
   #
   # @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 +79,13 @@ def self.diff(obj1, obj2, options = {}, &block)
       :delimiter   =>   '.',
       :strict      =>   true,
       :strip       =>   false,
-      :numeric_tolerance => 0
+      :numeric_tolerance => 0,
+      :array_path  =>   false,
+      :use_lcs     =>   true
     }.merge!(options)
 
+    opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
+
     opts[:comparison] = block if block_given?
 
     # prefer to compare with provided block
@@ -103,62 +112,59 @@ def self.diff(obj1, obj2, options = {}, &block)
     end
 
     result = []
-    if obj1.is_a?(Array)
-      changeset = diff_array(obj1, obj2, opts) do |lcs|
+    if obj1.is_a?(Array) && opts[:use_lcs]
+      changeset = diff_array_lcs(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?(Array) && !opts[:use_lcs]
+      result.concat(LinearCompareArray.call(obj1, obj2, opts))
     elsif obj1.is_a?(Hash)
-      if opts[:prefix].empty?
-        prefix = ""
-      else
-        prefix = "#{opts[:prefix]}#{opts[:delimiter]}"
-      end
 
-      deleted_keys = []
-      common_keys = []
-
-      obj1.each do |k, v|
-        if obj2.key?(k)
-          common_keys << k
-        else
-          deleted_keys << k
-        end
-      end
+      deleted_keys = obj1.keys - obj2.keys
+      common_keys = obj1.keys & obj2.keys
+      added_keys = obj2.keys - obj1.keys
 
       # add deleted properties
-      deleted_keys.each do |k|
-        custom_result = custom_compare(opts[:comparison], "#{prefix}#{k}", obj1[k], nil)
+      deleted_keys.sort_by{|k,v| k.to_s }.each do |k|
+        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.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
-      obj2.each do |k, v|
+      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, v)
+          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
@@ -173,7 +179,7 @@ def self.diff(obj1, obj2, options = {}, &block)
   # @private
   #
   # diff array using LCS algorithm
-  def self.diff_array(a, b, options = {})
+  def self.diff_array_lcs(a, b, options = {})
     opts = {
       :prefix      =>   '',
       :similarity  =>   0.8,
@@ -226,5 +232,4 @@ def self.diff_array(a, b, options = {})
 
     change_set
   end
-
 end