hashdiff 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ba86448df8842fe6323572feb2c89110954b775
-  data.tar.gz: e3d610f32c07e65e06f825e107371caaaf2e5896
+  metadata.gz: 6af49f121e2b09e5dcdf8a649f6d48c25f63ae03
+  data.tar.gz: c6738c2b03d36f622ac1e0a3c228a863b691ac29
 SHA512:
-  metadata.gz: 7e7b28d277160a603df99c83022f6b8bd7bb27ac5d467e351e5834ba955195ed493249b7a7e213dafe0cb1aa630c5de46fe11a95b5942de4ba9c1f4e66262ec3
-  data.tar.gz: d5290cbc0b5c97038cce213e627fc20fcaf4e7405888c217c78b949c8fc98990ab6d3ae18b0f91d2909c069ffccc20a9d0d45aa572419252aa6eae960df6491d
+  metadata.gz: 8dfda8cd1b17af2c64ea4626570e7d858b76a5ed918df4b6a5703c63e0ae43c371cbe5e3573b4382aa1491915f48335e62d3b4300f3c678660f329f39e8d9b62
+  data.tar.gz: 71ab91ba878e19c436dbad30cc08c85645aadf6aabeed889dc8e3661102d2ddf5a98b12c7a6a8b1007a5115f64e082829f88d99abe11ad87f2a69cf504f28885

data/.travis.yml

@@ -4,7 +4,10 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.10
-  - 2.2.6
-  - 2.3.3
-  - 2.4.0
+  - 2.2.8
+  - 2.3.4
+  - 2.4.2
 script: "bundle exec rake spec"
+
+before_install:
+  - gem install bundler

data/Gemfile

@@ -3,5 +3,4 @@ gemspec
 
 group :test do
   gem 'rake', '< 11'
-  gem 'codecov'
 end

data/README.md

@@ -91,9 +91,9 @@ HashDiff.unpatch!(b, diff).should == a
 
 ### Options
 
-There are seven options available: `:delimiter`, `:similarity`,
-`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`
-and `:array_path`.
+There are eight options available: `:delimiter`, `:similarity`,
+`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path`
+and `:use_lcs`
 
 #### `:delimiter`
 
@@ -184,6 +184,28 @@ diff = HashDiff.diff(a, b, :array_path => true)
 diff.should == [["~", [:a], [1], {0=>1}]]
 ```
 
+#### `:use_lcs`
+
+The :use_lcs option is used to specify whether a
+[Longest common subsequence](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)
+(LCS) algorithm is used to determine differences in arrays. This defaults to
+`true` but can be changed to `false` for significantly faster array comparisons
+(O(n) complexity rather than O(n<sup>2</sup>) for LCS).
+
+When :use_lcs is false the results of array comparisons have a tendency to
+show changes at indexes rather than additions and subtractions when :use_lcs is
+true.
+
+Note, currently the :similarity option has no effect when :use_lcs is false.
+
+```ruby
+a = {x: [0, 1, 2]}
+b = {x: [0, 2, 2, 3]}
+
+diff = HashDiff.diff(a, b, :use_lcs => false)
+diff.should == [["~", "x[1]", 1, 2], ["+", "x[3]", 3]]
+```
+
 #### Specifying a custom comparison method
 
 It's possible to specify how the values of a key should be compared.

data/changelog.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## v0.3.7 2017-10-08
+
+* remove 1.8.7 support from gemspec #39
+
+## v0.3.6 2017-08-22
+
+* add option `use_lcs` #35
+
 ## v0.3.5 2017-08-06
 
 * add option `array_path` #34

data/hashdiff.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   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.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
 
   s.authors = ["Liu Fengyun"]
   s.email   = ["liufengyunchina@gmail.com"]

data/lib/hashdiff.rb

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

data/lib/hashdiff/diff.rb

@@ -12,6 +12,7 @@ module HashDiff
   #   * :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
   #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
+  #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
   #
   # @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.
   #
@@ -55,6 +56,8 @@ module HashDiff
   #   * :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
   #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
+  #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
+  #
   #
   # @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.
   #
@@ -77,7 +80,8 @@ module HashDiff
       :strict      =>   true,
       :strip       =>   false,
       :numeric_tolerance => 0,
-      :array_path  =>   false
+      :array_path  =>   false,
+      :use_lcs     =>   true
     }.merge!(options)
 
     opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
@@ -105,8 +109,8 @@ module HashDiff
     end
 
     result = []
-    if obj1.is_a?(Array)
-      changeset = diff_array(obj1, obj2, opts) do |lcs|
+    if obj1.is_a?(Array) && opts[:use_lcs]
+      changeset = diff_array_lcs(obj1, obj2, opts) do |lcs|
         # use a's index for similarity
         lcs.each do |pair|
           prefix = prefix_append_array_index(opts[:prefix], pair[0], opts)
@@ -122,6 +126,8 @@ module HashDiff
           result << ['+', change_key, change[2]]
         end
       end
+    elsif obj1.is_a?(Array) && !opts[:use_lcs]
+      result.concat(LinearCompareArray.call(obj1, obj2, opts))
     elsif obj1.is_a?(Hash)
 
       deleted_keys = obj1.keys - obj2.keys
@@ -170,7 +176,7 @@ module HashDiff
   # @private
   #
   # diff array using LCS algorithm
-  def self.diff_array(a, b, options = {})
+  def self.diff_array_lcs(a, b, options = {})
     opts = {
       :prefix      =>   '',
       :similarity  =>   0.8,
@@ -223,5 +229,4 @@ module HashDiff
 
     change_set
   end
-
 end

data/lib/hashdiff/linear_compare_array.rb

@@ -0,0 +1,155 @@
+module HashDiff
+  # @private
+  #
+  # Used to compare arrays in a linear complexity, which produces longer diffs
+  # than using the lcs algorithm but is considerably faster
+  class LinearCompareArray
+    def self.call(old_array, new_array, options = {})
+      instance = self.new(old_array, new_array, options)
+      instance.call
+    end
+
+    def call
+      return [] if old_array.empty? && new_array.empty?
+
+      self.old_index = 0
+      self.new_index = 0
+      # by comparing the array lengths we can expect that a number of items
+      # are either added or removed
+      self.expected_additions = new_array.length - old_array.length
+
+      loop do
+        if extra_items_in_old_array?
+          append_deletion(old_array[old_index], old_index)
+        elsif extra_items_in_new_array?
+          append_addition(new_array[new_index], new_index)
+        else
+          compare_at_index
+        end
+
+        self.old_index = old_index + 1
+        self.new_index = new_index + 1
+        break if iterated_through_both_arrays?
+      end
+
+      changes
+    end
+
+    private
+
+    attr_reader :old_array, :new_array, :options, :additions, :deletions, :differences
+    attr_accessor :old_index, :new_index, :expected_additions
+
+    def initialize(old_array, new_array, options)
+      @old_array = old_array
+      @new_array = new_array
+      @options = { prefix: '' }.merge!(options)
+
+      @additions = []
+      @deletions = []
+      @differences = []
+    end
+
+    def extra_items_in_old_array?
+      old_index < old_array.length && new_index >= new_array.length
+    end
+
+    def extra_items_in_new_array?
+      new_index < new_array.length && old_index >= old_array.length
+    end
+
+    def iterated_through_both_arrays?
+      old_index >= old_array.length && new_index >= new_array.length
+    end
+
+    def compare_at_index
+      difference = item_difference(old_array[old_index], new_array[new_index], old_index)
+      return if difference.empty?
+
+      index_after_additions = index_of_match_after_additions
+      append_addititions_before_match(index_after_additions)
+
+      index_after_deletions = index_of_match_after_deletions
+      append_deletions_before_match(index_after_deletions)
+
+      match = index_after_additions || index_after_deletions
+
+      append_differences(difference) unless match
+    end
+
+    def item_difference(old_item, new_item, item_index)
+      prefix = HashDiff.prefix_append_array_index(options[:prefix], item_index, options)
+      HashDiff.diff(old_item, new_item, options.merge(:prefix => prefix))
+    end
+
+    # look ahead in the new array to see if the current item appears later
+    # thereby having new items added
+    def index_of_match_after_additions
+      return unless expected_additions > 0
+
+      (1..expected_additions).each do |i|
+        next_difference = item_difference(
+          old_array[old_index],
+          new_array[new_index + i],
+          old_index
+        )
+
+        return new_index + i if next_difference.empty?
+      end
+
+      nil
+    end
+
+    # look ahead in the old array to see if the current item appears later
+    # thereby having items removed
+    def index_of_match_after_deletions
+      return unless expected_additions < 0
+
+      (1..(expected_additions.abs)).each do |i|
+        next_difference = item_difference(
+          old_array[old_index + i],
+          new_array[new_index],
+          old_index
+        )
+
+        return old_index + i if next_difference.empty?
+      end
+
+      nil
+    end
+
+    def append_addititions_before_match(match_index)
+      return unless match_index
+      (new_index...match_index).each { |i| append_addition(new_array[i], i) }
+      self.expected_additions = expected_additions - (match_index - new_index)
+      self.new_index = match_index
+    end
+
+    def append_deletions_before_match(match_index)
+      return unless match_index
+      (old_index...match_index).each { |i| append_deletion(old_array[i], i) }
+      self.expected_additions = expected_additions + (match_index - new_index)
+      self.old_index = match_index
+    end
+
+    def append_addition(item, index)
+      key = HashDiff.prefix_append_array_index(options[:prefix], index, options)
+      additions << ['+', key, item]
+    end
+
+    def append_deletion(item, index)
+      key = HashDiff.prefix_append_array_index(options[:prefix], index, options)
+      deletions << ['-', key, item]
+    end
+
+    def append_differences(difference)
+      differences.concat(difference)
+    end
+
+    def changes
+      # this algorithm only allows there to be additions or deletions
+      # deletions are reverse so they don't change the index of earlier items
+      differences + additions + deletions.reverse
+    end
+  end
+end

data/lib/hashdiff/version.rb

@@ -1,3 +1,3 @@
 module HashDiff
-  VERSION = '0.3.5'
+  VERSION = '0.3.7'
 end

data/spec/hashdiff/diff_array_spec.rb

@@ -5,7 +5,7 @@ describe HashDiff do
     a = [1, 2, 3]
     b = [1, 2, 3]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = HashDiff.diff_array_lcs(a, b)
     diff.should == []
   end
 
@@ -13,7 +13,7 @@ describe HashDiff do
     a = [1, 2, 3]
     b = [1, 8, 7]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = HashDiff.diff_array_lcs(a, b)
     diff.should == [['-', 2, 3], ['-', 1, 2], ['+', 1, 8], ['+', 2, 7]]
   end
 
@@ -21,7 +21,7 @@ describe HashDiff do
     a = [1, 2]
     b = []
 
-    diff = HashDiff.diff_array(a, b)
+    diff = HashDiff.diff_array_lcs(a, b)
     diff.should == [['-', 1, 2], ['-', 0, 1]]
   end
 
@@ -29,7 +29,7 @@ describe HashDiff do
     a = []
     b = [1, 2]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = HashDiff.diff_array_lcs(a, b)
     diff.should == [['+', 0, 1], ['+', 1, 2]]
   end
 
@@ -37,7 +37,7 @@ describe HashDiff do
     a = [1, 3, 5, 7]
     b = [2, 3, 7, 5]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = HashDiff.diff_array_lcs(a, b)
     diff.should == [['-', 0, 1], ['+', 0, 2], ['+', 2, 7], ['-', 4, 7]]
   end
 
@@ -45,14 +45,14 @@ describe HashDiff do
     a = [1, 3, 4, 7]
     b = [2, 3, 7, 5]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = HashDiff.diff_array_lcs(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 = HashDiff.diff_array_lcs(a, b)
     diff.should == [['+', 0, 1], ['-', 2, 3]]
   end
 

data/spec/hashdiff/diff_spec.rb

@@ -310,4 +310,30 @@ describe HashDiff do
       diff.should == [['-', [time], 'foo'], ['+', [0], 'bar']]
     end
   end
+
+  context 'when :use_lcs is false' do
+    it 'should show items in an array as changed' do
+      x = [:a, :b]
+      y = [:c, :d]
+      diff = HashDiff.diff(x, y, :use_lcs => false)
+
+      diff.should == [['~', '[0]', :a, :c], ['~', '[1]', :b, :d]]
+    end
+
+    it 'should show additions to arrays' do
+      x = { :a => [0] }
+      y = { :a => [0, 1] }
+      diff = HashDiff.diff(x, y, :use_lcs => false)
+
+      diff.should == [['+', 'a[1]', 1]]
+    end
+
+    it 'shows changes to nested arrays' do
+      x = { :a => [[0, 1]] }
+      y = { :a => [[1, 2]] }
+      diff = HashDiff.diff(x, y, :use_lcs => false)
+
+      diff.should == [['~', 'a[0][0]', 0, 1], ['~', 'a[0][1]', 1, 2]]
+    end
+  end
 end

data/spec/hashdiff/linear_compare_array_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe HashDiff::LinearCompareArray do
+  it "should find no differences between two empty arrays" do
+    difference = described_class.call([], [])
+    difference.should == []
+  end
+
+  it "should find added items when the old array is empty" do
+    difference = described_class.call([], [:a, :b])
+    difference.should == [['+', '[0]', :a], ['+', '[1]', :b]]
+  end
+
+  it "should find removed items when the new array is empty" do
+    difference = described_class.call([:a, :b], [])
+    difference.should == [['-', '[1]', :b], ['-', '[0]', :a]]
+  end
+
+  it "should find no differences between identical arrays" do
+    difference = described_class.call([:a, :b], [:a, :b])
+    difference.should == []
+  end
+
+  it "should find added items in an array" do
+    difference = described_class.call([:a, :d], [:a, :b, :c, :d])
+    difference.should == [['+', '[1]', :b], ['+', '[2]', :c]]
+  end
+
+  it "should find removed items in an array" do
+    difference = described_class.call([:a, :b, :c, :d, :e, :f], [:a, :d, :f])
+    difference.should == [['-', '[4]', :e], ['-', '[2]', :c], ['-', '[1]', :b]]
+  end
+
+  it "should show additions and deletions as changed items" do
+    difference = described_class.call([:a, :b, :c], [:c, :b, :a])
+    difference.should == [['~', '[0]', :a, :c], ['~', '[2]', :c, :a]]
+  end
+
+  it "should show changed items in a hash" do
+    difference = described_class.call([{ :a => :b }], [{ :a => :c }])
+    difference.should == [['~', '[0].a', :b, :c]]
+  end
+
+  it "should show changed items and added items" do
+    difference = described_class.call([{ :a => 1, :b => 2 }], [{ :a => 2, :b => 2 }, :item])
+    difference.should == [['~', '[0].a', 1, 2], ['+', '[1]', :item]]
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,3 @@
-require 'simplecov'
-SimpleCov.start
-if ENV['CI'] == 'true'
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-end
-
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rubygems'

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-06 00:00:00.000000000 Z
+date: 2017-10-08 00:00:00.000000000 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:
-    - - "~>"
+    - - ~>
       - !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'
   type: :development
   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'
   type: :development
   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. "
+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"
-- ".yardopts"
+- .gitignore
+- .rspec
+- .travis.yml
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
@@ -73,6 +73,7 @@ files:
 - lib/hashdiff.rb
 - lib/hashdiff/diff.rb
 - lib/hashdiff/lcs.rb
+- lib/hashdiff/linear_compare_array.rb
 - lib/hashdiff/patch.rb
 - lib/hashdiff/util.rb
 - lib/hashdiff/version.rb
@@ -80,6 +81,7 @@ files:
 - spec/hashdiff/diff_array_spec.rb
 - spec/hashdiff/diff_spec.rb
 - spec/hashdiff/lcs_spec.rb
+- spec/hashdiff/linear_compare_array_spec.rb
 - spec/hashdiff/patch_spec.rb
 - spec/hashdiff/util_spec.rb
 - spec/spec_helper.rb
@@ -93,19 +95,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: HashDiff is a diff lib to compute the smallest difference between two hashes.
 test_files: []
-has_rdoc: