hashdiff 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f76f1e64a73818c32f00f87cac3ba70d68253b10
-  data.tar.gz: a21cb6f9b8657866cca3628f1489301546baf2f8
+  metadata.gz: ca3dcdddb4d1143b186229d4e7d27e9ded3b752b
+  data.tar.gz: edf3e5858ede25b65ad79a9fcbbb5903ff60e5b7
 SHA512:
-  metadata.gz: 9d5e16abeea6634037f6e3696530ea575a8373a19a431ecbe4ab792e9e47d907a380fee1eb65f9aa33e5b0fc48e1237a004fc1859d74583161909ee35d72ac4d
-  data.tar.gz: 92a95d686c55d47db575f768cbf9fc0c4e274b86b1c454f6780135a2db5bf6ac007fa54e5e3e3fad37628313791624634a1e309999e1810d21a37585a051cdfb
+  metadata.gz: a7f0e3f36f65b01281792c5f81fc7a3d4f1bc6b9e0bcfa47dd65202aabcb5ea93acb956e6deeadc437b6a0a812a517336eb2430b6d9f1c1056ebbb080980a1f0
+  data.tar.gz: be5bd3ca90b482c7287f65da86b64559cc83f0073901f61f549a627025c277187c160488519ea91a92ab688478bd008af7273fc725e515bd8c6f2f090a074a0a

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.1
 script: "bundle exec rake spec"

data/README.md

@@ -10,93 +10,166 @@ HashDiff is a ruby library to compute the smallest difference between two hashes
 
 Given two Hashes A and B, sometimes you face the question: what's the smallest changes that can be made to change A to B?
 
-An algorithm responds to this question has to do following:
+An algorithm that responds to this question has to do following:
 
 * Generate a list of additions, deletions and changes, so that `A + ChangeSet = B` and `B - ChangeSet = A`.
 * Compute recursively -- Arrays and Hashes may be nested arbitrarily in A or B.
-* Compute the smallest change -- it should recoganize similar child Hashes or child Arrays between A and B.
+* Compute the smallest change -- it should recognize similar child Hashes or child Arrays between A and B.
 
 HashDiff answers the question above in 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 do-syntax representation. For example, `[['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]`.
+* The change set can be represented using the dot-syntax representation. For example, `[['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]`.
 * It compares Arrays using LCS(longest common subsequence) algorithm.
-* It recoganize similar Hashes in Array using a similarity value(0 < similarity <= 1).
+* It recognizes similar Hashes in an Array using a similarity value (0 < similarity <= 1).
 
 ## Usage
 
-If you're using bundler, add following to the Gemfile:
+To use the gem, add the following to your Gemfile:
 
-    gem 'hashdiff'
-
-Or, you can run `gem install hashdiff`, then add following line to your ruby file which uses HashDiff:
-
-    require 'hashdiff'
+```ruby
+gem 'hashdiff'
+```
 
 ## Quick Start
 
 ### Diff
 
-Two simple hash:
+Two simple hashes:
 
-    a = {a:3, b:2}
-    b = {}
+```ruby
+a = {a:3, b:2}
+b = {}
 
-    diff = HashDiff.diff(a, b)
-    diff.should == [['-', 'a', 3], ['-', 'b', 2]]
+diff = HashDiff.diff(a, b)
+diff.should == [['-', 'a', 3], ['-', 'b', 2]]
+```
 
-More complex hash:
+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}}
+```ruby
+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.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
+diff = HashDiff.diff(a, b)
+diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
+```
 
-Array in hash:
+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}}
+```ruby
+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.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
+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]]
+```
 
 ### Patch
 
 patch example:
 
-    a = {a: 3}
-    b = {a: {a1: 1, a2: 2}}
+```ruby
+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:
 
-    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}]
+```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}]
 
-    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
 
-There're two options available: `:delimiter` and `:similarity`.
+There are five options available: `:delimiter`, `:similarity`, `:strict`, `:numeric_tolerance` and `:strip`.
+
+#### `:delimiter`
+
+You can specify `:delimiter` to be something other than the default dot. For example:
+
+```ruby
+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.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
+```
+
+#### `:similarity`
+
+In cases where you have similar hash objects in arrays, you can pass a custom value for `:similarity` instead of the default `0.8`.  This is interpreted as a ratio of similarity (default is 80% similar, whereas `:similarity => 0.5` would look for at least a 50% similarity).
+
+#### `:strict`
+
+The `:strict` option, which defaults to `true`, specifies whether numeric types are compared on type as well as value.  By default, a Fixnum will never be equal to a Float (e.g. 4 != 4.0).  Setting `:strict` to false makes the comparison looser (e.g. 4 == 4.0).
+
+#### `:numeric_tolerance`
+
+The :numeric_tolerance option allows for a small numeric tolerance.
+
+```ruby
+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.should == [["~", "x", 5, 6]]
+```
+
+#### `:strip`
+
+The :strip option strips all strings before comparing.
+
+```ruby
+a = {x:5, s:'foo '}
+b = {x:6, s:'foo'}
+
+diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip => true })
+diff.should == [["~", "x", 5, 6]]
+```
+
+#### Specifying a custom comparison method
+
+It's possible to specify how the values of a key should be compared.
+
+```ruby
+a = {a:'car', b:'boat', c:'plane'}
+b = {a:'bus', b:'truck', c:' plan'}
+
+diff = HashDiff.diff(a, b) do |path, obj1, obj2|
+  case path
+  when  /a|b|c/
+    obj1.length == obj2.length
+  end
+end
 
-You can specify `:delimiter` to be something else than the dot. For example:
+diff.should == [['~', 'b', 'boat', 'truck']]
+```
 
-    a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
-    b = {a:{y:3}, b:{y:3, z:30}}
+The yielded params of the comparison block is `|path, obj1, obj2|`, in which path is the key (or delimited compound key) to the value being compared. When comparing elements in array, the path is with the format `array[*]`. For example:
 
-    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]]
+```ruby
+a = {a:'car', b:['boat', 'plane'] }
+b = {a:'bus', b:['truck', ' plan'] }
 
-In cases you have similar hash objects in array, you can pass a custom value for `:similarity` instead of the default `0.8`.
+diff = HashDiff.diff(a, b) do |path, obj1, obj2|
+  case path
+  when 'b[*]'
+    obj1.length == obj2.length
+  end
+end
 
-## Contributors
+diff.should == [["~", "a", "car", "bus"], ["~", "b[1]", "plane", " plan"], ["-", "b[0]", "boat"], ["+", "b[0]", "truck"]]
+```
 
-- [@liufengyun](https://github.com/liufengyun)
-- [@m-o-e](https://github.com/m-o-e)
+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.
 
 ## License
 

data/changelog.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## v0.2.0 2014-3-29
+
+* support custom comparison blocks
+* support `:strip`, `:numeric_tolerance` and `:strict` options
+
 ## v0.1.0 2013-8-25
 
 * use options for parameters `:delimiter` and `:similarity` in interfaces

data/lib/hashdiff/diff.rb

@@ -2,12 +2,17 @@ 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 includes similar hashes in array.
+  # HashDiff.best_diff is useful in case of comparing two objects which include similar hashes in arrays.
   #
-  # @param [Arrary, Hash] obj1
-  # @param [Arrary, Hash] obj2
-  # @param [Hash] options supports following keys:
-  #   :delimiter - default value is '.'(dot).
+  # @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
+  #   * :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
+  #
+  # @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.
   #
   # @return [Array] an array of changes.
   #   e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
@@ -19,7 +24,9 @@ module HashDiff
   #   diff.should == [['-', 'x[0].c', 3], ['+', 'x[0].b', 2], ['-', 'x[1].y', 3], ['-', 'x[1]', {}]]
   #
   # @since 0.0.1
-  def self.best_diff(obj1, obj2, options = {})
+  def self.best_diff(obj1, obj2, options = {}, &block)
+    options[:comparison] = block if block_given?
+
     opts = {similarity: 0.3}.merge!(options)
     diffs_1 = diff(obj1, obj2, opts)
     count_1 = count_diff diffs_1
@@ -36,14 +43,18 @@ module HashDiff
     diffs = count < count_3 ? diffs : diffs_3
   end
 
-  # Compute the diff of two hashes
+  # Compute the diff of two hashes or arrays
   #
-  # @param [Arrary, Hash] obj1
-  # @param [Arrary, Hash] obj2
-  # @param [Hash] options supports following keys:
-  #   :similarity - should be between (0, 1]. The default value is 0.8. :similarity is meaningful if there're similar hashes in arrays. See {best_diff}.
+  # @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
+  #   * :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
   #
-  #   :delimiter - defaults to '.'(dot).
+  # @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.
   #
   # @return [Array] an array of changes.
   #   e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
@@ -56,14 +67,31 @@ module HashDiff
   #   diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
   #
   # @since 0.0.1
-  def self.diff(obj1, obj2, options = {})
+  def self.diff(obj1, obj2, options = {}, &block)
     opts = {
       :prefix      =>   '',
       :similarity  =>   0.8,
-      :delimiter   =>   '.'
-    }
-
-    opts = opts.merge!(options)
+      :delimiter   =>   '.',
+      :strict      =>   true,
+      :strip       =>   false,
+      :numeric_tolerance => 0
+    }.merge!(options)
+
+    opts[:comparison] = block if block_given?
+
+    # prefer to compare with provided block
+    if opts[:comparison]
+      res = opts[:comparison].call(opts[:prefix], obj1, obj2)
+
+      # nil != false here
+      if res == false
+        return [['~', opts[:prefix], obj1, obj2]]
+      elsif res == true
+        return []
+      else
+        # compare with specified built-in helpers
+      end
+    end
 
     if obj1.nil? and obj2.nil?
       return []
@@ -77,13 +105,13 @@ module HashDiff
       return [['~', opts[:prefix], obj1, nil]]
     end
 
-    if !(obj1.is_a?(Array) and obj2.is_a?(Array)) and !(obj1.is_a?(Hash) and obj2.is_a?(Hash)) and !(obj1.is_a?(obj2.class) or obj2.is_a?(obj1.class))
+    unless comparable?(obj1, obj2, opts[:strict])
       return [['~', opts[:prefix], obj1, obj2]]
     end
 
     result = []
     if obj1.is_a?(Array)
-      changeset = diff_array(obj1, obj2, opts[:similarity]) do |lcs|
+      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]}]")))
@@ -128,7 +156,7 @@ module HashDiff
         end
       end
     else
-      return [] if obj1 == obj2
+      return [] if compare_values(obj1, obj2, opts)
       return [['~', opts[:prefix], obj1, obj2]]
     end
 
@@ -138,7 +166,13 @@ module HashDiff
   # @private
   #
   # diff array using LCS algorithm
-  def self.diff_array(a, b, similarity = 0.8)
+  def self.diff_array(a, b, options = {})
+    opts = {
+      :prefix      =>   '',
+      :similarity  =>   0.8,
+      :delimiter   =>   '.'
+    }.merge!(options)
+
     change_set = []
     if a.size == 0 and b.size == 0
       return []
@@ -155,7 +189,7 @@ module HashDiff
       return change_set
     end
 
-    links = lcs(a, b, similarity)
+    links = lcs(a, b, opts)
 
     # yield common
     yield links if block_given?

data/lib/hashdiff/lcs.rb

@@ -3,7 +3,11 @@ module HashDiff
   #
   # caculate array difference using LCS algorithm
   # http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
-  def self.lcs(a, b, similarity = 0.8)
+  def self.lcs(a, b, options = {})
+    opts = { :similarity => 0.8 }.merge!(options)
+
+    opts[:prefix] = "#{opts[:prefix]}[*]"
+
     return [] if a.size == 0 or b.size == 0
 
     a_start = b_start = 0
@@ -15,7 +19,7 @@ module HashDiff
     (0..b_finish).each do |bi|
       lcs[bi] = [] 
       (0..a_finish).each do |ai|
-        if similar?(a[ai], b[bi], similarity)
+        if similar?(a[ai], b[bi], opts)
           topleft = (ai > 0 and bi > 0)? lcs[bi-1][ai-1][1] : 0
           lcs[bi][ai] = [:topleft, topleft + 1]
         elsif

data/lib/hashdiff/patch.rb

@@ -5,10 +5,10 @@ module HashDiff
 
   # Apply patch to object
   #
-  # @param [Hash, Array] obj the object to be patchted, can be an Array of a Hash
+  # @param [Hash, Array] obj the object to be patched, can be an Array or a Hash
   # @param [Array] changes e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
   # @param [Hash] options supports following keys:
-  #   :delimiter - default value is '.'(dot).
+  #   * :delimiter (String) ['.'] delimiter string for representing nested keys in changes array
   #
   # @return the object after patch
   #
@@ -44,10 +44,10 @@ module HashDiff
 
   # Unpatch an object
   #
-  # @param [Hash, Array] obj the object to be unpatchted, can be an Array of a Hash
+  # @param [Hash, Array] obj the object to be unpatched, can be an Array or a Hash
   # @param [Array] changes e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
   # @param [Hash] options supports following keys:
-  #   :delimiter - default value is '.'(dot).
+  #   * :delimiter (String) ['.'] delimiter string for representing nested keys in changes array
   #
   # @return the object after unpatch
   #

data/lib/hashdiff/util.rb

@@ -3,15 +3,17 @@ module HashDiff
   # @private
   #
   # judge whether two objects are similar
-  def self.similar?(a, b, similarity = 0.8)
+  def self.similar?(a, b, options = {})
+    opts = { :similarity => 0.8 }.merge(options)
+
     count_a = count_nodes(a)
     count_b = count_nodes(b)
-    diffs = count_diff diff(a, b, :similarity => similarity)
+    diffs = count_diff diff(a, b, opts)
 
     if count_a + count_b == 0
       return true
     else
-      (1 - diffs.to_f/(count_a + count_b).to_f) >= similarity
+      (1 - diffs.to_f/(count_a + count_b).to_f) >= opts[:similarity]
     end
   end
 
@@ -78,4 +80,32 @@ module HashDiff
     temp
   end
 
+  # @private
+  #
+  # check for equality or "closeness" within given tolerance
+  def self.compare_values(obj1, obj2, options = {})
+    if (options[:numeric_tolerance].is_a? Numeric) &&
+        [obj1, obj2].all? { |v| v.is_a? Numeric }
+      return (obj1 - obj2).abs <= options[:numeric_tolerance]
+    end
+
+    if options[:strip] == true
+      first = obj1.strip if obj1.respond_to?(:strip)
+      second = obj2.strip if obj2.respond_to?(:strip)
+      return first == second
+    end
+
+    obj1 == obj2
+  end
+
+  # @private
+  #
+  # check if objects are comparable
+  def self.comparable?(obj1, obj2, strict = true)
+    [Array, Hash].each do |type|
+      return true if obj1.is_a?(type) && obj2.is_a?(type)
+    end
+    return true if !strict && obj1.is_a?(Numeric) && obj2.is_a?(Numeric)
+    obj1.is_a?(obj2.class) && obj2.is_a?(obj1.class)
+  end
 end

data/lib/hashdiff/version.rb

@@ -1,3 +1,3 @@
 module HashDiff
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/spec/hashdiff/best_diff_spec.rb

@@ -17,6 +17,20 @@ describe HashDiff do
     diff.should == [["-", "x[0]\tc", 3], ["+", "x[0]\tb", 2], ["-", "x[1]", {"y"=>3}]]
   end
 
+  it "should use custom comparison when provided" do
+    a = {'x' => [{'a' => 'foo', 'c' => 'goat', 'e' => 'snake'}, {'y' => 'baz'}]}
+    b = {'x' => [{'a' => 'bar', 'b' => 'cow', 'e' => 'puppy'}] }
+
+    diff = HashDiff.best_diff(a, b) do |path, obj1, obj2|
+      case path
+      when /^x\[.\]\..$/
+        obj1.length == obj2.length
+      end
+    end
+
+    diff.should == [["-", "x[0].c", 'goat'], ["+", "x[0].b", 'cow'], ["-", "x[1]", {"y"=>'baz'}]]
+  end
+
   it "should be able to best diff array in hash" do
     a = {"menu" => {
       "id" => "file",

data/spec/hashdiff/diff_spec.rb

@@ -22,6 +22,16 @@ describe HashDiff do
     diff.should == []
   end
 
+  it "should be able to diff two hashes with equivalent numerics, when strict is false" do
+    diff = HashDiff.diff({a:2.0, b:2}, {a:2, b:2.0}, :strict => false)
+    diff.should == []
+  end
+
+  it "should be able to diff changes in hash value" do
+    diff = HashDiff.diff({a:2, b:3, c:" hello"}, {a:2, b:4, c:"hello"})
+    diff.should == [['~', 'b', 3, 4], ['~', 'c', " hello", "hello"]]
+  end
+
   it "should be able to diff changes in hash value which is array" do
     diff = HashDiff.diff({a:2, b:[1, 2, 3]}, {a:2, b:[1, 3, 4]})
     diff.should == [['-', 'b[1]', 2], ['+', 'b[2]', 4]]
@@ -131,5 +141,77 @@ describe HashDiff do
     diff.should == [["-", "[0]\td", 4], ["-", "[1]", {"x"=>5, "y"=>6, "z"=>3}]]
   end
 
+  context 'when :numeric_tolerance requested' do
+    it "should be able to diff changes in hash value" do
+      a = {'a' => 0.558, 'b' => 0.0, 'c' => 0.65, 'd' => 'fin'}
+      b = {'a' => 0.557, 'b' => 'hats', 'c' => 0.67, 'd' => 'fin'}
+
+      diff = HashDiff.diff(a, b, :numeric_tolerance => 0.01)
+      diff.should == [["~", "b", 0.0, 'hats'], ["~", "c", 0.65, 0.67]]
+
+      diff = HashDiff.diff(b, a, :numeric_tolerance => 0.01)
+      diff.should == [["~", "b", 'hats', 0.0], ["~", "c", 0.67, 0.65]]
+    end
+
+    it "should be able to diff changes in nested values" do
+      a = {'a' => {'x' => 0.4, 'y' => 0.338}, 'b' => [13, 68.03]}
+      b = {'a' => {'x' => 0.6, 'y' => 0.341}, 'b' => [14, 68.025]}
+
+      diff = HashDiff.diff(a, b, :numeric_tolerance => 0.01)
+      diff.should == [["~", "a.x", 0.4, 0.6], ["-", "b[0]", 13], ["+", "b[0]", 14]]
+
+      diff = HashDiff.diff(b, a, :numeric_tolerance => 0.01)
+      diff.should == [["~", "a.x", 0.6, 0.4], ["-", "b[0]", 14], ["+", "b[0]", 13]]
+    end
+  end
+
+  context 'when :strip requested' do
+    it "should strip strings before comparing" do
+      a = {a:" foo", b:"fizz buzz"}
+      b = {a:"foo", b:"fizzbuzz"}
+      diff = HashDiff.diff(a, b, :strip => true)
+      diff.should == [['~', 'b', "fizz buzz", "fizzbuzz"]]
+    end
+
+    it "should strip nested strings before comparing" do
+      a = {a:{x:" foo"}, b:["fizz buzz", "nerf"]}
+      b = {a:{x:"foo"}, b:["fizzbuzz", "nerf"]}
+      diff = HashDiff.diff(a, b, :strip => true)
+      diff.should == [['-', 'b[0]', "fizz buzz"], ['+', 'b[0]', "fizzbuzz"]]
+    end
+  end
+
+  context 'when both :strip and :numeric_tolerance requested' do
+    it 'should apply filters to proper object types' do
+      a = {a:" foo", b:35, c:'bar', d:'baz'}
+      b = {a:"foo", b:35.005, c:'bar', d:18.5}
+      diff = HashDiff.diff(a, b, :strict => false, :numeric_tolerance => 0.01, :strip => true)
+      diff.should == [['~', 'd', "baz", 18.5]]
+    end
+  end
+
+  context 'with custom comparison' do
+    let(:a) { {a:'car', b:'boat', c:'plane'} }
+    let(:b) { {a:'bus', b:'truck', c:' plan'} }
+
+    it 'should compare using proc specified in block' do
+      diff = HashDiff.diff(a, b) do |prefix, obj1, obj2|
+        case prefix
+        when /a|b|c/
+          obj1.length == obj2.length
+        end
+      end
+      diff.should == [['~', 'b', 'boat', 'truck']]
+    end
+
+    it 'should compare with both proc and :strip when both provided' do
+      diff = HashDiff.diff(a, b, :strip => true) do |prefix, obj1, obj2|
+        case prefix
+        when 'a'
+          obj1.length == obj2.length
+        end
+      end
+      diff.should == [['~', 'b', 'boat', 'truck'], ['~', 'c', 'plane', ' plan']]
+    end
+  end
 end
-

data/spec/hashdiff/lcs_spec.rb

@@ -9,6 +9,22 @@ describe HashDiff do
     lcs.should == [[0, 0], [1, 1], [2, 2]]
   end
 
+  it "should be able to find LCS between two close arrays" do
+    a = [1.05, 2, 3.25]
+    b = [1.06, 2, 3.24]
+
+    lcs = HashDiff.lcs(a, b, :numeric_tolerance => 0.1)
+    lcs.should == [[0, 0], [1, 1], [2, 2]]
+  end
+
+  it "should strip strings when finding LCS if requested" do
+    a = ['foo', 'bar', 'baz']
+    b = [' foo', 'bar', 'zab']
+
+    lcs = HashDiff.lcs(a, b, :strip => true)
+    lcs.should == [[0, 0], [1, 1]]
+  end
+
   it "should be able to find LCS with one common elements" do
     a = [1, 2, 3]
     b = [1, 8, 7]
@@ -25,6 +41,14 @@ describe HashDiff do
     lcs.should == [[1, 1], [2, 3]]
   end
 
+  it "should be able to find LCS with two close elements" do
+    a = [1, 3.05, 5, 7]
+    b = [2, 3.06, 7, 5]
+
+    lcs = HashDiff.lcs(a, b, :numeric_tolerance => 0.1)
+    lcs.should == [[1, 1], [2, 3]]
+  end
+
   it "should be able to find LCS with two common elements in different ordering" do
     a = [1, 3, 4, 7]
     b = [2, 3, 7, 5]
@@ -44,7 +68,7 @@ describe HashDiff do
           {"value" => "Close", "onclick" => "CloseDoc()"}
         ]
 
-    lcs = HashDiff.lcs(a, b, 0.5)
+    lcs = HashDiff.lcs(a, b, :similarity => 0.5)
     lcs.should == [[0, 0], [1, 2]]
   end
 end

data/spec/hashdiff/util_spec.rb

@@ -15,7 +15,14 @@ describe HashDiff do
     a = {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}
     b = {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}
     HashDiff.similar?(a, b).should be_true
-    HashDiff.similar?(a, b, 1).should be_false
+    HashDiff.similar?(a, b, :similarity => 1).should be_false
+  end
+
+  it "should be able to tell similiar hash with values within tolerance" do
+    a = {'a' => 1.5, 'b' => 2.25, 'c' => 3, 'd' => 4, 'e' => 5}
+    b = {'a' => 1.503, 'b' => 2.22, 'c' => 3, 'e' => 5}
+    HashDiff.similar?(a, b, :numeric_tolerance => 0.05).should be_true
+    HashDiff.similar?(a, b).should be_false
   end
 
   it "should be able to tell numbers and strings" do
@@ -29,14 +36,38 @@ describe HashDiff do
     a = {"value" => "New1", "onclick" => "CreateNewDoc()"}
     b = {"value" => "New", "onclick" => "CreateNewDoc()"}
 
-    HashDiff.similar?(a, b, 0.5).should be_true
+    HashDiff.similar?(a, b, :similarity => 0.5).should be_true
   end
 
   it "should be able to tell false when similarity == 0.5" do
     a = {"value" => "New1", "onclick" => "open()"}
     b = {"value" => "New", "onclick" => "CreateNewDoc()"}
 
-    HashDiff.similar?(a, b, 0.5).should be_false
+    HashDiff.similar?(a, b, :similarity => 0.5).should be_false
+  end
+
+  describe '.compare_values' do
+    it "should compare numeric values exactly when no tolerance" do
+      expect(HashDiff.compare_values(10.004, 10.003)).to be_false
+    end
+
+    it "should allow tolerance with numeric values" do
+      expect(HashDiff.compare_values(10.004, 10.003, :numeric_tolerance => 0.01)).to be_true
+    end
+
+    it "should compare other objects with or without tolerance" do
+      expect(HashDiff.compare_values('hats', 'ninjas')).to be_false
+      expect(HashDiff.compare_values('hats', 'ninjas', :numeric_tolerance => 0.01)).to be_false
+      expect(HashDiff.compare_values('horse', 'horse')).to be_true
+    end
+
+    it 'should compare strings exactly by default' do
+      expect(HashDiff.compare_values(' horse', 'horse')).to be_false
+    end
+
+    it 'should strip strings before comparing when requested' do
+      expect(HashDiff.compare_values(' horse', 'horse', :strip => true)).to be_true
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-30 00:00:00.000000000 Z
+date: 2014-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec