hashdiff 0.3.7 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6af49f121e2b09e5dcdf8a649f6d48c25f63ae03
-  data.tar.gz: c6738c2b03d36f622ac1e0a3c228a863b691ac29
+SHA256:
+  metadata.gz: a9b50073f973250c144bb05272510f462dda18a7f5c9a8719156065773fdcaaa
+  data.tar.gz: 903439ed3ea22994d072201509506232fb77482506494bbb8c8419dc9fb8d546
 SHA512:
-  metadata.gz: 8dfda8cd1b17af2c64ea4626570e7d858b76a5ed918df4b6a5703c63e0ae43c371cbe5e3573b4382aa1491915f48335e62d3b4300f3c678660f329f39e8d9b62
-  data.tar.gz: 71ab91ba878e19c436dbad30cc08c85645aadf6aabeed889dc8e3661102d2ddf5a98b12c7a6a8b1007a5115f64e082829f88d99abe11ad87f2a69cf504f28885
+  metadata.gz: e1c00d4710a67688a35197197da93ac3bfabca5f5a51edc152bfbd341a16548e762ddf2290364b7fc3a20e99cdb6d8d909ff84e766468fe623eb3977afd6d90f
+  data.tar.gz: 2d860929e99458cd89ee60ce877a87557d6bb9d52dcd25e0989f1a0a7b372d026bb646ee2b19498f6637a485f15fcd1e68cf1e1c0dbe666ad5af1792d60a893a

data/.rubocop.yml

@@ -0,0 +1,32 @@
+require: rubocop-rspec
+AllCops:
+  TargetRubyVersion: 2.0 # always the lowest version we support
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/LineLength:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+Style/NumericPredicate:
+  Enabled: false
+Style/RedundantFreeze:
+  Enabled: false
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/DescribeClass:
+  Enabled: false

data/.travis.yml

@@ -1,13 +1,11 @@
 sudo: false
 language: ruby
+cache: bundler
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.10
   - 2.2.8
   - 2.3.4
   - 2.4.2
-script: "bundle exec rake spec"
-
-before_install:
-  - gem install bundler
+  - 2.5.3
+  - 2.6.0

data/Gemfile

@@ -1,4 +1,6 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
 gemspec
 
 group :test do

data/README.md

@@ -1,14 +1,17 @@
-# HashDiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.png)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.png)](http://badge.fury.io/rb/hashdiff)
+# Hashdiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.svg)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.svg)](http://badge.fury.io/rb/hashdiff)
 
-HashDiff is a ruby library to compute the smallest difference between two hashes.
+Hashdiff is a ruby library to compute the smallest difference between two hashes.
 
 It also supports comparing two arrays.
 
-HashDiff does not monkey-patch any existing class. All features are contained inside the `HashDiff` module.
+Hashdiff does not monkey-patch any existing class. All features are contained inside the `Hashdiff` module.
 
 **Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
 
-## Why HashDiff?
+
+__WARNING__: Don't use the library for comparing large arrays, say ~10K (see #49).
+
+## Why Hashdiff?
 
 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?
 
@@ -18,7 +21,7 @@ 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 using 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]]`.
@@ -29,7 +32,7 @@ HashDiff answers the question above using an opinionated approach:
 
 To use the gem, add the following to your Gemfile:
 
-```ruby
+```Ruby
 gem 'hashdiff'
 ```
 
@@ -43,7 +46,7 @@ Two simple hashes:
 a = {a:3, b:2}
 b = {}
 
-diff = HashDiff.diff(a, b)
+diff = Hashdiff.diff(a, b)
 diff.should == [['-', 'a', 3], ['-', 'b', 2]]
 ```
 
@@ -53,7 +56,7 @@ More complex hashes:
 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 = Hashdiff.diff(a, b)
 diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
 ```
 
@@ -63,7 +66,7 @@ Arrays in hashes:
 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)
+diff = Hashdiff.best_diff(a, b)
 diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
 ```
 
@@ -75,8 +78,8 @@ patch example:
 a = {'a' => 3}
 b = {'a' => {'a1' => 1, 'a2' => 2}}
 
-diff = HashDiff.diff(a, b)
-HashDiff.patch!(a, diff).should == b
+diff = Hashdiff.diff(a, b)
+Hashdiff.patch!(a, diff).should == b
 ```
 
 unpatch example:
@@ -85,15 +88,15 @@ 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
+diff = Hashdiff.diff(a, b) # diff two array is OK
+Hashdiff.unpatch!(b, diff).should == a
 ```
 
 ### Options
 
 There are eight options available: `:delimiter`, `:similarity`,
-`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path`
-and `:use_lcs`
+`:strict`, `:indifferent`, `:numeric_tolerance`, `:strip`, `:case_insensitive`,
+`:array_path` and `:use_lcs`
 
 #### `:delimiter`
 
@@ -103,7 +106,7 @@ You can specify `:delimiter` to be something other than the default dot. For exa
 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, :delimiter => '\t')
+diff = Hashdiff.diff(a, b, delimiter: '\t')
 diff.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
 ```
 
@@ -113,7 +116,11 @@ In cases where you have similar hash objects in arrays, you can pass a custom va
 
 #### `:strict`
 
-The `:strict` option, which defaults to `true`, specifies whether numeric types are compared on type as well as value.  By default, a Fixnum will never be equal to a Float (e.g. 4 != 4.0).  Setting `:strict` to false makes the comparison looser (e.g. 4 == 4.0).
+The `:strict` option, which defaults to `true`, specifies whether numeric types are compared on type as well as value.  By default, an Integer will never be equal to a Float (e.g. 4 != 4.0).  Setting `:strict` to false makes the comparison looser (e.g. 4 == 4.0).
+
+#### `:indifferent`
+
+The `:indifferent` option, which defaults to `false`, specifies whether to treat hash keys indifferently.  Setting `:indifferent` to true has the effect of ignoring differences between symbol keys (ie. {a: 1} ~= {'a' => 1})
 
 #### `:numeric_tolerance`
 
@@ -123,7 +130,7 @@ The :numeric_tolerance option allows for a small numeric tolerance.
 a = {x:5, y:3.75, z:7}
 b = {x:6, y:3.76, z:7}
 
-diff = HashDiff.diff(a, b, :numeric_tolerance => 0.1)
+diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1)
 diff.should == [["~", "x", 5, 6]]
 ```
 
@@ -135,7 +142,7 @@ The :strip option strips all strings before comparing.
 a = {x:5, s:'foo '}
 b = {x:6, s:'foo'}
 
-diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip => true })
+diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1, strip: true)
 diff.should == [["~", "x", 5, 6]]
 ```
 
@@ -147,7 +154,7 @@ The :case_insensitive option makes string comparisons ignore case.
 a = {x:5, s:'FooBar'}
 b = {x:6, s:'foobar'}
 
-diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_insensitive => true })
+diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1, case_insensitive: true)
 diff.should == [["~", "x", 5, 6]]
 ```
 
@@ -161,7 +168,7 @@ is useful for `patch!` when used on hashes without string keys.
 a = {x:5}
 b = {'x'=>6}
 
-diff = HashDiff.diff(a, b, :array_path => true)
+diff = Hashdiff.diff(a, b, array_path: true)
 diff.should == [['-', [:x], 5], ['+', ['x'], 6]]
 ```
 
@@ -170,7 +177,7 @@ For cases where there are arrays in paths their index will be added to the path.
 a = {x:[0,1]}
 b = {x:[0,2]}
 
-diff = HashDiff.diff(a, b, :array_path => true)
+diff = Hashdiff.diff(a, b, array_path: true)
 diff.should == [["-", [:x, 1], 1], ["+", [:x, 1], 2]]
 ```
 
@@ -180,8 +187,8 @@ This shouldn't cause problems if you are comparing an array with a hash:
 a = {x:{0=>1}}
 b = {x:[1]}
 
-diff = HashDiff.diff(a, b, :array_path => true)
-diff.should == [["~", [:a], [1], {0=>1}]]
+diff = Hashdiff.diff(a, b, array_path: true)
+diff.should == [["~", [:x], {0=>1}, [1]]]
 ```
 
 #### `:use_lcs`
@@ -202,7 +209,7 @@ Note, currently the :similarity option has no effect when :use_lcs is false.
 a = {x: [0, 1, 2]}
 b = {x: [0, 2, 2, 3]}
 
-diff = HashDiff.diff(a, b, :use_lcs => false)
+diff = Hashdiff.diff(a, b, use_lcs: false)
 diff.should == [["~", "x[1]", 1, 2], ["+", "x[3]", 3]]
 ```
 
@@ -214,7 +221,7 @@ It's possible to specify how the values of a key should be compared.
 a = {a:'car', b:'boat', c:'plane'}
 b = {a:'bus', b:'truck', c:' plan'}
 
-diff = HashDiff.diff(a, b) do |path, obj1, obj2|
+diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
   case path
   when  /a|b|c/
     obj1.length == obj2.length
@@ -230,7 +237,7 @@ The yielded params of the comparison block is `|path, obj1, obj2|`, in which pat
 a = {a:'car', b:['boat', 'plane'] }
 b = {a:'bus', b:['truck', ' plan'] }
 
-diff = HashDiff.diff(a, b) do |path, obj1, obj2|
+diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
   case path
   when 'b[*]'
     obj1.length == obj2.length
@@ -252,14 +259,18 @@ An order difference alone between two arrays can create too many diffs to be use
 a = {a:'car', b:['boat', 'plane'] }
 b = {a:'car', b:['plane', 'boat'] }
 
-HashDiff.diff(a, b) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
+Hashdiff.diff(a, b).should == [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
 
 b[:b].sort!
 
-HashDiff.diff(a, b) => []
+Hashdiff.diff(a, b).should == []
 ```
 
-## License
+## Maintainers
 
-HashDiff is distributed under the MIT-LICENSE.
+- Krzysztof Rybka ([@krzysiek1507](https://github.com/krzysiek1507))
+- Fengyun Liu ([@liufengyun](https://github.com/liufengyun))
+
+## License
 
+Hashdiff is distributed under the MIT-LICENSE.

data/Rakefile

@@ -1,13 +1,18 @@
-$:.push File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'rubocop/rake_task'
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 
-task :default => :spec
+RuboCop::RakeTask.new
+
+task default: %w[spec rubocop]
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = "./spec/**/*_spec.rb"
+  spec.pattern = './spec/**/*_spec.rb'
 end
-

data/changelog.md

@@ -1,5 +1,34 @@
 # Change Log
 
+## v1.0.1 2020-02-25
+
+* Add indifferent option
+
+## v1.0.0 2019-06-06
+
+* Fix typo in readme (#72 @koic)
+* Fix Rubocop offence (#73 @koic)
+* Bumps version to v1.0.0 (#74 @jfelchner)
+
+## v1.0.0.beta1 2019-06-06
+
+* fix warnings in ci (#69 @y-yagi)
+* drop warnings of the constant change (#70 @jfelchner)
+
+## v0.4.0 2019-05-28
+
+* refactoring (#56 #57 #59 #61 krzysiek1507)
+* fix typo in README (#64 @pboling)
+* change HashDiff to Hashdiff (#65 @jfelchner)
+
+## v0.3.9 2019-04-22
+
+* Performance tweak (thanks @krzysiek1507: #51 #52 #53)
+
+## v0.3.8 2018-12-30
+
+* Add Rubocop and drops Ruby 1.9 support #47
+
 ## v0.3.7 2017-10-08
 
 * remove 1.8.7 support from gemspec #39
@@ -14,7 +43,7 @@
 
 ## v0.3.4 2017-05-01
 
-* performance improvement of HashDiff#similar? #31
+* performance improvement of `#similar?` #31
 
 ## v0.3.2 2016-12-27
 
@@ -56,7 +85,7 @@
 ## v0.0.5 2012-7-1
 
 * fix a bug in judging whehter two objects are similiar.
-* add more spec test for HashDiff.best_diff
+* add more spec test for `.best_diff`
 
 ## v0.0.4 2012-6-24
 
@@ -69,4 +98,3 @@ For example, `diff({a:2, c:[4, 5]}, {a:2}) will generate following output:
 instead of following:
 
     [['-', 'c[0]', 4], ['-', 'c[1]', 5], ['-', 'c', []]]
-

data/hashdiff.gemspec

@@ -1,25 +1,39 @@
-$LOAD_PATH << File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path('lib', __dir__)
 require 'hashdiff/version'
 
 Gem::Specification.new do |s|
-  s.name        = %q{hashdiff}
-  s.version     = HashDiff::VERSION
+  s.name        = 'hashdiff'
+  s.version     = Hashdiff::VERSION
   s.license     = 'MIT'
-  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.summary     = ' Hashdiff is a diff lib to compute the smallest difference between two hashes. '
+  s.description = ' 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.9.3")
+  s.required_ruby_version = Gem::Requirement.new('>= 2.0.0')
+
+  s.authors = ['Liu Fengyun']
+  s.email   = ['liufengyunchina@gmail.com']
 
-  s.authors = ["Liu Fengyun"]
-  s.email   = ["liufengyunchina@gmail.com"]
+  s.homepage = 'https://github.com/liufengyun/hashdiff'
 
-  s.homepage = "https://github.com/liufengyun/hashdiff"
+  s.add_development_dependency('bluecloth')
+  s.add_development_dependency('rspec', '~> 2.0')
+  s.add_development_dependency('rubocop', '~> 0.49.1') # last version that works with ruby 2.0
+  s.add_development_dependency('rubocop-rspec')
+  s.add_development_dependency('yard')
 
-  s.add_development_dependency("rspec",    "~> 2.0")
-  s.add_development_dependency("yard")
-  s.add_development_dependency("bluecloth")
+  if s.respond_to?(:metadata)
+    s.metadata = {
+      'bug_tracker_uri' => 'https://github.com/liufengyun/hashdiff/issues',
+      'changelog_uri' => 'https://github.com/liufengyun/hashdiff/blob/master/changelog.md',
+      'documentation_uri' => 'https://www.rubydoc.info/gems/hashdiff',
+      'homepage_uri' => 'https://github.com/liufengyun/hashdiff',
+      'source_code_uri' => 'https://github.com/liufengyun/hashdiff'
+    }
+  end
 end

data/lib/hashdiff.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require 'hashdiff/util'
+require 'hashdiff/compare_hashes'
 require 'hashdiff/lcs'
+require 'hashdiff/lcs_compare_arrays'
 require 'hashdiff/linear_compare_array'
 require 'hashdiff/diff'
 require 'hashdiff/patch'

data/lib/hashdiff/compare_hashes.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare hashes
+  class CompareHashes
+    class << self
+      def call(obj1, obj2, opts = {})
+        return [] if obj1.empty? && obj2.empty?
+
+        obj1_keys = obj1.keys
+        obj2_keys = obj2.keys
+        obj1_lookup = {}
+        obj2_lookup = {}
+
+        if opts[:indifferent]
+          obj1_lookup = obj1_keys.each_with_object({}) { |k, h| h[k.to_s] = k }
+          obj2_lookup = obj2_keys.each_with_object({}) { |k, h| h[k.to_s] = k }
+          obj1_keys = obj1_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+          obj2_keys = obj2_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+        end
+
+        added_keys = (obj2_keys - obj1_keys).sort_by(&:to_s)
+        common_keys = (obj1_keys & obj2_keys).sort_by(&:to_s)
+        deleted_keys = (obj1_keys - obj2_keys).sort_by(&:to_s)
+
+        result = []
+
+        # add deleted properties
+        deleted_keys.each do |k|
+          k = opts[:indifferent] ? obj1_lookup[k] : k
+          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, obj1[k], nil)
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['-', change_key, obj1[k]]
+          end
+        end
+
+        # recursive comparison for common keys
+        common_keys.each do |k|
+          prefix = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+
+          k1 = opts[:indifferent] ? obj1_lookup[k] : k
+          k2 = opts[:indifferent] ? obj2_lookup[k] : k
+          result.concat(Hashdiff.diff(obj1[k1], obj2[k2], opts.merge(prefix: prefix)))
+        end
+
+        # added properties
+        added_keys.each do |k|
+          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+
+          k = opts[:indifferent] ? obj2_lookup[k] : k
+          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, nil, obj2[k])
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['+', change_key, obj2[k]]
+          end
+        end
+
+        result
+      end
+    end
+  end
+end