hashdiff 0.0.3 → 0.0.4

data/.travis.yml

@@ -1,11 +1,6 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3
-  - rbx
-  - rbx-2.0
-  - ree
-  - jruby
   - ruby-head
 script: "bundle exec rake spec"

data/Gemfile

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

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    hashdiff (0.0.1)
+    hashdiff (0.0.3)
 
 GEM
   remote: http://rubygems.org/
   specs:
     bluecloth (2.2.0)
     diff-lcs (1.1.3)
+    rake (0.9.2.2)
     rspec (2.10.0)
       rspec-core (~> 2.10.0)
       rspec-expectations (~> 2.10.0)
@@ -24,5 +25,6 @@ PLATFORMS
 DEPENDENCIES
   bluecloth
   hashdiff!
+  rake
   rspec (~> 2.0)
   yard

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Liu Fengyun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -1,24 +1,38 @@
-HashDiff
-=========
+# HashDiff
+
+[![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.png)](http://travis-ci.org/liufengyun/hashdiff)
 
 HashDiff is a ruby library to compute the smallest difference between two hashes.
 
-Requirements
-------------
-HashDiff is tested on following platforms:
+**Demo**: [HashDiff](http://hashdiff.herokuapp.com/)
+
+**Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
+
+## 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?
+
+An algorithm 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.
 
-- 1.8.7
-- 1.9.2
-- 1.9.3
-- rbx
-- rbx-2.0
-- ree
-- jruby
-- ruby-head
+HashDiff answers the question above in an opinionated approach:
 
-Usage
-------------
-If you're using bundler, add following:
+* 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]]`.
+* It compares Arrays using LCS(longest common subsequence) algorithm.
+* It recoganize similar Hashes in Array using a similarity value(0 < similarity <= 1).
+
+
+## Compatibility
+
+HashDiff is tested against `1.9.2`, `1.9.3` and `ruby-head`. It should work on other versions as well.
+
+## Usage
+
+If you're using bundler, add following to the Gemfile:
 
     gem 'hashdiff'
 
@@ -26,10 +40,7 @@ Or, you can run `gem install hashdiff`, then add following line to your ruby fil
 
     require 'hashdiff'
 
-Quick Start
------------
-
-You can find full docs here: [Documentation](http://rubydoc.info/gems/hashdiff)
+## Quick Start
 
 ### Diff
 
@@ -65,7 +76,7 @@ patch example:
     b = {a: {a1: 1, a2: 2}}
 
     diff = HashDiff.diff(a, b)
-    HashDiff.patch(a, diff).should == b
+    HashDiff.patch!(a, diff).should == b
 
 unpatch example:
 
@@ -73,11 +84,10 @@ unpatch example:
     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
+    HashDiff.unpatch!(b, diff).should == a
 
 
-License
--------
+## License
 
 HashDiff is distributed under the MIT-LICENSE.
 

data/changelog.md

@@ -0,0 +1,14 @@
+# Change Log
+
+## v0.0.4 2012-6-24
+
+Main changes in this version is to output the whole object in addition & deletion, instead of recursely add/deletes the object.
+
+For example, `diff({a:2, c:[4, 5]}, {a:2}) will generate following output:
+
+    [['-', 'c', [4, 5]]]
+
+instead of following:
+
+    [['-', 'c[0]', 4], ['-', 'c[1]', 5], ['-', 'c', []]]
+

data/lib/hashdiff/diff.rb

@@ -1,6 +1,6 @@
 module HashDiff
 
-  # Best diff two objects, which tries to generate the smallest change set.
+  # Best diff two objects, which tries to generate the smallest change set using different similarity values.
   #
   # HashDiff.best_diff is only meaningful in case of comparing two objects which includes similar objects in array.
   #
@@ -19,11 +19,16 @@ module HashDiff
   # @since 0.0.1
   def self.best_diff(obj1, obj2)
     diffs_1 = diff(obj1, obj2, "", 0.3)
+    count_1 = count_diff diffs_1
+
     diffs_2 = diff(obj1, obj2, "", 0.5)
+    count_2 = count_diff diffs_2
+
     diffs_3 = diff(obj1, obj2, "", 0.8)
+    count_3 = count_diff diffs_3
 
-    diffs = diffs_1.size < diffs_2.size ? diffs_1 : diffs_2
-    diffs = diffs.size < diffs_3.size ? diffs : diffs_3
+    count, diffs = count_1 < count_2 ? [count_1, diffs_1] : [count_2, diffs_2]
+    diffs = count < count_3 ? diffs : diffs_3
   end
 
   # Compute the diff of two hashes
@@ -51,15 +56,15 @@ module HashDiff
     end
 
     if obj1.nil?
-      return [['-', prefix, nil]] + changed(obj2, '+', prefix)
+      return [['~', prefix, nil, obj2]]
     end
 
     if obj2.nil?
-      return changed(obj1, '-', prefix) + [['+', prefix, nil]]
+      return [['~', 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))
-      return changed(obj1, '-', prefix) + changed(obj2, '+', prefix)
+      return [['~', prefix, obj1, obj2]]
     end
 
     result = []
@@ -73,9 +78,9 @@ module HashDiff
 
       changeset.each do |change|
         if change[0] == '-'
-          result.concat(changed(change[2], '-', "#{prefix}[#{change[1]}]"))
+          result << ['-', "#{prefix}[#{change[1]}]", change[2]]
         elsif change[0] == '+'
-          result.concat(changed(change[2], '+', "#{prefix}[#{change[1]}]"))
+          result << ['+', "#{prefix}[#{change[1]}]", change[2]]
         end
       end
     elsif obj1.is_a?(Hash)
@@ -93,7 +98,7 @@ module HashDiff
       end
 
       # add deleted properties
-      deleted_keys.each {|k| result.concat(changed(obj1[k], '-', "#{prefix}#{k}")) }
+      deleted_keys.each {|k| result << ['-', "#{prefix}#{k}", obj1[k]] }
 
       # recursive comparison for common keys
       common_keys.each {|k| result.concat(diff(obj1[k], obj2[k], "#{prefix}#{k}", similarity)) }
@@ -101,7 +106,7 @@ module HashDiff
       # added properties
       obj2.each do |k, v|
         unless obj1.key?(k)
-          result.concat(changed(obj2[k], '+', "#{prefix}#{k}"))
+          result << ['+', "#{prefix}#{k}", obj2[k]]
         end
       end
     else

data/lib/hashdiff/lcs.rb

@@ -15,7 +15,7 @@ module HashDiff
     (0..b_finish).each do |bi|
       lcs[bi] = [] 
       (0..a_finish).each do |ai|
-        if similiar?(a[ai], b[bi], similarity)
+        if similar?(a[ai], b[bi], similarity)
           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

@@ -16,32 +16,22 @@ module HashDiff
       parts = decode_property_path(change[1])
       last_part = parts.last
 
-      dest_node = node(obj, parts[0, parts.size-1])
+      parent_node = node(obj, parts[0, parts.size-1])
 
       if change[0] == '+'
-        if dest_node == nil
-          parent_key = parts[parts.size-2]
-          parent_node = node(obj, parts[0, parts.size-2])
-          if last_part.is_a?(Fixnum)
-            dest_node = parent_node[parent_key] = []
-          else
-            dest_node = parent_node[parent_key] = {}
-          end
-        end
-
         if last_part.is_a?(Fixnum)
-          dest_node.insert(last_part, change[2])
+          parent_node.insert(last_part, change[2])
         else
-          dest_node[last_part] = change[2]
+          parent_node[last_part] = change[2]
         end
       elsif change[0] == '-'
         if last_part.is_a?(Fixnum)
-          dest_node.delete_at(last_part)
+          parent_node.delete_at(last_part)
         else
-          dest_node.delete(last_part)
+          parent_node.delete(last_part)
         end
       elsif change[0] == '~'
-        dest_node[last_part] = change[3]
+        parent_node[last_part] = change[3]
       end
     end
 
@@ -56,41 +46,31 @@ module HashDiff
   # @return the object after unpatch
   #
   # @since 0.0.1
-  def self.unpatch!(hash, changes)
+  def self.unpatch!(obj, changes)
     changes.reverse_each do |change|
       parts = decode_property_path(change[1])
       last_part = parts.last
 
-      dest_node = node(hash, parts[0, parts.size-1])
+      parent_node = node(obj, parts[0, parts.size-1])
 
       if change[0] == '+'
         if last_part.is_a?(Fixnum)
-          dest_node.delete_at(last_part)
+          parent_node.delete_at(last_part)
         else
-          dest_node.delete(last_part)
+          parent_node.delete(last_part)
         end
       elsif change[0] == '-'
-        if dest_node == nil
-          parent_key = parts[parts.size-2]
-          parent_node = node(hash, parts[0, parts.size-2])
-          if last_part.is_a?(Fixnum)
-            dest_node = parent_node[parent_key] = []
-          else
-            dest_node = parent_node[parent_key] = {}
-          end
-        end
-
         if last_part.is_a?(Fixnum)
-          dest_node.insert(last_part, change[2])
+          parent_node.insert(last_part, change[2])
         else
-          dest_node[last_part] = change[2]
+          parent_node[last_part] = change[2]
         end
       elsif change[0] == '~'
-        dest_node[last_part] = change[2]
+        parent_node[last_part] = change[2]
       end
     end
 
-    hash
+    obj
   end
 
 end

data/lib/hashdiff/util.rb

@@ -1,54 +1,28 @@
 module HashDiff
 
-  # @private
-  #
-  # return an array of added properties
-  # e.g. [[ '+', 'a.b', 45 ], [ '-', 'a.c', 5 ]]
-  def self.changed(obj, sign, prefix = "")
-    return [[sign, prefix, obj]] unless obj
-
-    results = []
-    if obj.is_a?(Array)
-      if sign == '+'
-        # add from the begining
-        results << [sign, prefix, []]
-        obj.each_index do |index|
-          results.concat(changed(obj[index], sign, "#{prefix}[#{index}]"))
-        end
-      elsif sign == '-'
-        # delete from the end
-        obj.each_index do |index|
-          i = obj.size - index - 1
-          results.concat(changed(obj[i], sign, "#{prefix}[#{i}]"))
-        end
-        results << [sign, prefix, []]
-      end
-    elsif obj.is_a?(Hash)
-      results << [sign, prefix, {}] if sign == '+'
-      prefix_t = prefix.empty? ? "" : "#{prefix}."
-      obj.each do |k, v|
-        results.concat(changed(v, sign, "#{prefix_t}#{k}"))
-      end
-      results << [sign, prefix, {}] if sign == '-'
-    else
-      return [[sign, prefix, obj]]
-    end
-
-    results
-  end
-
   # @private
   #
   # judge whether two objects are similar
-  def self.similiar?(a, b, similarity = 0.8)
+  def self.similar?(a, b, similarity = 0.8)
     count_a = count_nodes(a)
     count_b = count_nodes(b)
-    count_diff = diff(a, b, "", similarity).count
+    diffs = count_diff diff(a, b, "", similarity)
 
     if count_a + count_b == 0
       return true
     else
-      (1 - count_diff.to_f/(count_a + count_b).to_f) >= similarity
+      (1 - diffs.to_f/(count_a + count_b).to_f) >= similarity
+    end
+  end
+
+  # @private
+  #
+  # count node differences
+  def self.count_diff(diffs)
+    diffs.inject(0) do |sum, item|
+      old_change_count = count_nodes(item[2])
+      new_change_count = count_nodes(item[3])
+      sum += (old_change_count > new_change_count ? old_change_count : new_change_count)
     end
   end
 
@@ -60,10 +34,8 @@ module HashDiff
 
     count = 0
     if obj.is_a?(Array)
-      count = obj.size
       obj.each {|e| count += count_nodes(e) }
     elsif obj.is_a?(Hash)
-      count = obj.size
       obj.each {|k, v| count += count_nodes(v) }
     else
       return 1

data/lib/hashdiff/version.rb

@@ -1,3 +1,3 @@
 module HashDiff
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/spec/hashdiff/diff_spec.rb

@@ -53,10 +53,10 @@ describe HashDiff do
     b = {"a" => {"a1" => 1, "a2" => 2}}
 
     diff = HashDiff.diff(a, b)
-    diff.should  == [['-', 'a', 3], ['+', 'a', {}], ['+', 'a.a1', 1], ['+', 'a.a2', 2]]
+    diff.should  == [['~', 'a', 3, {"a1" => 1, "a2" => 2}]]
 
     diff = HashDiff.diff(b, a)
-    diff.should  == [['-', 'a.a1', 1], ['-', 'a.a2', 2], ['-', 'a', {}], ['+', 'a', 3]]
+    diff.should  == [['~', 'a', {"a1" => 1, "a2" => 2}, 3]]
   end
 
   it "should be able to diff value changes: array <=> []" do
@@ -72,7 +72,7 @@ describe HashDiff do
     b = {"a" => 1, "b" => nil}
 
     diff = HashDiff.diff(a, b)
-    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1], ['-', 'b', []], ['+', 'b', nil]]
+    diff.should == [["~", "b", [1, 2], nil]]
   end
 
   it "should be able to diff value chagnes: remove array completely" do
@@ -80,7 +80,7 @@ describe HashDiff do
     b = {"a" => 1}
 
     diff = HashDiff.diff(a, b)
-    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1], ['-', 'b', []]]
+    diff.should == [["-", "b", [1, 2]]]
   end
 
   it "should be able to diff value changes: remove whole hash" do
@@ -88,7 +88,7 @@ describe HashDiff do
     b = {"a" => 1}
 
     diff = HashDiff.diff(a, b)
-    diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2], ['-', 'b', {}]]
+    diff.should == [["-", "b", {"b1"=>1, "b2"=>2}]]
   end
 
   it "should be able to diff value changes: hash <=> {}" do
@@ -104,7 +104,7 @@ describe HashDiff do
     b = {"a" => 1, "b" => nil}
 
     diff = HashDiff.diff(a, b)
-    diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2], ['-', 'b', {}], ['+', 'b', nil]]
+    diff.should == [["~", "b", {"b1"=>1, "b2"=>2}, nil]]
   end
 
   it "should be able to diff similar objects in array" do
@@ -120,7 +120,7 @@ describe HashDiff do
     b = [{'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}, 3]
 
     diff = HashDiff.diff(a, b)
-    diff.should == [['-', '[0].d', 4], ['-', '[1].x', 5], ['-', '[1].y', 6], ['-', '[1].z', 3], ['-', '[1]', {}]]
+    diff.should == [["-", "[0].d", 4], ["-", "[1]", {"x"=>5, "y"=>6, "z"=>3}]]
   end
 
   it "should be able to best diff" do
@@ -128,7 +128,7 @@ describe HashDiff do
     b = {'x' => [{'a' => 1, 'b' => 2, 'e' => 5}] }
 
     diff = HashDiff.best_diff(a, b)
-    diff.should == [['-', 'x[0].c', 3], ['+', 'x[0].b', 2], ['-', 'x[1].y', 3], ['-', 'x[1]', {}]]
+    diff.should == [["-", "x[0].c", 3], ["+", "x[0].b", 2], ["-", "x[1]", {"y"=>3}]]
   end
 
 end

data/spec/hashdiff/util_spec.rb

@@ -5,5 +5,19 @@ describe HashDiff do
     decoded = HashDiff.send(:decode_property_path, "a.b[0].c.city[5]")
     decoded.should == ['a', 'b', 0, 'c', 'city', 5]
   end
+
+  it "should be able to tell similiar hash" 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
+  end
+
+  it "should be able to tell numbers and strings" do
+    HashDiff.similar?(1, 2).should_not be_true
+    HashDiff.similar?("a", "b").should_not be_true
+    HashDiff.similar?("a", [1, 2, 3]).should_not be_true
+    HashDiff.similar?(1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}).should_not be_true
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-03 00:00:00.000000000Z
+date: 2012-06-24 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &14927020 !ruby/object:Gem::Requirement
+  requirement: &29117920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.0'
   type: :development
   prerelease: false
-  version_requirements: *14927020
+  version_requirements: *29117920
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &14926640 !ruby/object:Gem::Requirement
+  requirement: &29117540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14926640
+  version_requirements: *29117540
 - !ruby/object:Gem::Dependency
   name: bluecloth
-  requirement: &14926180 !ruby/object:Gem::Requirement
+  requirement: &29116960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14926180
+  version_requirements: *29116960
 description: ! ' HashDiff is a diff lib to compute the smallest difference between
   two hashes. '
 email:
@@ -58,8 +58,10 @@ files:
 - .yardopts
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
+- changelog.md
 - hashdiff.gemspec
 - lib/hashdiff.rb
 - lib/hashdiff/diff.rb