hashdiff 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1de380f239260b12890d36de1548ee8a9159a15d
-  data.tar.gz: be13f7000b31ac211e59c8e5c924a976a39fb26c
+  metadata.gz: 204c04301ec7d5b755863a0ec7b9001930a569c1
+  data.tar.gz: c0bf2c27e34271b637da82792549104a5b0ca2cb
 SHA512:
-  metadata.gz: bad33e3fd08a4f7b14388f54c17060153a48832eda6c06e6d137ce23b901cd14183630eabcfa7e1da6d2c93f33d7b59109a7fee0e78a23f2a3102e3576c35846
-  data.tar.gz: 7fa406149636c91d9cc5abc49b926f92e8b4962654e9b78ef18b3938dc971ce2f51cf16b2c01b3968556cc20fbfb577437b76a7094ecf0ba4eb5cd00cdba0bb3
+  metadata.gz: 68f07faf7b58132dae314317cf90e1dae5549218d93c19be33df0460659d2e74a861f458c9f6401909ce78ca1b0cb649cc843e0a804a4dad70e3c824568bfd7c
+  data.tar.gz: ba2ff10babe7886c263cbac1c761a38e205880dc323199746ed6845762b462a08b7664f9f1159b5765751b020dfd38ac365fcec04e350d894f97df6b519f3c71

data/.travis.yml

@@ -1,5 +1,6 @@
 sudo: false
 language: ruby
+cache: bundler
 rvm:
   - 2.0.0
   - 2.1.10

data/README.md

@@ -1,17 +1,17 @@
-# HashDiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.svg)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.svg)](http://badge.fury.io/rb/hashdiff)
+# Hashdiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.svg)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.svg)](http://badge.fury.io/rb/hashdiff)
 
-HashDiff is a ruby library to compute the smallest difference between two hashes.
+Hashdiff is a ruby library to compute the smallest difference between two hashes.
 
 It also supports comparing two arrays.
 
-HashDiff does not monkey-patch any existing class. All features are contained inside the `HashDiff` module.
+Hashdiff does not monkey-patch any existing class. All features are contained inside the `Hashdiff` module.
 
 **Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
 
 
 __WARNING__: Don't use the library for comparing large arrays, say ~10K (see #49).
 
-## Why HashDiff?
+## Why Hashdiff?
 
 Given two Hashes A and B, sometimes you face the question: what's the smallest modification that can be made to change A into B?
 
@@ -21,7 +21,7 @@ An algorithm that responds to this question has to do following:
 * Compute recursively -- Arrays and Hashes may be nested arbitrarily in A or B.
 * Compute the smallest change -- it should recognize similar child Hashes or child Arrays between A and B.
 
-HashDiff answers the question above using an opinionated approach:
+Hashdiff answers the question above using an opinionated approach:
 
 * Hash can be represented as a list of (dot-syntax-path, value) pairs. For example, `{a:[{c:2}]}` can be represented as `["a[0].c", 2]`.
 * The change set can be represented using the dot-syntax representation. For example, `[['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]`.
@@ -46,7 +46,7 @@ Two simple hashes:
 a = {a:3, b:2}
 b = {}
 
-diff = HashDiff.diff(a, b)
+diff = Hashdiff.diff(a, b)
 diff.should == [['-', 'a', 3], ['-', 'b', 2]]
 ```
 
@@ -56,7 +56,7 @@ More complex hashes:
 a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
 b = {a:{y:3}, b:{y:3, z:30}}
 
-diff = HashDiff.diff(a, b)
+diff = Hashdiff.diff(a, b)
 diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
 ```
 
@@ -66,7 +66,7 @@ Arrays in hashes:
 a = {a:[{x:2, y:3, z:4}, {x:11, y:22, z:33}], b:{x:3, z:45}}
 b = {a:[{y:3}, {x:11, z:33}], b:{y:22}}
 
-diff = HashDiff.best_diff(a, b)
+diff = Hashdiff.best_diff(a, b)
 diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
 ```
 
@@ -78,8 +78,8 @@ patch example:
 a = {'a' => 3}
 b = {'a' => {'a1' => 1, 'a2' => 2}}
 
-diff = HashDiff.diff(a, b)
-HashDiff.patch!(a, diff).should == b
+diff = Hashdiff.diff(a, b)
+Hashdiff.patch!(a, diff).should == b
 ```
 
 unpatch example:
@@ -88,8 +88,8 @@ unpatch example:
 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
+diff = Hashdiff.diff(a, b) # diff two array is OK
+Hashdiff.unpatch!(b, diff).should == a
 ```
 
 ### Options
@@ -106,7 +106,7 @@ You can specify `:delimiter` to be something other than the default dot. For exa
 a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
 b = {a:{y:3}, b:{y:3, z:30}}
 
-diff = HashDiff.diff(a, b, :delimiter => '\t')
+diff = Hashdiff.diff(a, b, :delimiter => '\t')
 diff.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
 ```
 
@@ -126,7 +126,7 @@ The :numeric_tolerance option allows for a small numeric tolerance.
 a = {x:5, y:3.75, z:7}
 b = {x:6, y:3.76, z:7}
 
-diff = HashDiff.diff(a, b, :numeric_tolerance => 0.1)
+diff = Hashdiff.diff(a, b, :numeric_tolerance => 0.1)
 diff.should == [["~", "x", 5, 6]]
 ```
 
@@ -138,7 +138,7 @@ The :strip option strips all strings before comparing.
 a = {x:5, s:'foo '}
 b = {x:6, s:'foo'}
 
-diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip => true })
+diff = Hashdiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip => true })
 diff.should == [["~", "x", 5, 6]]
 ```
 
@@ -150,7 +150,7 @@ The :case_insensitive option makes string comparisons ignore case.
 a = {x:5, s:'FooBar'}
 b = {x:6, s:'foobar'}
 
-diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_insensitive => true })
+diff = Hashdiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_insensitive => true })
 diff.should == [["~", "x", 5, 6]]
 ```
 
@@ -164,7 +164,7 @@ is useful for `patch!` when used on hashes without string keys.
 a = {x:5}
 b = {'x'=>6}
 
-diff = HashDiff.diff(a, b, :array_path => true)
+diff = Hashdiff.diff(a, b, :array_path => true)
 diff.should == [['-', [:x], 5], ['+', ['x'], 6]]
 ```
 
@@ -173,7 +173,7 @@ For cases where there are arrays in paths their index will be added to the path.
 a = {x:[0,1]}
 b = {x:[0,2]}
 
-diff = HashDiff.diff(a, b, :array_path => true)
+diff = Hashdiff.diff(a, b, :array_path => true)
 diff.should == [["-", [:x, 1], 1], ["+", [:x, 1], 2]]
 ```
 
@@ -183,8 +183,8 @@ This shouldn't cause problems if you are comparing an array with a hash:
 a = {x:{0=>1}}
 b = {x:[1]}
 
-diff = HashDiff.diff(a, b, :array_path => true)
-diff.should == [["~", [:a], [1], {0=>1}]]
+diff = Hashdiff.diff(a, b, :array_path => true)
+diff.should == [["~", [:x], {0=>1}, [1]]]
 ```
 
 #### `:use_lcs`
@@ -205,7 +205,7 @@ Note, currently the :similarity option has no effect when :use_lcs is false.
 a = {x: [0, 1, 2]}
 b = {x: [0, 2, 2, 3]}
 
-diff = HashDiff.diff(a, b, :use_lcs => false)
+diff = Hashdiff.diff(a, b, :use_lcs => false)
 diff.should == [["~", "x[1]", 1, 2], ["+", "x[3]", 3]]
 ```
 
@@ -217,7 +217,7 @@ It's possible to specify how the values of a key should be compared.
 a = {a:'car', b:'boat', c:'plane'}
 b = {a:'bus', b:'truck', c:' plan'}
 
-diff = HashDiff.diff(a, b) do |path, obj1, obj2|
+diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
   case path
   when  /a|b|c/
     obj1.length == obj2.length
@@ -233,7 +233,7 @@ The yielded params of the comparison block is `|path, obj1, obj2|`, in which pat
 a = {a:'car', b:['boat', 'plane'] }
 b = {a:'bus', b:['truck', ' plan'] }
 
-diff = HashDiff.diff(a, b) do |path, obj1, obj2|
+diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
   case path
   when 'b[*]'
     obj1.length == obj2.length
@@ -255,13 +255,18 @@ An order difference alone between two arrays can create too many diffs to be use
 a = {a:'car', b:['boat', 'plane'] }
 b = {a:'car', b:['plane', 'boat'] }
 
-HashDiff.diff(a, b) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
+Hashdiff.diff(a, b) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
 
 b[:b].sort!
 
-HashDiff.diff(a, b) => []
+Hashdiff.diff(a, b) => []
 ```
 
+## Maintainers
+
+- Krzysztof Rybka ([@krzysiek1507](https://github.com/krzysiek1507))
+- Fengyun Liu ([@liufengyun](https://github.com/liufengyun))
+
 ## License
 
-HashDiff is distributed under the MIT-LICENSE.
+Hashdiff is distributed under the MIT-LICENSE.

data/changelog.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## v0.4.0 2019-05-28
+
+* refactoring (#56 #57 #59 #61 krzysiek1507)
+* fix typo in README (#64 @pboling)
+* change HashDiff to Hashdiff (#65 @jfelchner)
+
 ## v0.3.9 2019-04-22
 
 * Performance tweak (thanks @krzysiek1507: #51 #52 #53)
@@ -22,7 +28,7 @@
 
 ## v0.3.4 2017-05-01
 
-* performance improvement of HashDiff#similar? #31
+* performance improvement of `#similar?` #31
 
 ## v0.3.2 2016-12-27
 
@@ -64,7 +70,7 @@
 ## v0.0.5 2012-7-1
 
 * fix a bug in judging whehter two objects are similiar.
-* add more spec test for HashDiff.best_diff
+* add more spec test for `.best_diff`
 
 ## v0.0.4 2012-6-24
 

data/hashdiff.gemspec

@@ -5,16 +5,17 @@ require 'hashdiff/version'
 
 Gem::Specification.new do |s|
   s.name        = 'hashdiff'
-  s.version     = HashDiff::VERSION
+  s.version     = Hashdiff::VERSION
   s.license     = 'MIT'
-  s.summary     = ' HashDiff is a diff lib to compute the smallest difference between two hashes. '
-  s.description = ' HashDiff is a diff lib to compute the smallest difference between two hashes. '
+  s.summary     = ' Hashdiff is a diff lib to compute the smallest difference between two hashes. '
+  s.description = ' Hashdiff is a diff lib to compute the smallest difference between two hashes. '
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- Appraisals {spec}/*`.split("\n")
 
   s.require_paths = ['lib']
   s.required_ruby_version = Gem::Requirement.new('>= 2.0.0')
+  s.post_install_message = 'The HashDiff constant used by this gem conflicts with another gem of a similar name.  As of version 1.0 the HashDiff constant will be completely removed and replaced by Hashdiff.  For more information see https://github.com/liufengyun/hashdiff/issues/45.'
 
   s.authors = ['Liu Fengyun']
   s.email   = ['liufengyunchina@gmail.com']
@@ -26,4 +27,14 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rubocop')
   s.add_development_dependency('rubocop-rspec')
   s.add_development_dependency('yard')
+
+  if s.respond_to?(:metadata)
+    s.metadata = {
+      'bug_tracker_uri' => 'https://github.com/liufengyun/hashdiff/issues',
+      'changelog_uri' => 'https://github.com/liufengyun/hashdiff/blob/master/changelog.md',
+      'documentation_uri' => 'https://www.rubydoc.info/gems/hashdiff',
+      'homepage_uri' => 'https://github.com/liufengyun/hashdiff',
+      'source_code_uri' => 'https://github.com/liufengyun/hashdiff'
+    }
+  end
 end

data/lib/hashdiff.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'hashdiff/util'
-require_relative 'hashdiff/lcs'
-require_relative 'hashdiff/linear_compare_array'
-require_relative 'hashdiff/diff'
-require_relative 'hashdiff/patch'
-require_relative 'hashdiff/version'
+require 'hashdiff/util'
+require 'hashdiff/compare_hashes'
+require 'hashdiff/lcs'
+require 'hashdiff/lcs_compare_arrays'
+require 'hashdiff/linear_compare_array'
+require 'hashdiff/diff'
+require 'hashdiff/patch'
+require 'hashdiff/version'
+
+HashDiff = Hashdiff
+
+warn 'The HashDiff constant used by this gem conflicts with another gem of a similar name.  As of version 1.0 the HashDiff constant will be completely removed and replaced by Hashdiff.  For more information see https://github.com/liufengyun/hashdiff/issues/45.'

data/lib/hashdiff/compare_hashes.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare hashes
+  class CompareHashes
+    class << self
+      def call(obj1, obj2, opts = {})
+        return [] if obj1.empty? && obj2.empty?
+
+        obj1_keys = obj1.keys
+        obj2_keys = obj2.keys
+
+        added_keys = (obj2_keys - obj1_keys).sort_by(&:to_s)
+        common_keys = (obj1_keys & obj2_keys).sort_by(&:to_s)
+        deleted_keys = (obj1_keys - obj2_keys).sort_by(&:to_s)
+
+        result = []
+
+        # add deleted properties
+        deleted_keys.each do |k|
+          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, obj1[k], nil)
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['-', change_key, obj1[k]]
+          end
+        end
+
+        # recursive comparison for common keys
+        common_keys.each do |k|
+          prefix = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+
+          result.concat(Hashdiff.diff(obj1[k], obj2[k], opts.merge(prefix: prefix)))
+        end
+
+        # added properties
+        added_keys.each do |k|
+          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+
+          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, nil, obj2[k])
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['+', change_key, obj2[k]]
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/hashdiff/diff.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module HashDiff
+module Hashdiff
   # Best diff two objects, which tries to generate the smallest change set using different similarity values.
   #
-  # HashDiff.best_diff is useful in case of comparing two objects which include similar hashes in arrays.
+  # Hashdiff.best_diff is useful in case of comparing two objects which include similar hashes in arrays.
   #
   # @param [Array, Hash] obj1
   # @param [Array, Hash] obj2
@@ -23,7 +23,7 @@ module HashDiff
   # @example
   #   a = {'x' => [{'a' => 1, 'c' => 3, 'e' => 5}, {'y' => 3}]}
   #   b = {'x' => [{'a' => 1, 'b' => 2, 'e' => 5}] }
-  #   diff = HashDiff.best_diff(a, b)
+  #   diff = Hashdiff.best_diff(a, b)
   #   diff.should == [['-', 'x[0].c', 3], ['+', 'x[0].b', 2], ['-', 'x[1].y', 3], ['-', 'x[1]', {}]]
   #
   # @since 0.0.1
@@ -69,7 +69,7 @@ module HashDiff
   #   a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
   #   b = {"a" => 1, "b" => {}}
   #
-  #   diff = HashDiff.diff(a, b)
+  #   diff = Hashdiff.diff(a, b)
   #   diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
   #
   # @since 0.0.1
@@ -95,78 +95,19 @@ module HashDiff
 
     return [] if obj1.nil? && obj2.nil?
 
-    return [['~', opts[:prefix], nil, obj2]] if obj1.nil?
-
-    return [['~', opts[:prefix], obj1, nil]] if obj2.nil?
+    return [['~', opts[:prefix], obj1, obj2]] if obj1.nil? || obj2.nil?
 
     return [['~', opts[:prefix], obj1, obj2]] unless comparable?(obj1, obj2, opts[:strict])
 
-    result = []
-    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|
-          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 << ['-', change_key, change[2]]
-        elsif change[0] == '+'
-          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)
-      obj1_keys = obj1.keys
-      obj2_keys = obj2.keys
-
-      deleted_keys = (obj1_keys - obj2_keys).sort_by(&:to_s)
-      common_keys = (obj1_keys & obj2_keys).sort_by(&:to_s)
-      added_keys = (obj2_keys - obj1_keys).sort_by(&:to_s)
-
-      # add deleted properties
-      deleted_keys.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 << ['-', change_key, obj1[k]]
-        end
-      end
-
-      # recursive comparison for common keys
-      common_keys.each do |k|
-        prefix = prefix_append_key(opts[:prefix], k, opts)
-        result.concat(diff(obj1[k], obj2[k], opts.merge(prefix: prefix)))
-      end
+    return LcsCompareArrays.call(obj1, obj2, opts) if obj1.is_a?(Array) && opts[:use_lcs]
 
-      # added properties
-      added_keys.each do |k|
-        change_key = prefix_append_key(opts[:prefix], k, opts)
-        next if obj1.key?(k)
+    return LinearCompareArray.call(obj1, obj2, opts) if obj1.is_a?(Array) && !opts[:use_lcs]
 
-        custom_result = custom_compare(opts[:comparison], change_key, nil, obj2[k])
+    return CompareHashes.call(obj1, obj2, opts) if obj1.is_a?(Hash)
 
-        if custom_result
-          result.concat(custom_result)
-        else
-          result << ['+', change_key, obj2[k]]
-        end
-      end
-    else
-      return [] if compare_values(obj1, obj2, opts)
-
-      return [['~', opts[:prefix], obj1, obj2]]
-    end
+    return [] if compare_values(obj1, obj2, opts)
 
-    result
+    [['~', opts[:prefix], obj1, obj2]]
   end
 
   # @private

data/lib/hashdiff/lcs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module HashDiff
+module Hashdiff
   # @private
   #
   # caculate array difference using LCS algorithm

data/lib/hashdiff/lcs_compare_arrays.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare arrays using the lcs algorithm
+  class LcsCompareArrays
+    class << self
+      def call(obj1, obj2, opts = {})
+        result = []
+
+        changeset = Hashdiff.diff_array_lcs(obj1, obj2, opts) do |lcs|
+          # use a's index for similarity
+          lcs.each do |pair|
+            prefix = Hashdiff.prefix_append_array_index(opts[:prefix], pair[0], opts)
+
+            result.concat(Hashdiff.diff(obj1[pair[0]], obj2[pair[1]], opts.merge(prefix: prefix)))
+          end
+        end
+
+        changeset.each do |change|
+          next if change[0] != '-' && change[0] != '+'
+
+          change_key = Hashdiff.prefix_append_array_index(opts[:prefix], change[1], opts)
+
+          result << [change[0], change_key, change[2]]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/hashdiff/linear_compare_array.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module HashDiff
+module Hashdiff
   # @private
   #
   # Used to compare arrays in a linear complexity, which produces longer diffs
@@ -80,8 +80,8 @@ module HashDiff
     end
 
     def item_difference(old_item, new_item, item_index)
-      prefix = HashDiff.prefix_append_array_index(options[:prefix], item_index, options)
-      HashDiff.diff(old_item, new_item, options.merge(prefix: prefix))
+      prefix = Hashdiff.prefix_append_array_index(options[:prefix], item_index, options)
+      Hashdiff.diff(old_item, new_item, options.merge(prefix: prefix))
     end
 
     # look ahead in the new array to see if the current item appears later
@@ -137,12 +137,12 @@ module HashDiff
     end
 
     def append_addition(item, index)
-      key = HashDiff.prefix_append_array_index(options[:prefix], index, options)
+      key = Hashdiff.prefix_append_array_index(options[:prefix], index, options)
       additions << ['+', key, item]
     end
 
     def append_deletion(item, index)
-      key = HashDiff.prefix_append_array_index(options[:prefix], index, options)
+      key = Hashdiff.prefix_append_array_index(options[:prefix], index, options)
       deletions << ['-', key, item]
     end
 

data/lib/hashdiff/patch.rb

@@ -3,7 +3,7 @@
 #
 # This module provides methods to diff two hash, patch and unpatch hash
 #
-module HashDiff
+module Hashdiff
   # Apply patch to object
   #
   # @param [Hash, Array] obj the object to be patched, can be an Array or a Hash

data/lib/hashdiff/util.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module HashDiff
+module Hashdiff
   # @private
   #
   # judge whether two objects are similar
   def self.similar?(obja, objb, options = {})
-    return compare_values(obja, objb, options) unless obja.is_a?(Array) || obja.is_a?(Hash) || objb.is_a?(Array) || objb.is_a?(Hash)
+    return compare_values(obja, objb, options) if !options[:comparison] && !any_hash_or_array?(obja, objb)
 
     count_a = count_nodes(obja)
     count_b = count_nodes(objb)
@@ -140,4 +140,15 @@ module HashDiff
       "#{prefix}[#{array_index}]"
     end
   end
+
+  class << self
+    private
+
+    # @private
+    #
+    # checks if both objects are Arrays or Hashes
+    def any_hash_or_array?(obja, objb)
+      obja.is_a?(Array) || obja.is_a?(Hash) || objb.is_a?(Array) || objb.is_a?(Hash)
+    end
+  end
 end

data/lib/hashdiff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module HashDiff
-  VERSION = '0.3.9'.freeze
+module Hashdiff
+  VERSION = '0.4.0'.freeze
 end

data/spec/{hash_diff → hashdiff}/best_diff_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff do
+describe Hashdiff do
   it 'is able to best diff' do
     a = { 'x' => [{ 'a' => 1, 'c' => 3, 'e' => 5 }, { 'y' => 3 }] }
     b = { 'x' => [{ 'a' => 1, 'b' => 2, 'e' => 5 }] }

data/spec/{hash_diff → hashdiff}/diff_array_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff do
+describe Hashdiff do
   it 'is able to diff two equal array' do
     a = [1, 2, 3]
     b = [1, 2, 3]

data/spec/{hash_diff → hashdiff}/diff_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff do
+describe Hashdiff do
   it 'is able to diff two empty hashes' do
     diff = described_class.diff({}, {})
     diff.should == []
@@ -275,6 +275,20 @@ describe HashDiff do
       end
       diff.should == [['~', 'b', 'boat', 'truck'], ['~', 'c', 'plane', ' plan']]
     end
+
+    it 'compares nested arrays using proc specified in block' do
+      a = { a: 'car', b: %w[boat plane] }
+      b = { a: 'bus', b: ['truck', ' plan'] }
+
+      diff = described_class.diff(a, b) do |path, obj1, obj2|
+        case path
+        when 'b[*]'
+          obj1.length == obj2.length
+        end
+      end
+
+      expect(diff).to eq [['~', 'a', 'car', 'bus'], ['~', 'b[1]', 'plane', ' plan'], ['-', 'b[0]', 'boat'], ['+', 'b[0]', 'truck']]
+    end
   end
 
   context 'when :array_path is true' do

data/spec/{hash_diff → hashdiff}/lcs_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff do
+describe Hashdiff do
   it 'is able to find LCS between two equal array' do
     a = [1, 2, 3]
     b = [1, 2, 3]

data/spec/{hash_diff → hashdiff}/linear_compare_array_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff::LinearCompareArray do
+describe Hashdiff::LinearCompareArray do
   it 'finds no differences between two empty arrays' do
     difference = described_class.call([], [])
     difference.should == []

data/spec/{hash_diff → hashdiff}/patch_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff do
+describe Hashdiff do
   it 'is able to patch key addition' do
     a = { 'a' => 3, 'c' => 11, 'd' => 45, 'e' => 100, 'f' => 200 }
     b = { 'a' => 3, 'c' => 11, 'd' => 45, 'e' => 100, 'f' => 200, 'g' => 300 }

data/spec/{hash_diff → hashdiff}/util_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HashDiff do
+describe Hashdiff do
   it 'is able to decode property path' do
     decoded = described_class.send(:decode_property_path, 'a.b[0].c.city[5]')
     decoded.should == ['a', 'b', 0, 'c', 'city', 5]
@@ -21,11 +21,11 @@ describe HashDiff do
   end
 
   it 'is able to tell similiar empty hash' do
-    described_class.similar?({}, {}, 1).should be true
+    described_class.similar?({}, {}, similarity: 1).should be true
   end
 
   it 'is able to tell similiar empty array' do
-    described_class.similar?([], [], 1).should be true
+    described_class.similar?([], [], similarity: 1).should be true
   end
 
   it 'is able to tell similiar hash with values within tolerance' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-22 00:00:00.000000000 Z
+date: 2019-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bluecloth
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: " HashDiff is a diff lib to compute the smallest difference between two
+description: " Hashdiff is a diff lib to compute the smallest difference between two
   hashes. "
 email:
 - liufengyunchina@gmail.com
@@ -100,25 +100,34 @@ files:
 - changelog.md
 - hashdiff.gemspec
 - lib/hashdiff.rb
+- lib/hashdiff/compare_hashes.rb
 - lib/hashdiff/diff.rb
 - lib/hashdiff/lcs.rb
+- lib/hashdiff/lcs_compare_arrays.rb
 - lib/hashdiff/linear_compare_array.rb
 - lib/hashdiff/patch.rb
 - lib/hashdiff/util.rb
 - lib/hashdiff/version.rb
-- spec/hash_diff/best_diff_spec.rb
-- spec/hash_diff/diff_array_spec.rb
-- spec/hash_diff/diff_spec.rb
-- spec/hash_diff/lcs_spec.rb
-- spec/hash_diff/linear_compare_array_spec.rb
-- spec/hash_diff/patch_spec.rb
-- spec/hash_diff/util_spec.rb
+- spec/hashdiff/best_diff_spec.rb
+- spec/hashdiff/diff_array_spec.rb
+- spec/hashdiff/diff_spec.rb
+- spec/hashdiff/lcs_spec.rb
+- spec/hashdiff/linear_compare_array_spec.rb
+- spec/hashdiff/patch_spec.rb
+- spec/hashdiff/util_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/liufengyun/hashdiff
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/liufengyun/hashdiff/issues
+  changelog_uri: https://github.com/liufengyun/hashdiff/blob/master/changelog.md
+  documentation_uri: https://www.rubydoc.info/gems/hashdiff
+  homepage_uri: https://github.com/liufengyun/hashdiff
+  source_code_uri: https://github.com/liufengyun/hashdiff
+post_install_message: The HashDiff constant used by this gem conflicts with another
+  gem of a similar name.  As of version 1.0 the HashDiff constant will be completely
+  removed and replaced by Hashdiff.  For more information see https://github.com/liufengyun/hashdiff/issues/45.
 rdoc_options: []
 require_paths:
 - lib
@@ -137,5 +146,5 @@ rubyforge_project:
 rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
-summary: HashDiff is a diff lib to compute the smallest difference between two hashes.
+summary: Hashdiff is a diff lib to compute the smallest difference between two hashes.
 test_files: []