hashdiff 0.2.1 → 0.2.2

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 1.8.7
   - 1.9.3
   - 2.0.0
   - 2.1.1

data/README.md

@@ -8,7 +8,7 @@ HashDiff is a ruby library to compute the smallest difference between two hashes
 
 ## Why HashDiff?
 
-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?
+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?
 
 An algorithm that responds to this question has to do following:
 
@@ -16,11 +16,11 @@ 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 in 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]]`.
-* It compares Arrays using LCS(longest common subsequence) algorithm.
+* It compares Arrays using the [LCS(longest common subsequence)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem) algorithm.
 * It recognizes similar Hashes in an Array using a similarity value (0 < similarity <= 1).
 
 ## Usage
@@ -171,6 +171,38 @@ 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.
 
+#### 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.
+
+```ruby
+a = {a:'car', b:['boat', 'plane'] }
+b = {a:'car', b:['plane', 'boat'] }
+
+HashDiff.diff(a, b) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
+
+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.

data/changelog.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## 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

data/lib/hashdiff/diff.rb

@@ -27,15 +27,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
 
@@ -104,7 +104,7 @@ 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]}]")))
+          result.concat(diff(obj1[pair[0]], obj2[pair[1]], opts.merge(:prefix => "#{opts[:prefix]}[#{pair[0]}]")))
         end
       end
 
@@ -122,19 +122,12 @@ module HashDiff
         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|
+      deleted_keys.sort.each do |k|
         custom_result = custom_compare(opts[:comparison], "#{prefix}#{k}", obj1[k], nil)
 
         if custom_result
@@ -145,12 +138,12 @@ module HashDiff
       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.each {|k| result.concat(diff(obj1[k], obj2[k], opts.merge(:prefix => "#{prefix}#{k}"))) }
 
       # added properties
-      obj2.each do |k, v|
+      added_keys.sort.each do |k|
         unless obj1.key?(k)
-          custom_result = custom_compare(opts[:comparison], "#{prefix}#{k}", nil, v)
+          custom_result = custom_compare(opts[:comparison], "#{prefix}#{k}", nil, obj2[k])
 
           if custom_result
             result.concat(custom_result)

data/lib/hashdiff/version.rb

@@ -1,3 +1,3 @@
 module HashDiff
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/spec/hashdiff/diff_spec.rb

@@ -7,7 +7,7 @@ describe HashDiff do
   end
 
   it "should be able to diff an hash with an empty hash" do
-    a = {a:3, b:2}
+    a = { 'a' => 3, 'b' => 2 }
     b = {}
 
     diff = HashDiff.diff(a, b)
@@ -18,32 +18,34 @@ describe HashDiff do
   end
 
   it "should be able to diff two equal hashes" do
-    diff = HashDiff.diff({a:2, b:2}, {a:2, b:2})
+    diff = HashDiff.diff({ 'a' => 2, 'b' => 2}, { 'a' => 2, 'b' => 2 })
     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 = 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 = 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 = HashDiff.diff({ 'a' => 2, 'b' => [1, 2, 3] }, { 'a' => 2, 'b' => [1, 3, 4]})
     diff.should == [['-', 'b[1]', 2], ['+', 'b[2]', 4]]
   end
 
   it "should be able to diff changes in hash value which is hash" do
-    diff = HashDiff.diff({a:{x:2, y:3, z:4}, b:{x:3, z:45}}, {a:{y:3}, b:{y:3, z:30}})
+    diff = HashDiff.diff({ 'a' => { 'x' => 2, 'y' => 3, 'z' => 4 }, 'b' => { 'x' => 3, 'z' => 45 } },
+                         { 'a' => { 'y' => 3 }, 'b' => { 'y' => 3, 'z' => 30 } })
     diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
   end
 
   it "should be able to diff similar objects in array" do
-    diff = HashDiff.best_diff({a:[{x:2, y:3, z:4}, {x:11, y:22, z:33}], b:{x:3, z:45}}, {a:[{y:3}, {x:11, z:33}], b:{y:22}})
+    diff = HashDiff.best_diff({ 'a' => [{ 'x' => 2, 'y' => 3, 'z' => 4 }, { 'x' => 11, 'y' => 22, 'z' => 33 }], 'b' => { 'x' => 3, 'z' => 45 } },
+                              { 'a' => [{ 'y' => 3 }, { 'x' => 11, 'z' => 33 }], 'b' => { 'y' => 22 } })
     diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
   end
 
@@ -137,7 +139,7 @@ describe HashDiff do
     a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, {'x' => 5, 'y' => 6, 'z' => 3}, 3]
     b = [{'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}, 3]
 
-    diff = HashDiff.diff(a, b, similarity: 0.8, delimiter: "\t")
+    diff = HashDiff.diff(a, b, :similarity => 0.8, :delimiter => "\t")
     diff.should == [["-", "[0]\td", 4], ["-", "[1]", {"x"=>5, "y"=>6, "z"=>3}]]
   end
 
@@ -167,15 +169,15 @@ describe HashDiff do
 
   context 'when :strip requested' do
     it "should strip strings before comparing" do
-      a = {a:" foo", b:"fizz buzz"}
-      b = {a:"foo", b:"fizzbuzz"}
+      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"]}
+      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
@@ -183,16 +185,16 @@ describe HashDiff do
 
   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}
+      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'} }
+    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|
@@ -205,8 +207,8 @@ describe HashDiff do
     end
 
     it 'should yield added keys' do
-      x = {a:'car', b:'boat'}
-      y = {a:'car'}
+      x = { 'a' => 'car', 'b' => 'boat'}
+      y = { 'a' => 'car' }
 
       diff = HashDiff.diff(x, y) do |prefix, obj1, obj2|
         case prefix

metadata

@@ -1,65 +1,75 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: hashdiff
-version: !ruby/object:Gem::Version
-  version: 0.2.1
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
 platform: ruby
-authors:
+authors: 
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-10-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
   type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bluecloth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bluecloth
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: ' HashDiff is a diff lib to compute the smallest difference between two
-  hashes. '
-email:
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: " HashDiff is a diff lib to compute the smallest difference between two hashes. "
+email: 
 - liufengyunchina@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .rspec
 - .travis.yml
@@ -84,28 +94,40 @@ files:
 - spec/hashdiff/util_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/liufengyun/hashdiff
-licenses:
+licenses: 
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - '>='
-    - !ruby/object:Gem::Version
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: HashDiff is a diff lib to compute the smallest difference between two hashes.
 test_files: []
+
 has_rdoc: 

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: d8b0a6ff22612f26b5bca9a05e0aa2a59903d8ea
-  data.tar.gz: 239c5cc0d80aad921ab88ae4712c215598b964e5
-SHA512:
-  metadata.gz: f32454eb369913c1ef2da688d843d3fa2f06b7d98d14cbea8a586534735cf0ac548beef2c49608e5d637d0569c08567b11b8bc89a575b01c13ec855be7f51f29
-  data.tar.gz: dcd6291074a3038274b07ea772f210050dcd8cd448ed0d9b53a47572206bae3d9a64d19b1807194fd10a5ba69e9466999889fc7b190c4e505198c72b9a8887c2