hashdiff 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56a70b8fb995b7d778a1840400c42303c34648a9205055b11157a5b69208afa1
-  data.tar.gz: 410e1bea7bc27e43f4580c42ff17054e1ce57dc3c3f486fe570269e366c7ecb4
+  metadata.gz: 113e55eeac757365f792e7e2554a8fbb5f16c06cfcf83d4dcf7db268637ef47e
+  data.tar.gz: ae222f4980bff17fa8f9fecef25cb1fa54db61503c075cc49b3ef755927ec5f1
 SHA512:
-  metadata.gz: 30e90e14ee676c7b035a20d01f5f8cf5dfcdae7319f652bd828c6fcc8d66a4e6b0cb8fd046937ce09a38aac8e7c3eba92dfc60b8ea2e09674eb9c8ea35256e9a
-  data.tar.gz: 146cc4564d22ee6c6ef47b09032e4e171cd2682ecd941e798bd729bea7d3e8a10974356e39500886bd6ec4d0d3d6c109d2e6556bbe47abc7b79a9c9d45db66e4
+  metadata.gz: 7476c18bd05f2e5c57da5b15d9bd938bbfd5fa330825b21be8d867fded3b404d6ae3405acca5f235397f816b866aede13425e0ab314ee71497bfa54010ab6e82
+  data.tar.gz: ce5d8d3ea4e8bca768688aa782e21bab01ae4a5ae8cd0b8f5b11927abc5c5163da3dc2a1135a069ad139998654471d11359b48e2a2eeb1d87f17bc461813745f

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: ci
+
+on:
+  - pull_request
+  - push
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.7
+          - 3.0
+          - 3.1
+          - 3.2
+          - 3.3
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install dependencies
+        run: bundle install --jobs $(nproc) --retry 3
+      - name: Run rake
+        run: bundle exec rake

data/.rubocop.yml

@@ -9,7 +9,7 @@ Metrics/MethodLength:
   Enabled: false
 Metrics/AbcSize:
   Enabled: false
-Metrics/LineLength:
+Layout/LineLength:
   Enabled: false
 Metrics/ClassLength:
   Enabled: false
@@ -36,5 +36,7 @@ RSpec/ExampleLength:
   Enabled: false
 RSpec/DescribeClass:
   Enabled: false
-RSpec/FilePath:
+RSpec/SpecFilePathFormat:
+  Enabled: false
+RSpec/NoExpectationExample:
   Enabled: false

data/README.md

@@ -1,4 +1,4 @@
-# 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 [![Build Status](https://github.com/liufengyun/hashdiff/workflows/ci/badge.svg)](https://github.com/liufengyun/hashdiff/actions?query=workflow%3Aci) [![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.
 
@@ -119,23 +119,26 @@ The `:strict` option, which defaults to `true`, specifies whether numeric types
 
 #### `:ignore_keys`
 
-The `:ignore_keys` option allows you to specify one or more keys to ignore, which defaults to `[]` (none). Ignored keys are ignored at all levels. For example:
+The `:ignore_keys` option allows you to specify one or more keys to ignore, which defaults to `[]` (none). Ignored keys are ignored at all levels in both hashes. For example:
 
 ```ruby
-a = { a: 1, b: { d: 2, a: 3 }, c: 4 }
-b = { a: 2, b: { d: 2, a: 7 }, c: 5 }
-diff = Hashdiff.diff(a, b, ignore_keys: :a)
-diff.should == [['~', 'c', 4, 5]]
+a = { a: 4, g: 0, b: { a: 5, c: 6, e: 1 }       }
+b = {             b: { a: 7, c: 3, f: 1 }, d: 8 }
+diff = Hashdiff.diff(a, b, ignore_keys: %i[a f])
+diff.should == [['-', 'g', 0], ['-', 'b.e', 1], ['~', 'b.c', 6, 3], ['+', 'd', 8]]
 ```
-If you wish instead to ignore keys at a particlar level you should 
-use a [custom comparison method](https://github.com/liufengyun/hashdiff#specifying-a-custom-comparison-method) instead. For example:
+If you wish instead to ignore keys at a particlar level you should
+use a [custom comparison method](https://github.com/liufengyun/hashdiff#specifying-a-custom-comparison-method) instead. For example to diff only at the 2nd level of both hashes:
 
 ```ruby
-a = { a: 1, b: { d: 2, a: 3 }, c: 4 }
-b = { a: 2, b: { d: 2, a: 7 }, c: 5 }
-diff = Hashdiff.diff(a, b) { |path, _e, _a| true if path == 'b.a' } # note '.' is the default delimiter
-diff.should == [['~', 'a', 1, 2], ['~', 'c', 4, 5]]
-``` 
+a = { a: 4, g: 0, b: { a: 5, c: 6, e: 1 }       }
+b = {             b: { a: 7, c: 3, f: 1 }, d: 8 }
+diff = Hashdiff.diff(a, b) do |path, _e, _a|
+  arr = path.split('.')
+  true if %w[a f].include?(arr.last) && arr.size == 2 # note '.' is the default delimiter
+end
+diff.should == [['-', 'a', 4], ['-', 'g', 0], ['-', 'b.e', 1], ['~', 'b.c', 6, 3], ['+', 'd', 8]]
+```
 
 #### `:indifferent`
 

data/changelog.md

@@ -1,6 +1,17 @@
 # Change Log
 
-## v1.1.0 2020-02-25
+## v1.1.2 2024-11-12
+
+* Fix bundler cache #96 (@olleolleolle)
+* Quote the '3.0' in YAML #95 (@olleolleolle)
+* Fix version in source code #97 (@liufengyun)
+
+## v1.1.1 2024-08-02
+
+* Fix bug in ignore_keys option #88 (@Matzfan)
+* Exclude spec files from gem package #94 (@amatsuda)
+
+## v1.1.0 2023-12-14
 
 * Add ignore_keys option (#86 @Matzfan)
 * Remove pinned version of rake < 11

data/hashdiff.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   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.files         = `git ls-files`.split("\n").grep_v(%r{^spec/})
   s.test_files    = `git ls-files -- Appraisals {spec}/*`.split("\n")
 
   s.require_paths = ['lib']

data/lib/hashdiff/compare_hashes.rb

@@ -26,7 +26,11 @@ module Hashdiff
 
         result = []
 
-        opts[:ignore_keys].each { |k| common_keys.delete k }
+        opts[:ignore_keys].each do |k|
+          added_keys.delete k
+          common_keys.delete k
+          deleted_keys.delete k
+        end
 
         # add deleted properties
         deleted_keys.each do |k|

data/lib/hashdiff/diff.rb

@@ -9,7 +9,7 @@ module Hashdiff
   # @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 Integer, Float, BigDecimal to each other
-  #   * :ignore_keys (Symbol, String or Array) [[]] a list of keys to ignore. No comparison is made for the specified key(s)
+  #   * :ignore_keys (Symbol, String or Array) [[]] a list of keys to ignore. No comparison is made for the specified key(s) in either hash
   #   * :indifferent (Boolean) [false] whether to treat hash keys indifferently.  Set to true to ignore differences between symbol keys (ie. {a: 1} ~= {'a' => 1})
   #   * :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.
@@ -54,7 +54,7 @@ module Hashdiff
   # @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 Integer, Float, BigDecimal to each other
-  #   * :ignore_keys (Symbol, String or Array) [[]] a list of keys to ignore. No comparison is made for the specified key(s)
+  #   * :ignore_keys (Symbol, String or Array) [[]] a list of keys to ignore. No comparison is made for the specified key(s) in either hash
   #   * :indifferent (Boolean) [false] whether to treat hash keys indifferently.  Set to true to ignore differences between symbol keys (ie. {a: 1} ~= {'a' => 1})
   #   * :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
@@ -93,7 +93,7 @@ module Hashdiff
 
     opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
 
-    opts[:ignore_keys] = [*opts[:ignore_keys]] # splat covers single sym/string case
+    opts[:ignore_keys] = [*opts[:ignore_keys]]
 
     opts[:comparison] = block if block_given?
 

data/lib/hashdiff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashdiff
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.1.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Liu Fengyun
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-14 00:00:00.000000000 Z
+date: 2024-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bluecloth
@@ -88,6 +88,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -108,15 +109,6 @@ files:
 - lib/hashdiff/patch.rb
 - lib/hashdiff/util.rb
 - lib/hashdiff/version.rb
-- spec/hashdiff/best_diff_spec.rb
-- 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/readme_spec.rb
-- spec/hashdiff/util_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/liufengyun/hashdiff
 licenses:
 - MIT
@@ -126,7 +118,7 @@ metadata:
   documentation_uri: https://www.rubydoc.info/gems/hashdiff
   homepage_uri: https://github.com/liufengyun/hashdiff
   source_code_uri: https://github.com/liufengyun/hashdiff
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -141,8 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.3.5
+signing_key: 
 specification_version: 4
 summary: Hashdiff is a diff lib to compute the smallest difference between two hashes.
 test_files: []

data/spec/hashdiff/best_diff_spec.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to best diff' do
-    a = { 'x' => [{ 'a' => 1, 'c' => 3, 'e' => 5 }, { 'y' => 3 }] }
-    b = { 'x' => [{ 'a' => 1, 'b' => 2, 'e' => 5 }] }
-
-    diff = described_class.best_diff(a, b)
-    diff.should == [['-', 'x[0].c', 3], ['+', 'x[0].b', 2], ['-', 'x[1]', { 'y' => 3 }]]
-  end
-
-  it 'uses custom delimiter when provided' do
-    a = { 'x' => [{ 'a' => 1, 'c' => 3, 'e' => 5 }, { 'y' => 3 }] }
-    b = { 'x' => [{ 'a' => 1, 'b' => 2, 'e' => 5 }] }
-
-    diff = described_class.best_diff(a, b, delimiter: "\t")
-    diff.should == [['-', "x[0]\tc", 3], ['+', "x[0]\tb", 2], ['-', 'x[1]', { 'y' => 3 }]]
-  end
-
-  it 'uses custom comparison when provided' do
-    a = { 'x' => [{ 'a' => 'foo', 'c' => 'goat', 'e' => 'snake' }, { 'y' => 'baz' }] }
-    b = { 'x' => [{ 'a' => 'bar', 'b' => 'cow', 'e' => 'puppy' }] }
-
-    diff = described_class.best_diff(a, b) do |path, obj1, obj2|
-      case path
-      when /^x\[.\]\..$/
-        obj1.length == obj2.length if obj1 && obj2
-      end
-    end
-
-    diff.should == [['-', 'x[0].c', 'goat'], ['+', 'x[0].b', 'cow'], ['-', 'x[1]', { 'y' => 'baz' }]]
-  end
-
-  it 'is able to best diff array in hash' do
-    a = { 'menu' => {
-      'id' => 'file',
-      'value' => 'File',
-      'popup' => {
-        'menuitem' => [
-          { 'value' => 'New', 'onclick' => 'CreateNewDoc()' },
-          { 'value' => 'Close', 'onclick' => 'CloseDoc()' }
-        ]
-      }
-    } }
-
-    b = { 'menu' => {
-      'id' => 'file 2',
-      'value' => 'File',
-      'popup' => {
-        'menuitem' => [
-          { 'value' => 'New1', 'onclick' => 'CreateNewDoc()' },
-          { 'value' => 'Open', 'onclick' => 'OpenDoc()' },
-          { 'value' => 'Close', 'onclick' => 'CloseDoc()' }
-        ]
-      }
-    } }
-
-    diff = described_class.best_diff(a, b)
-    diff.should == [
-      ['~', 'menu.id', 'file', 'file 2'],
-      ['~', 'menu.popup.menuitem[0].value', 'New', 'New1'],
-      ['+', 'menu.popup.menuitem[1]', { 'value' => 'Open', 'onclick' => 'OpenDoc()' }]
-    ]
-  end
-
-  it 'is able to have an array_path specified' do
-    a = { 'x' => [{ 'a' => 1, 'c' => 3, 'e' => 5 }, { 'y' => 3 }] }
-    b = { 'x' => [{ 'a' => 1, 'b' => 2, 'e' => 5 }] }
-
-    diff = described_class.best_diff(a, b, array_path: true)
-    diff.should == [['-', ['x', 0, 'c'], 3], ['+', ['x', 0, 'b'], 2], ['-', ['x', 1], { 'y' => 3 }]]
-  end
-end

data/spec/hashdiff/diff_array_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to diff two equal array' do
-    a = [1, 2, 3]
-    b = [1, 2, 3]
-
-    diff = described_class.diff_array_lcs(a, b)
-    diff.should == []
-  end
-
-  it 'is able to diff two arrays with one element in common' do
-    a = [1, 2, 3]
-    b = [1, 8, 7]
-
-    diff = described_class.diff_array_lcs(a, b)
-    diff.should == [['-', 2, 3], ['-', 1, 2], ['+', 1, 8], ['+', 2, 7]]
-  end
-
-  it 'is able to diff two arrays with nothing in common' do
-    a = [1, 2]
-    b = []
-
-    diff = described_class.diff_array_lcs(a, b)
-    diff.should == [['-', 1, 2], ['-', 0, 1]]
-  end
-
-  it 'is able to diff an empty array with an non-empty array' do
-    a = []
-    b = [1, 2]
-
-    diff = described_class.diff_array_lcs(a, b)
-    diff.should == [['+', 0, 1], ['+', 1, 2]]
-  end
-
-  it 'is able to diff two arrays with two elements in common' do
-    a = [1, 3, 5, 7]
-    b = [2, 3, 7, 5]
-
-    diff = described_class.diff_array_lcs(a, b)
-    diff.should == [['-', 0, 1], ['+', 0, 2], ['+', 2, 7], ['-', 4, 7]]
-  end
-
-  it 'is able to test two arrays with two common elements in different order' do
-    a = [1, 3, 4, 7]
-    b = [2, 3, 7, 5]
-
-    diff = described_class.diff_array_lcs(a, b)
-    diff.should == [['-', 0, 1], ['+', 0, 2], ['-', 2, 4], ['+', 3, 5]]
-  end
-
-  it 'is 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 = described_class.diff_array_lcs(a, b)
-    diff.should == [['+', 0, 1], ['-', 2, 3]]
-  end
-end

data/spec/hashdiff/diff_spec.rb

@@ -1,375 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to diff two empty hashes' do
-    diff = described_class.diff({}, {})
-    diff.should == []
-  end
-
-  it 'is able to diff an hash with an empty hash' do
-    a = { 'a' => 3, 'b' => 2 }
-    b = {}
-
-    diff = described_class.diff(a, b)
-    expect(diff).to eq([['-', 'a', 3], ['-', 'b', 2]])
-
-    diff = described_class.diff(b, a)
-    diff.should == [['+', 'a', 3], ['+', 'b', 2]]
-  end
-
-  it 'is able to diff two equal hashes' do
-    diff = described_class.diff({ 'a' => 2, 'b' => 2 }, 'a' => 2, 'b' => 2)
-    diff.should == []
-  end
-
-  it 'is able to diff two equal hashes with mixed key types' do
-    a = { 'a' => 1, :b => 1 }
-    diff = described_class.diff(a, a)
-    diff.should == []
-  end
-
-  it 'is able to diff if mixed key types are removed' do
-    a = { 'a' => 1, :b => 1 }
-    b = {}
-    diff = described_class.diff(a, b)
-    diff.should == [['-', 'a', 1], ['-', 'b', 1]]
-  end
-
-  it 'is able to diff if mixed key types are added' do
-    a = { 'a' => 1, :b => 1 }
-    b = {}
-    diff = described_class.diff(b, a)
-    diff.should == [['+', 'a', 1], ['+', 'b', 1]]
-  end
-
-  it 'is able to diff two hashes with equivalent numerics, when strict is false' do
-    diff = described_class.diff({ 'a' => 2.0, 'b' => 2 }, { 'a' => 2, 'b' => 2.0 }, strict: false)
-    diff.should == []
-  end
-
-  context 'with the ignore_keys option' do
-    a = { a: 1, b: { d: 2, a: 3 }, c: 4 }
-    b = { a: 2, b: { d: 2, a: 7 }, c: 5 }
-
-    it 'ignores a single key' do
-      diff = described_class.diff(a, b, ignore_keys: :a)
-      diff.should == [['~', 'c', 4, 5]]
-    end
-
-    it 'ignores an array of keys' do
-      diff = described_class.diff(a, b, ignore_keys: %i[a c])
-      diff.should == []
-    end
-  end
-
-  it 'ignores string vs symbol differences, when indifferent is true' do
-    diff = described_class.diff({ 'a' => 2, :b => 2 }, { :a => 2, 'b' => 2, :c => 3 }, indifferent: true)
-    diff.should == [['+', 'c', 3]]
-  end
-
-  it 'is able to diff changes in hash value' do
-    diff = described_class.diff({ 'a' => 2, 'b' => 3, 'c' => ' hello' }, 'a' => 2, 'b' => 4, 'c' => 'hello')
-    diff.should == [['~', 'b', 3, 4], ['~', 'c', ' hello', 'hello']]
-  end
-
-  it 'is able to diff changes in hash value which is array' do
-    diff = described_class.diff({ 'a' => 2, 'b' => [1, 2, 3] }, 'a' => 2, 'b' => [1, 3, 4])
-    diff.should == [['-', 'b[1]', 2], ['+', 'b[2]', 4]]
-  end
-
-  it 'is able to diff changes in hash value which is hash' do
-    diff = described_class.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 'is able to best diff similar objects in array' do
-    diff = described_class.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 'is 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 = described_class.diff(a, b)
-    expect(diff).to eq([['+', 'g', 300]])
-
-    diff = described_class.diff(b, a)
-    diff.should == [['-', 'g', 300]]
-  end
-
-  it 'is able to diff value type changes' do
-    a = { 'a' => 3 }
-    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
-
-    diff = described_class.diff(a, b)
-    expect(diff).to eq([['~', 'a', 3, { 'a1' => 1, 'a2' => 2 }]])
-
-    diff = described_class.diff(b, a)
-    diff.should == [['~', 'a', { 'a1' => 1, 'a2' => 2 }, 3]]
-  end
-
-  it 'is able to diff value changes: array <=> []' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => [] }
-
-    diff = described_class.diff(a, b)
-    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1]]
-  end
-
-  it 'is able to diff value changes: array <=> nil' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => nil }
-
-    diff = described_class.diff(a, b)
-    diff.should == [['~', 'b', [1, 2], nil]]
-  end
-
-  it 'is able to diff value chagnes: remove array completely' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1 }
-
-    diff = described_class.diff(a, b)
-    diff.should == [['-', 'b', [1, 2]]]
-  end
-
-  it 'is able to diff value changes: remove whole hash' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1 }
-
-    diff = described_class.diff(a, b)
-    diff.should == [['-', 'b', { 'b1' => 1, 'b2' => 2 }]]
-  end
-
-  it 'is able to diff value changes: hash <=> {}' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => {} }
-
-    diff = described_class.diff(a, b)
-    diff.should == [['-', 'b.b1', 1], ['-', 'b.b2', 2]]
-  end
-
-  it 'is able to diff value changes: hash <=> nil' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => nil }
-
-    diff = described_class.diff(a, b)
-    diff.should == [['~', 'b', { 'b1' => 1, 'b2' => 2 }, nil]]
-  end
-
-  it 'is 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 = described_class.diff(a, b)
-    diff.should == [['-', '[0].d', 4], ['+', '[0]', 1], ['-', '[2]', 3]]
-  end
-
-  it 'is 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 = described_class.diff(a, b)
-    diff.should == [['-', '[0].d', 4], ['-', '[1]', { 'x' => 5, 'y' => 6, 'z' => 3 }]]
-  end
-
-  it 'uses custom delimiter when provided' 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 = described_class.diff(a, b, similarity: 0.8, delimiter: "\t")
-    diff.should == [['-', "[0]\td", 4], ['-', '[1]', { 'x' => 5, 'y' => 6, 'z' => 3 }]]
-  end
-
-  context 'when :numeric_tolerance requested' do
-    it 'is able to diff changes in hash value' do
-      a = { 'a' => 0.558, 'b' => 0.0, 'c' => 0.65, 'd' => 'fin' }
-      b = { 'a' => 0.557, 'b' => 'hats', 'c' => 0.67, 'd' => 'fin' }
-
-      diff = described_class.diff(a, b, numeric_tolerance: 0.01)
-      expect(diff).to eq([['~', 'b', 0.0, 'hats'], ['~', 'c', 0.65, 0.67]])
-
-      diff = described_class.diff(b, a, numeric_tolerance: 0.01)
-      diff.should == [['~', 'b', 'hats', 0.0], ['~', 'c', 0.67, 0.65]]
-    end
-
-    it 'is able to diff changes in nested values' do
-      a = { 'a' => { 'x' => 0.4, 'y' => 0.338 }, 'b' => [13, 68.03] }
-      b = { 'a' => { 'x' => 0.6, 'y' => 0.341 }, 'b' => [14, 68.025] }
-
-      diff = described_class.diff(a, b, numeric_tolerance: 0.01)
-      expect(diff).to eq([['~', 'a.x', 0.4, 0.6], ['-', 'b[0]', 13], ['+', 'b[0]', 14]])
-
-      diff = described_class.diff(b, a, numeric_tolerance: 0.01)
-      diff.should == [['~', 'a.x', 0.6, 0.4], ['-', 'b[0]', 14], ['+', 'b[0]', 13]]
-    end
-  end
-
-  context 'when :strip requested' do
-    it 'strips strings before comparing' do
-      a = { 'a' => ' foo', 'b' => 'fizz buzz' }
-      b = { 'a' => 'foo', 'b' => 'fizzbuzz' }
-      diff = described_class.diff(a, b, strip: true)
-      diff.should == [['~', 'b', 'fizz buzz', 'fizzbuzz']]
-    end
-
-    it 'strips nested strings before comparing' do
-      a = { 'a' => { 'x' => ' foo' }, 'b' => ['fizz buzz', 'nerf'] }
-      b = { 'a' => { 'x' => 'foo' }, 'b' => %w[fizzbuzz nerf] }
-      diff = described_class.diff(a, b, strip: true)
-      diff.should == [['-', 'b[0]', 'fizz buzz'], ['+', 'b[0]', 'fizzbuzz']]
-    end
-  end
-
-  context 'when :case_insensitive requested' do
-    it 'strips strings before comparing' do
-      a = { 'a' => 'Foo', 'b' => 'fizz buzz' }
-      b = { 'a' => 'foo', 'b' => 'fizzBuzz' }
-      diff = described_class.diff(a, b, case_insensitive: true)
-      diff.should == [['~', 'b', 'fizz buzz', 'fizzBuzz']]
-    end
-
-    it 'ignores case on nested strings before comparing' do
-      a = { 'a' => { 'x' => 'Foo' }, 'b' => ['fizz buzz', 'nerf'] }
-      b = { 'a' => { 'x' => 'foo' }, 'b' => %w[fizzbuzz nerf] }
-      diff = described_class.diff(a, b, case_insensitive: true)
-      diff.should == [['-', 'b[0]', 'fizz buzz'], ['+', 'b[0]', 'fizzbuzz']]
-    end
-  end
-
-  context 'when both :strip and :numeric_tolerance requested' do
-    it 'applies filters to proper object types' do
-      a = { 'a' => ' foo', 'b' => 35, 'c' => 'bar', 'd' => 'baz' }
-      b = { 'a' => 'foo', 'b' => 35.005, 'c' => 'bar', 'd' => 18.5 }
-      diff = described_class.diff(a, b, strict: false, numeric_tolerance: 0.01, strip: true)
-      diff.should == [['~', 'd', 'baz', 18.5]]
-    end
-  end
-
-  context 'when both :strip and :case_insensitive requested' do
-    it 'applies both filters to strings' do
-      a = { 'a' => ' Foo', 'b' => 'fizz buzz' }
-      b = { 'a' => 'foo', 'b' => 'fizzBuzz' }
-      diff = described_class.diff(a, b, case_insensitive: true, strip: true)
-      diff.should == [['~', 'b', 'fizz buzz', 'fizzBuzz']]
-    end
-  end
-
-  context 'with custom comparison' do
-    let(:a) { { 'a' => 'car', 'b' => 'boat', 'c' => 'plane' } }
-    let(:b) { { 'a' => 'bus', 'b' => 'truck', 'c' => ' plan' } }
-
-    it 'compares using proc specified in block' do
-      diff = described_class.diff(a, b) do |prefix, obj1, obj2|
-        case prefix
-        when /a|b|c/
-          obj1.length == obj2.length
-        end
-      end
-      diff.should == [['~', 'b', 'boat', 'truck']]
-    end
-
-    it 'yields added keys' do
-      x = { 'a' => 'car', 'b' => 'boat' }
-      y = { 'a' => 'car' }
-
-      diff = described_class.diff(x, y) do |prefix, _obj1, _obj2|
-        case prefix
-        when /b/
-          true
-        end
-      end
-      diff.should == []
-    end
-
-    it 'compares with both proc and :strip when both provided' do
-      diff = described_class.diff(a, b, strip: true) do |prefix, obj1, obj2|
-        case prefix
-        when 'a'
-          obj1.length == obj2.length
-        end
-      end
-      diff.should == [['~', 'b', 'boat', 'truck'], ['~', 'c', 'plane', ' plan']]
-    end
-
-    it 'compares nested arrays using proc specified in block' do
-      a = { a: 'car', b: %w[boat plane] }
-      b = { a: 'bus', b: ['truck', ' plan'] }
-
-      diff = described_class.diff(a, b) do |path, obj1, obj2|
-        case path
-        when 'b[*]'
-          obj1.length == obj2.length
-        end
-      end
-
-      expect(diff).to eq [['~', 'a', 'car', 'bus'], ['~', 'b[1]', 'plane', ' plan'], ['-', 'b[0]', 'boat'], ['+', 'b[0]', 'truck']]
-    end
-  end
-
-  context 'when :array_path is true' do
-    it 'returns the diff path in an array rather than a string' do
-      x = { 'a' => 'foo' }
-      y = { 'a' => 'bar' }
-      diff = described_class.diff(x, y, array_path: true)
-
-      diff.should == [['~', ['a'], 'foo', 'bar']]
-    end
-
-    it 'shows array indexes in paths' do
-      x = { 'a' => [0, 1, 2] }
-      y = { 'a' => [0, 1, 2, 3] }
-
-      diff = described_class.diff(x, y, array_path: true)
-
-      diff.should == [['+', ['a', 3], 3]]
-    end
-
-    it 'shows differences with string and symbol keys' do
-      x = { 'a' => 'foo' }
-      y = { a: 'bar' }
-
-      diff = described_class.diff(x, y, array_path: true)
-      diff.should == [['-', ['a'], 'foo'], ['+', [:a], 'bar']]
-    end
-
-    it 'supports other key types' do
-      time = Time.now
-      x = { time => 'foo' }
-      y = { 0 => 'bar' }
-
-      diff = described_class.diff(x, y, array_path: true)
-      diff.should == [['-', [time], 'foo'], ['+', [0], 'bar']]
-    end
-  end
-
-  context 'when :use_lcs is false' do
-    it 'shows items in an array as changed' do
-      x = %i[a b]
-      y = %i[c d]
-      diff = described_class.diff(x, y, use_lcs: false)
-
-      diff.should == [['~', '[0]', :a, :c], ['~', '[1]', :b, :d]]
-    end
-
-    it 'shows additions to arrays' do
-      x = { a: [0] }
-      y = { a: [0, 1] }
-      diff = described_class.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 = described_class.diff(x, y, use_lcs: false)
-
-      diff.should == [['~', 'a[0][0]', 0, 1], ['~', 'a[0][1]', 1, 2]]
-    end
-  end
-end

data/spec/hashdiff/lcs_spec.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to find LCS between two equal array' do
-    a = [1, 2, 3]
-    b = [1, 2, 3]
-
-    lcs = described_class.lcs(a, b)
-    lcs.should == [[0, 0], [1, 1], [2, 2]]
-  end
-
-  it 'is able to find LCS between two close arrays' do
-    a = [1.05, 2, 3.25]
-    b = [1.06, 2, 3.24]
-
-    lcs = described_class.lcs(a, b, numeric_tolerance: 0.1)
-    lcs.should == [[0, 0], [1, 1], [2, 2]]
-  end
-
-  it 'strips strings when finding LCS if requested' do
-    a = %w[foo bar baz]
-    b = [' foo', 'bar', 'zab']
-
-    lcs = described_class.lcs(a, b, strip: true)
-    lcs.should == [[0, 0], [1, 1]]
-  end
-
-  it 'is able to find LCS with one common elements' do
-    a = [1, 2, 3]
-    b = [1, 8, 7]
-
-    lcs = described_class.lcs(a, b)
-    lcs.should == [[0, 0]]
-  end
-
-  it 'is able to find LCS with two common elements' do
-    a = [1, 3, 5, 7]
-    b = [2, 3, 7, 5]
-
-    lcs = described_class.lcs(a, b)
-    lcs.should == [[1, 1], [2, 3]]
-  end
-
-  it 'is able to find LCS with two close elements' do
-    a = [1, 3.05, 5, 7]
-    b = [2, 3.06, 7, 5]
-
-    lcs = described_class.lcs(a, b, numeric_tolerance: 0.1)
-    lcs.should == [[1, 1], [2, 3]]
-  end
-
-  it 'is able to find LCS with two common elements in different ordering' do
-    a = [1, 3, 4, 7]
-    b = [2, 3, 7, 5]
-
-    lcs = described_class.lcs(a, b)
-    lcs.should == [[1, 1], [3, 2]]
-  end
-
-  it 'is able to find LCS with a similarity value' do
-    a = [
-      { 'value' => 'New', 'onclick' => 'CreateNewDoc()' },
-      { 'value' => 'Close', 'onclick' => 'CloseDoc()' }
-    ]
-    b = [
-      { 'value' => 'New1', 'onclick' => 'CreateNewDoc()' },
-      { 'value' => 'Open', 'onclick' => 'OpenDoc()' },
-      { 'value' => 'Close', 'onclick' => 'CloseDoc()' }
-    ]
-
-    lcs = described_class.lcs(a, b, similarity: 0.5)
-    lcs.should == [[0, 0], [1, 2]]
-  end
-end

data/spec/hashdiff/linear_compare_array_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff::LinearCompareArray do
-  it 'finds no differences between two empty arrays' do
-    difference = described_class.call([], [])
-    difference.should == []
-  end
-
-  it 'finds added items when the old array is empty' do
-    difference = described_class.call([], %i[a b])
-    difference.should == [['+', '[0]', :a], ['+', '[1]', :b]]
-  end
-
-  it 'finds removed items when the new array is empty' do
-    difference = described_class.call(%i[a b], [])
-    difference.should == [['-', '[1]', :b], ['-', '[0]', :a]]
-  end
-
-  it 'finds no differences between identical arrays' do
-    difference = described_class.call(%i[a b], %i[a b])
-    difference.should == []
-  end
-
-  it 'finds added items in an array' do
-    difference = described_class.call(%i[a d], %i[a b c d])
-    difference.should == [['+', '[1]', :b], ['+', '[2]', :c]]
-  end
-
-  it 'finds removed items in an array' do
-    difference = described_class.call(%i[a b c d e f], %i[a d f])
-    difference.should == [['-', '[4]', :e], ['-', '[2]', :c], ['-', '[1]', :b]]
-  end
-
-  it 'shows additions and deletions as changed items' do
-    difference = described_class.call(%i[a b c], %i[c b a])
-    difference.should == [['~', '[0]', :a, :c], ['~', '[2]', :c, :a]]
-  end
-
-  it 'shows changed items in a hash' do
-    difference = described_class.call([{ a: :b }], [{ a: :c }])
-    difference.should == [['~', '[0].a', :b, :c]]
-  end
-
-  it 'shows 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/hashdiff/patch_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is 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 = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(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 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value type changes' do
-    a = { 'a' => 3 }
-    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 3 }
-    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value array <=> []' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => [] }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => [] }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value array <=> nil' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => nil }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => nil }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch array value removal' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch array under hash key with non-word characters' do
-    a = { 'a' => 1, 'b-b' => [1, 2] }
-    b = { 'a' => 1, 'b-b' => [2, 1] }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b-b' => [1, 2] }
-    b = { 'a' => 1, 'b-b' => [2, 1] }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch hash value removal' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value hash <=> {}' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => {} }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => {} }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value hash <=> nil' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => nil }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => nil }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value nil removal' do
-    a = { 'a' => 1, 'b' => nil }
-    b = { 'a' => 1 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => nil }
-    b = { 'a' => 1 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is 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 = described_class.diff(a, b)
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = [{ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }, 3]
-    b = [1, { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }]
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is 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 = described_class.diff(a, b)
-    expect(described_class.patch!(a, diff)).to eq(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 }]
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch hash value removal with custom delimiter' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => { 'b1' => 3 } }
-    diff = described_class.diff(a, b, delimiter: "\n")
-
-    expect(described_class.patch!(a, diff, delimiter: "\n")).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => { 'b1' => 3 } }
-    described_class.unpatch!(b, diff, delimiter: "\n").should == a
-  end
-
-  it 'is able to patch when the diff is generated with an array_path' do
-    a = { 'a' => 1, 'b' => 1 }
-    b = { 'a' => 1, 'b' => 2 }
-    diff = described_class.diff(a, b, array_path: true)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => 1 }
-    b = { 'a' => 1, 'b' => 2 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to use non string keys when diff is generated with an array_path' do
-    a = { 'a' => 1, :a => 2, 0 => 3 }
-    b = { 'a' => 5, :a => 6, 0 => 7 }
-    diff = described_class.diff(a, b, array_path: true)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, :a => 2, 0 => 3 }
-    b = { 'a' => 5, :a => 6, 0 => 7 }
-    described_class.unpatch!(b, diff).should == a
-  end
-end

data/spec/hashdiff/readme_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'README.md' do
-  it 'has correct examples' do
-    File.read('README.md').scan(/```ruby(.*?)```/m).flatten(1).each do |block|
-      begin
-        eval block # rubocop:disable Security/Eval
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        raise "README.md code block:\n#{block}\n\nhas error:\n#{e}"
-      end
-    end
-  end
-end

data/spec/hashdiff/util_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to decode property path' do
-    decoded = described_class.send(:decode_property_path, 'a.b[0].c.city[5]')
-    decoded.should == ['a', 'b', 0, 'c', 'city', 5]
-  end
-
-  it 'is able to decode property path with custom delimiter' do
-    decoded = described_class.send(:decode_property_path, "a\tb[0]\tc\tcity[5]", "\t")
-    decoded.should == ['a', 'b', 0, 'c', 'city', 5]
-  end
-
-  it 'is 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 }
-    described_class.similar?(a, b).should be true
-    described_class.similar?(a, b, similarity: 1).should be false
-  end
-
-  it 'is able to tell similiar empty hash' do
-    described_class.similar?({}, {}, similarity: 1).should be true
-  end
-
-  it 'is able to tell similiar empty array' do
-    described_class.similar?([], [], similarity: 1).should be true
-  end
-
-  it 'is able to tell similiar hash with values within tolerance' do
-    a = { 'a' => 1.5, 'b' => 2.25, 'c' => 3, 'd' => 4, 'e' => 5 }
-    b = { 'a' => 1.503, 'b' => 2.22, 'c' => 3, 'e' => 5 }
-    described_class.similar?(a, b, numeric_tolerance: 0.05).should be true
-    described_class.similar?(a, b).should be false
-  end
-
-  it 'is able to tell numbers and strings' do
-    described_class.similar?(1, 2).should be false
-    described_class.similar?('a', 'b').should be false
-    described_class.similar?('a', [1, 2, 3]).should be false
-    described_class.similar?(1, 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5).should be false
-  end
-
-  it 'is able to tell true when similarity == 0.5' do
-    a = { 'value' => 'New1', 'onclick' => 'CreateNewDoc()' }
-    b = { 'value' => 'New', 'onclick' => 'CreateNewDoc()' }
-
-    described_class.similar?(a, b, similarity: 0.5).should be true
-  end
-
-  it 'is able to tell false when similarity == 0.5' do
-    a = { 'value' => 'New1', 'onclick' => 'open()' }
-    b = { 'value' => 'New', 'onclick' => 'CreateNewDoc()' }
-
-    described_class.similar?(a, b, similarity: 0.5).should be false
-  end
-
-  describe '.compare_values' do
-    it 'compares numeric values exactly when no tolerance' do
-      expect(described_class.compare_values(10.004, 10.003)).to be false
-    end
-
-    it 'allows tolerance with numeric values' do
-      expect(described_class.compare_values(10.004, 10.003, numeric_tolerance: 0.01)).to be true
-    end
-
-    it 'compares different objects without tolerance' do
-      expect(described_class.compare_values('hats', 'ninjas')).to be false
-    end
-
-    it 'compares other objects with tolerance' do
-      expect(described_class.compare_values('hats', 'ninjas', numeric_tolerance: 0.01)).to be false
-    end
-
-    it 'compares same objects without tolerance' do
-      expect(described_class.compare_values('horse', 'horse')).to be true
-    end
-
-    it 'compares strings for spaces exactly by default' do
-      expect(described_class.compare_values(' horse', 'horse')).to be false
-    end
-
-    it 'compares strings for capitalization exactly by default' do
-      expect(described_class.compare_values('horse', 'Horse')).to be false
-    end
-
-    it 'strips strings before comparing when requested' do
-      expect(described_class.compare_values(' horse', 'horse', strip: true)).to be true
-    end
-
-    it 'ignores string case when requested' do
-      expect(described_class.compare_values('horse', 'Horse', case_insensitive: true)).to be true
-    end
-  end
-
-  describe '.comparable?' do
-    it 'identifies hashes as comparable' do
-      expect(described_class.comparable?({}, {})).to be true
-    end
-
-    it 'identifies a subclass of Hash to be comparable with a Hash' do
-      other = Class.new(Hash)
-      expect(described_class.comparable?(other.new, {})).to be true
-    end
-
-    it 'identifies a Hash to be comparable with a subclass of Hash' do
-      other = Class.new(Hash)
-      expect(described_class.comparable?({}, other.new)).to be true
-    end
-
-    it 'does not identify a Numeric as comparable with a Hash' do
-      expect(described_class.comparable?(1, {})).to be false
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-$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