hashdiff 0.0.2

data/.gitignore

@@ -0,0 +1,13 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+/doc
+/.yardoc
+
+*.swp
+*.bak

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,8 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - rbx
+  - rbx-2.0
+  - ree
+  - jruby
+  - ruby-head

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    hashdiff (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bluecloth (2.2.0)
+    diff-lcs (1.1.3)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    yard (0.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bluecloth
+  hashdiff!
+  rspec (~> 2.0)
+  yard

data/README.md

@@ -0,0 +1,70 @@
+HashDiff
+=========
+
+HashDiff is a ruby library to compute the smallest difference between two hashes.
+
+Requirements
+------------
+HashDiff is tested on following platforms:
+
+- 1.8.7
+- 1.9.2
+- rbx
+- rbx-2.0
+- ree
+- jruby
+- ruby-head
+
+Quick Start
+-----------
+
+### Diff
+
+Two simple hash:
+
+    a = {a:3, b:2}
+    b = {}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'a', 3], ['-', 'b', 2]]
+
+More complex hash:
+
+    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]]
+
+Array in hash:
+
+    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) # best_diff will try to match similar objects in array in order to generate the smallest change set
+    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}}
+
+    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}]
+
+    diff = HashDiff.diff(a, b) # diff two array is OK
+    HashDiff.unpatch(b, diff).should == a
+
+
+License
+-------
+
+HashDiff is distributed under the MIT-LICENSE.
+

data/Rakefile

@@ -0,0 +1,13 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "./spec/**/*_spec.rb"
+end
+

data/hashdiff.gemspec

@@ -0,0 +1,24 @@
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+require 'hashdiff/version'
+
+Gem::Specification.new do |s|
+  s.name        = %q{hashdiff}
+  s.version     = HashDiff::VERSION
+  s.summary     = %q{ HashDiff is a diff lib to compute the smallest difference between two hashes. }
+  s.description = %q{ 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(">= 1.8.7")
+
+  s.authors = ["Liu Fengyun"]
+  s.email   = ["liufengyunchina@gmail.com"]
+
+  s.homepage = "https://github.com/liufengyun/hashdiff"
+
+  s.add_development_dependency("rspec",    "~> 2.0")
+  s.add_development_dependency("yard")
+  s.add_development_dependency("bluecloth")
+end

data/lib/hashdiff.rb

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

data/lib/hashdiff/diff.rb

@@ -0,0 +1,142 @@
+module HashDiff
+
+  # try to make the best diff that generates the smallest change set
+  def self.best_diff(obj1, obj2)
+    diffs_1 = diff(obj1, obj2, "", 0.3)
+    diffs_2 = diff(obj1, obj2, "", 0.5)
+    diffs_3 = diff(obj1, obj2, "", 0.8)
+
+    diffs = diffs_1.size < diffs_2.size ? diffs_1 : diffs_2
+    diffs = diffs.size < diffs_3.size ? diffs : diffs_3
+  end
+
+  # compute the diff of two hashes, return an array of changes
+  # e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  #
+  # NOTE: diff will treat nil as [], {} or "" in comparison according to different context.
+  # 
+  def self.diff(obj1, obj2, prefix = "", similarity = 0.8)
+    if obj1.nil?
+      if obj2.is_a?(Array)
+        return diff([], obj2, prefix, similarity)
+      elsif obj2.is_a?(Hash)
+        return diff({}, obj2, prefix, similarity)
+      else
+        return diff('', obj2, prefix, similarity)
+      end
+    end
+
+    if obj2.nil?
+      if obj1.is_a?(Array)
+        return diff(obj1, [], prefix, similarity)
+      elsif obj1.is_a?(Hash)
+        return diff(obj1, {}, prefix, similarity)
+      else
+        return diff(obj1, '', prefix, similarity)
+      end
+    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)
+    end
+
+    result = []
+    if obj1.is_a?(Array)
+      changeset = diff_array(obj1, obj2, similarity) do |lcs|
+        # use a's index for similarity
+        lcs.each do |pair|
+          result.concat(diff(obj1[pair[0]], obj2[pair[1]], "#{prefix}[#{pair[0]}]", similarity))
+        end
+      end
+
+      changeset.each do |change|
+        if change[0] == '-'
+          result.concat(changed(change[2], '-', "#{prefix}[#{change[1]}]"))
+        elsif change[0] == '+'
+          result.concat(changed(change[2], '+', "#{prefix}[#{change[1]}]"))
+        end
+      end
+    elsif obj1.is_a?(Hash)
+      prefix = prefix.empty? ? "" : "#{prefix}."
+
+      deleted_keys = []
+      common_keys = []
+
+      obj1.each do |k, v|
+        if obj2.key?(k)
+          common_keys << k
+        else
+          deleted_keys << k
+        end
+      end
+
+      # add deleted properties
+      deleted_keys.each {|k| result.concat(changed(obj1[k], '-', "#{prefix}#{k}")) }
+
+      # recursive comparison for common keys
+      common_keys.each {|k| result.concat(diff(obj1[k], obj2[k], "#{prefix}#{k}", similarity)) }
+
+      # added properties
+      obj2.each do |k, v|
+        unless obj1.key?(k)
+          result.concat(changed(obj2[k], '+', "#{prefix}#{k}"))
+        end
+      end
+    else
+      return [] if obj1 == obj2
+      return [['~', prefix, obj1, obj2]]
+    end
+
+    result
+  end
+
+  # diff array using LCS algorithm
+  def self.diff_array(a, b, similarity = 0.8)
+    change_set = []
+    if a.size == 0 and b.size == 0
+      return []
+    elsif a.size == 0
+      b.each_index do |index|
+        change_set << ['+', index, b[index]]
+      end
+      return change_set
+    elsif b.size == 0
+      a.each_index do |index|
+        i = a.size - index - 1
+        change_set << ['-', i, a[i]]
+      end
+      return change_set
+    end
+
+    links = lcs(a, b, similarity)
+
+    # yield common
+    yield links if block_given?
+
+    # padding the end
+    links << [a.size, b.size]
+
+    last_x = -1
+    last_y = -1
+    links.each do |pair|
+      x, y = pair
+
+      # remove from a, beginning from the end
+      (x > last_x + 1) and (x - last_x - 2).downto(0).each do |i|
+        change_set << ['-', last_y + i + 1, a[i + last_x + 1]]
+      end
+
+      # add from b, beginning from the head
+      (y > last_y + 1) and 0.upto(y - last_y - 2).each do |i|
+        change_set << ['+', last_y + i + 1, b[i + last_y + 1]]
+      end
+
+      # update flags
+      last_x = x
+      last_y = y
+    end
+
+    change_set
+  end
+
+end

data/lib/hashdiff/lcs.rb

@@ -0,0 +1,64 @@
+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)
+    return [] if a.size == 0 or b.size == 0
+
+    a_start = b_start = 0
+    a_finish = a.size - 1
+    b_finish = b.size - 1
+    vector = []
+
+    lcs = []
+    (0..b_finish).each do |bi|
+      lcs[bi] = [] 
+      (0..a_finish).each do |ai|
+        if similiar?(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
+          top = (bi > 0)? lcs[bi-1][ai][1] : 0
+          left = (ai > 0)? lcs[bi][ai-1][1] : 0
+          count = (top > left) ? top : left
+
+          direction = :both
+          if top > left
+            direction = :top
+          elsif top < left
+            direction = :left
+          else
+            if bi == 0
+              direction = :top
+            elsif ai == 0
+              direction = :left
+            else
+              direction = :both
+            end
+          end
+
+          lcs[bi][ai] = [direction, count]
+        end
+      end
+    end
+
+    x = a_finish
+    y = b_finish
+    while x >= 0 and y >= 0 and lcs[y][x][1] > 0
+      if lcs[y][x][0] == :both
+        x -= 1
+      elsif lcs[y][x][0] == :topleft
+        vector.insert(0, [x, y])
+        x -= 1
+        y -= 1
+      elsif lcs[y][x][0] == :top
+        y -= 1
+      elsif lcs[y][x][0] == :left
+        x -= 1
+      end
+    end
+
+    vector
+  end
+
+end

data/lib/hashdiff/patch.rb

@@ -0,0 +1,86 @@
+# 
+# This class provides methods to diff two hash, patch and unpatch hash
+#
+module HashDiff
+
+  # apply changes to object
+  #
+  # changes: [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  def self.patch(hash, changes)
+    changes.each do |change|
+      parts = decode_property_path(change[1])
+      last_part = parts.last
+
+      dest_node = node(hash, parts[0, parts.size-1])
+
+      if 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])
+        else
+          dest_node[last_part] = change[2]
+        end
+      elsif change[0] == '-'
+        if last_part.is_a?(Fixnum)
+          dest_node.delete_at(last_part)
+        else
+          dest_node.delete(last_part)
+        end
+      elsif change[0] == '~'
+        dest_node[last_part] = change[3]
+      end
+    end
+
+    hash
+  end
+
+  # undo changes from object.
+  #
+  # changes: [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  def self.unpatch(hash, 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])
+
+      if change[0] == '+'
+        if last_part.is_a?(Fixnum)
+          dest_node.delete_at(last_part)
+        else
+          dest_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])
+        else
+          dest_node[last_part] = change[2]
+        end
+      elsif change[0] == '~'
+        dest_node[last_part] = change[2]
+      end
+    end
+
+    hash
+  end
+
+end

data/lib/hashdiff/util.rb

@@ -0,0 +1,97 @@
+module HashDiff
+
+  # 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
+
+  # judge whether two objects are similar
+  def self.similiar?(a, b, similarity = 0.8)
+    count_a = count_nodes(a)
+    count_b = count_nodes(b)
+    count_diff = diff(a, b, "", similarity).count
+
+    if count_a + count_b == 0
+      return true
+    else
+      (1 - count_diff.to_f/(count_a + count_b).to_f) >= similarity
+    end
+  end
+
+  # count total nodes for an object
+  def self.count_nodes(obj)
+    return 0 unless obj
+
+    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
+    end
+
+    count
+  end
+
+  # decode property path into an array
+  #
+  # e.g. "a.b[3].c" => ['a', 'b', 3, 'c']
+  def self.decode_property_path(path)
+    parts = path.split('.').collect do |part|
+      if part =~ /^(\w*)\[(\d+)\]$/
+        if $1.size > 0
+          [$1, $2.to_i]
+        else
+          $2.to_i
+        end
+      else
+        part
+      end
+    end
+
+    parts.flatten
+  end
+
+  # get the node of hash by given path parts
+  def self.node(hash, parts)
+    temp = hash
+    parts.each do |part|
+      temp = temp[part]
+    end
+    temp
+  end
+
+end

data/lib/hashdiff/version.rb

@@ -0,0 +1,3 @@
+module HashDiff
+  VERSION = '0.0.2'
+end

data/spec/hashdiff/diff_array_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to diff two equal array" do
+    a = [1, 2, 3]
+    b = [1, 2, 3]
+
+    diff = HashDiff.diff_array(a, b)
+    diff.should == []
+  end
+
+  it "should be able to diff two arrays with one element in common" do
+    a = [1, 2, 3]
+    b = [1, 8, 7]
+
+    diff = HashDiff.diff_array(a, b)
+    diff.should == [['-', 2, 3], ['-', 1, 2], ['+', 1, 8], ['+', 2, 7]]
+  end
+
+  it "should be able to diff two arrays with nothing in common" do
+    a = [1, 2]
+    b = []
+
+    diff = HashDiff.diff_array(a, b)
+    diff.should == [['-', 1, 2], ['-', 0, 1]]
+  end
+
+  it "should be able to diff an empty array with an non-empty array" do
+    a = []
+    b = [1, 2]
+
+    diff = HashDiff.diff_array(a, b)
+    diff.should == [['+', 0, 1], ['+', 1, 2]]
+  end
+
+  it "should be able to diff two arrays with two elements in common" do
+    a = [1, 3, 5, 7]
+    b = [2, 3, 7, 5]
+
+    diff = HashDiff.diff_array(a, b)
+    diff.should == [['-', 0, 1], ['+', 0, 2], ['+', 2, 7], ['-', 4, 7]]
+  end
+
+  it "should be able to test two arrays with two common elements in different order" do
+    a = [1, 3, 4, 7]
+    b = [2, 3, 7, 5]
+
+    diff = HashDiff.diff_array(a, b)
+    diff.should == [['-', 0, 1], ['+', 0, 2], ['-', 2, 4], ['+', 3, 5]]
+  end
+
+  it "should be able to diff two arrays with similar elements" do
+    a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, 3]
+    b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+    diff = HashDiff.diff_array(a, b)
+    diff.should == [['+', 0, 1], ['-', 2, 3]]
+  end
+
+end
+

data/spec/hashdiff/diff_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to diff two empty hashes" do
+    diff = HashDiff.diff({}, {})
+    diff.should == []
+  end
+
+  it "should be able to diff an hash with an empty hash" do
+    a = {a:3, b:2}
+    b = {}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'a', 3], ['-', 'b', 2]]
+
+    diff = HashDiff.diff(b, a)
+    diff.should == [['+', 'a', 3], ['+', 'b', 2]]
+  end
+
+  it "should be able to diff two equal hashes" do
+    diff = HashDiff.diff({a:2, b:2}, {a:2, b:2})
+    diff.should == []
+  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]]
+  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.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.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
+  end
+
+  it 'should be able to diff addition of key value pair' 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}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['+', 'g', 300]]
+
+    diff = HashDiff.diff(b, a)
+    diff.should == [['-', 'g', 300]]
+  end
+
+  it 'should be able to diff value type changes' do
+    a = {"a" => 3}
+    b = {"a" => {"a1" => 1, "a2" => 2}}
+
+    diff = HashDiff.diff(a, b)
+    diff.should  == [['-', 'a', 3], ['+', 'a', {}], ['+', 'a.a1', 1], ['+', 'a.a2', 2]]
+
+    diff = HashDiff.diff(b, a)
+    diff.should  == [['-', 'a.a1', 1], ['-', 'a.a2', 2], ['-', 'a', {}], ['+', 'a', 3]]
+  end
+
+  it "should be able to diff value changes: array <=> []" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => []}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1]]
+  end
+
+  # treat nil as empty array
+  it "should be able to diff value changes: array <=> nil" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => nil}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1]]
+  end
+
+  it "should be able to diff value chagnes: remove array completely" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1], ['-', 'b', []]]
+  end
+
+  it "should be able to diff value changes: remove whole hash" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2], ['-', 'b', {}]]
+  end
+
+  it "should be able to diff value changes: hash <=> {}" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => {}}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
+  end
+
+  # treat nil as empty hash
+  it "should be able to diff value changes: hash <=> nil" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => nil}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
+  end
+
+  it "should be able to diff similar objects in array" do
+    a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, 3]
+    b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', '[0].d', 4], ['+', '[0]', 1], ['-', '[2]', 3]]
+  end
+
+  it "should be able to diff similar & equal objects in array" 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)
+    diff.should == [['-', '[0].d', 4], ['-', '[1].x', 5], ['-', '[1].y', 6], ['-', '[1].z', 3], ['-', '[1]', {}]]
+  end
+
+  it "should be able to best diff" do
+    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.should == [['-', 'x[0].c', 3], ['+', 'x[0].b', 2], ['-', 'x[1].y', 3], ['-', 'x[1]', {}]]
+  end
+
+end
+

data/spec/hashdiff/lcs_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to find LCS between two equal array" do
+    a = [1, 2, 3]
+    b = [1, 2, 3]
+
+    lcs = HashDiff.lcs(a, b)
+    lcs.should == [[0, 0], [1, 1], [2, 2]]
+  end
+
+  it "should be able to find LCS with one common elements" do
+    a = [1, 2, 3]
+    b = [1, 8, 7]
+
+    lcs = HashDiff.lcs(a, b)
+    lcs.should == [[0, 0]]
+  end
+
+  it "should be able to find LCS with two common elements" do
+    a = [1, 3, 5, 7]
+    b = [2, 3, 7, 5]
+
+    lcs = HashDiff.lcs(a, b)
+    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]
+
+    lcs = HashDiff.lcs(a, b)
+    lcs.should == [[1, 1], [3, 2]]
+  end
+end
+

data/spec/hashdiff/patch_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "it should be 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}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a"=>3, "c"=>11, "d"=>45, "e"=>100, "f"=>200}
+    b = {"a"=>3, "c"=>11, "d"=>45, "e"=>100, "f"=>200, "g"=>300}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch value type changes" do
+    a = {"a" => 3}
+    b = {"a" => {"a1" => 1, "a2" => 2}}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a" => 3}
+    b = {"a" => {"a1" => 1, "a2" => 2}}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch value array <=> []" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => []}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => []}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch value array <=> nil" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => nil}
+    diff = HashDiff.diff(a, b)
+
+    # NOTE: nil is treated as [] in this context
+    HashDiff.patch(a, diff).should == {"a" => 1, "b" => []}
+
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => nil}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch array value removal" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch hash value removal" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch value hash <=> {}" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => {}}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => {}}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch value hash <=> nil" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => nil}
+    diff = HashDiff.diff(a, b)
+
+    # NOTE: nil will be taken as {} in the context
+    HashDiff.patch(a, diff).should == {"a" => 1, "b" => {}}
+
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => nil}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch value nil removal" do
+    a = {"a" => 1, "b" => nil}
+    b = {"a" => 1}
+    diff = HashDiff.diff(a, b)
+
+    HashDiff.patch(a, diff).should == b
+
+    a = {"a" => 1, "b" => nil}
+    b = {"a" => 1}
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch similar objects between arrays" do
+    a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, 3]
+    b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+
+    diff = HashDiff.diff(a, b)
+    HashDiff.patch(a, diff).should == b
+
+    a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, 3]
+    b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+  it "should be able to patch similar & equal objects between arrays" do
+    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)
+    HashDiff.patch(a, diff).should == b
+
+    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}]
+    HashDiff.unpatch(b, diff).should == a
+  end
+
+end
+

data/spec/hashdiff/util_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to decode property path" do
+    decoded = HashDiff.send(:decode_property_path, "a.b[0].c.city[5]")
+    decoded.should == ['a', 'b', 0, 'c', 'city', 5]
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'rspec'
+require 'rspec/autorun'
+
+require 'hashdiff'
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+
+  config.include RSpec::Matchers
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: hashdiff
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Liu Fengyun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &8876060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *8876060
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &8874480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8874480
+- !ruby/object:Gem::Dependency
+  name: bluecloth
+  requirement: &8859740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8859740
+description: ! ' HashDiff is a diff lib to compute the smallest difference between
+  two hashes. '
+email:
+- liufengyunchina@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- hashdiff.gemspec
+- lib/hashdiff.rb
+- lib/hashdiff/diff.rb
+- lib/hashdiff/lcs.rb
+- lib/hashdiff/patch.rb
+- lib/hashdiff/util.rb
+- lib/hashdiff/version.rb
+- spec/hashdiff/diff_array_spec.rb
+- spec/hashdiff/diff_spec.rb
+- spec/hashdiff/lcs_spec.rb
+- spec/hashdiff/patch_spec.rb
+- spec/hashdiff/util_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/liufengyun/hashdiff
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: HashDiff is a diff lib to compute the smallest difference between two hashes.
+test_files: []
+has_rdoc: