hashdiff_sym 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1c3c20780bd5ac5b4651aa308d5efe2978c1d87
+  data.tar.gz: 5ed5b1c281805ea581428c5574dc5ff7d93f2237
+SHA512:
+  metadata.gz: 73de6c8ca7869ea1990376f6e3a4c8daedfe9e16f50e15b920df5efb69f59dc84b2bdb81f920c807fb57e46d53c70209f72ffe00494d81cf1fe83b3c81d68a3b
+  data.tar.gz: 26ff1285b00bc83824f946e06499a2c2b371969b0149eeb09245d2e41d66930008d626656fa8fc3e2947bf206a307b1a8f28e083cdec29a8c8d03b6e20899e7c

data/.gitignore

@@ -0,0 +1,15 @@
+# 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
+/Gemfile.lock
+
+*.swp
+*.bak
+*.gem

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+script: "bundle exec rake spec"

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/Gemfile

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

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

@@ -0,0 +1,22 @@
+## Summary
+
+HashDiffSym is a fork of [HashDiff](https://github.com/liufengyun/hashdiff) (by [liufengyun](https://github.com/liufengyun)) with symbols support.
+
+```
+diff = HashDiffSym.diff({ 'a' => { x: 2, y: 3, z: 4 }, 'b' => { x: 3, z: [1, 2, 3] } },
+                        { 'a' => { y: 3 },             'b' => { y: 3, z: [2, 3, 4] } })
+diff.should == [['-', 'a.:x', 2], ['-', 'a.:z', 4], ['-', 'b.:x', 3], ["-", "b.:z[0]", 1], ["+", "b.:z[2]", 4], ['+', 'b.:y', 3]]
+```
+
+Also works for patch:
+
+```
+a = {a: 3}
+b = {a: {a1: 1, a2: 2}}
+diff = HashDiffSym.diff(a, b)
+HashDiffSym.patch!(a, diff).should == b
+```
+
+## License
+
+HashDiffSym 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/changelog.md

@@ -0,0 +1,48 @@
+# Change Log
+
+## v0.3.0 2016-2-11
+
+* support `:case_insensitive` option
+
+## v0.2.3 2015-11-5
+
+* improve performance of LCS algorithm #12
+
+## 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
+
+## 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
+
+## v0.0.6 2013-3-2
+
+* Add parameter for custom property-path delimiter.
+
+## v0.0.5 2012-7-1
+
+* fix a bug in judging whehter two objects are similiar.
+* add more spec test for HashDiffSym.best_diff
+
+## 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/hashdiff_sym.gemspec

@@ -0,0 +1,25 @@
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+require 'hashdiff_sym/version'
+
+Gem::Specification.new do |s|
+  s.name        = %q{hashdiff_sym}
+  s.version     = HashDiffSym::VERSION
+  s.license     = 'MIT'
+  s.summary     = %q{ HashDiffSym is a diff lib to compute the smallest difference between two hashes. }
+  s.description = %q{ HashDiffSym 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", "Alexander Morozov"]
+  s.email   = ["ntcomp12@gmail.com"]
+
+  s.homepage = "https://github.com/kengho/hashdiff_sym"
+
+  s.add_development_dependency("rspec",    "~> 2.0")
+  s.add_development_dependency("yard")
+  s.add_development_dependency("bluecloth")
+end

data/lib/hashdiff_sym/diff.rb

@@ -0,0 +1,220 @@
+module HashDiffSym
+
+  # Best diff two objects, which tries to generate the smallest change set using different similarity values.
+  #
+  # HashDiffSym.best_diff is useful in case of comparing two objects which include similar hashes in arrays.
+  #
+  # @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']]
+  #
+  # @example
+  #   a = {'x' => [{'a' => 1, 'c' => 3, 'e' => 5}, {'y' => 3}]}
+  #   b = {'x' => [{'a' => 1, 'b' => 2, 'e' => 5}] }
+  #   diff = HashDiffSym.best_diff(a, b)
+  #   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 = {}, &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
+
+    opts = { :similarity => 0.5 }.merge!(options)
+    diffs_2 = diff(obj1, obj2, opts)
+    count_2 = count_diff diffs_2
+
+    opts = { :similarity => 0.8 }.merge!(options)
+    diffs_3 = diff(obj1, obj2, opts)
+    count_3 = count_diff 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 or arrays
+  #
+  # @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
+  #
+  # @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']]
+  #
+  # @example
+  #   a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+  #   b = {"a" => 1, "b" => {}}
+  #
+  #   diff = HashDiffSym.diff(a, b)
+  #   diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
+  #
+  # @since 0.0.1
+  def self.diff(obj1, obj2, options = {}, &block)
+    opts = {
+      :prefix      =>   '',
+      :similarity  =>   0.8,
+      :delimiter   =>   '.',
+      :strict      =>   true,
+      :strip       =>   false,
+      :numeric_tolerance => 0
+    }.merge!(options)
+
+    opts[:comparison] = block if block_given?
+
+    # prefer to compare with provided block
+    result = custom_compare(opts[:comparison], opts[:prefix], obj1, obj2)
+    return result if result
+
+    if obj1.nil? and obj2.nil?
+      return []
+    end
+
+    if obj1.nil?
+      return [['~', opts[:prefix], nil, obj2]]
+    end
+
+    if obj2.nil?
+      return [['~', opts[:prefix], obj1, nil]]
+    end
+
+    unless comparable?(obj1, obj2, opts[:strict])
+      return [['~', opts[:prefix], obj1, obj2]]
+    end
+
+    result = []
+    if obj1.is_a?(Array)
+      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]}]")))
+        end
+      end
+
+      changeset.each do |change|
+        if change[0] == '-'
+          result << ['-', "#{opts[:prefix]}[#{change[1]}]", change[2]]
+        elsif change[0] == '+'
+          result << ['+', "#{opts[:prefix]}[#{change[1]}]", change[2]]
+        end
+      end
+    elsif obj1.is_a?(Hash)
+      if opts[:prefix].empty?
+        prefix = ""
+      else
+        prefix = "#{opts[:prefix]}#{opts[:delimiter]}"
+      end
+
+      deleted_keys = obj1.keys - obj2.keys
+      common_keys = obj1.keys & obj2.keys
+      added_keys = obj2.keys - obj1.keys
+
+      # add deleted properties
+      deleted_keys.sort.each do |k|
+        custom_result = custom_compare(opts[:comparison], "#{prefix}#{export_key(k)}", obj1[k], nil)
+
+        if custom_result
+          result.concat(custom_result)
+        else
+          result << ['-', "#{prefix}#{export_key(k)}", obj1[k]]
+        end
+      end
+
+      # recursive comparison for common keys
+      common_keys.sort.each {|k| result.concat(diff(obj1[k], obj2[k], opts.merge(:prefix => "#{prefix}#{export_key(k)}"))) }
+
+      # added properties
+      added_keys.sort.each do |k|
+        unless obj1.key?(k)
+          custom_result = custom_compare(opts[:comparison], "#{prefix}#{export_key(k)}", nil, obj2[k])
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['+', "#{prefix}#{export_key(k)}", obj2[k]]
+          end
+        end
+      end
+    else
+      return [] if compare_values(obj1, obj2, opts)
+      return [['~', opts[:prefix], obj1, obj2]]
+    end
+
+    result
+  end
+
+  # @private
+  #
+  # diff array using LCS algorithm
+  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 []
+    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, opts)
+
+    # 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_sym/lcs.rb

@@ -0,0 +1,69 @@
+module HashDiffSym
+  # @private
+  #
+  # caculate array difference using LCS algorithm
+  # http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
+  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
+    a_finish = a.size - 1
+    b_finish = b.size - 1
+    vector = []
+
+    lcs = []
+    (b_start..b_finish).each do |bi|
+      lcs[bi] = [] 
+      (a_start..a_finish).each do |ai|
+        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
+          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_sym/patch.rb

@@ -0,0 +1,84 @@
+# 
+# This module provides methods to diff two hash, patch and unpatch hash
+#
+module HashDiffSym
+
+  # Apply patch to object
+  #
+  # @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 (String) ['.'] delimiter string for representing nested keys in changes array
+  #
+  # @return the object after patch
+  #
+  # @since 0.0.1
+  def self.patch!(obj, changes, options = {})
+    delimiter = options[:delimiter] || '.'
+
+    changes.each do |change|
+      parts = decode_property_path(change[1], delimiter)
+      last_part = parts.last
+
+      parent_node = node(obj, parts[0, parts.size-1])
+
+      if change[0] == '+'
+        if last_part.is_a?(Fixnum)
+          parent_node.insert(last_part, change[2])
+        else
+          parent_node[last_part] = change[2]
+        end
+      elsif change[0] == '-'
+        if last_part.is_a?(Fixnum)
+          parent_node.delete_at(last_part)
+        else
+          parent_node.delete(last_part)
+        end
+      elsif change[0] == '~'
+        parent_node[last_part] = change[3]
+      end
+    end
+
+    obj
+  end
+
+  # Unpatch an object
+  #
+  # @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 (String) ['.'] delimiter string for representing nested keys in changes array
+  #
+  # @return the object after unpatch
+  #
+  # @since 0.0.1
+  def self.unpatch!(obj, changes, options = {})
+    delimiter = options[:delimiter] || '.'
+
+    changes.reverse_each do |change|
+      parts = decode_property_path(change[1], delimiter)
+      last_part = parts.last
+
+      parent_node = node(obj, parts[0, parts.size-1])
+
+      if change[0] == '+'
+        if last_part.is_a?(Fixnum)
+          parent_node.delete_at(last_part)
+        else
+          parent_node.delete(last_part)
+        end
+      elsif change[0] == '-'
+        if last_part.is_a?(Fixnum)
+          parent_node.insert(last_part, change[2])
+        else
+          parent_node[last_part] = change[2]
+        end
+      elsif change[0] == '~'
+        parent_node[last_part] = change[2]
+      end
+    end
+
+    obj
+  end
+
+end