cloudsmith-api 2.0.17 → 2.0.19

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.1.2/README.md

@@ -1,298 +0,0 @@
-# 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.
-
-It also supports comparing two arrays.
-
-Hashdiff does not monkey-patch any existing class. All features are contained inside the `Hashdiff` module.
-
-**Docs**: [Documentation](http://rubydoc.info/gems/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?
-
-An algorithm that responds to this question has to do following:
-
-* Generate a list of additions, deletions and changes, so that `A + ChangeSet = B` and `B - ChangeSet = A`.
-* 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:
-
-* 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]]`.
-* It compares Arrays using the [LCS(longest common subsequence)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem) algorithm.
-* It recognizes similar Hashes in an Array using a similarity value (0 < similarity <= 1).
-
-## Usage
-
-To use the gem, add the following to your Gemfile:
-
-```Ruby
-gem 'hashdiff'
-```
-
-## Quick Start
-
-### Diff
-
-Two simple hashes:
-
-```ruby
-a = {a:3, b:2}
-b = {}
-
-diff = Hashdiff.diff(a, b)
-diff.should == [['-', 'a', 3], ['-', 'b', 2]]
-```
-
-More complex hashes:
-
-```ruby
-a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
-b = {a:{y:3}, b:{y:3, z:30}}
-
-diff = Hashdiff.diff(a, b)
-diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
-```
-
-Arrays in hashes:
-
-```ruby
-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.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
-```
-
-### Patch
-
-patch example:
-
-```ruby
-a = {'a' => 3}
-b = {'a' => {'a1' => 1, 'a2' => 2}}
-
-diff = Hashdiff.diff(a, b)
-Hashdiff.patch!(a, diff).should == b
-```
-
-unpatch example:
-
-```ruby
-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
-```
-
-### Options
-
-The following options are available: `:delimiter`, `:similarity`, `:strict`, `:ignore_keys`,
-`:indifferent`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path` and `:use_lcs`
-
-#### `:delimiter`
-
-You can specify `:delimiter` to be something other than the default dot. For example:
-
-```ruby
-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.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
-```
-
-#### `:similarity`
-
-In cases where you have similar hash objects in arrays, you can pass a custom value for `:similarity` instead of the default `0.8`.  This is interpreted as a ratio of similarity (default is 80% similar, whereas `:similarity => 0.5` would look for at least a 50% similarity).
-
-#### `:strict`
-
-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).
-
-#### `: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 in both hashes. For example:
-
-```ruby
-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 to diff only at the 2nd level of both hashes:
-
-```ruby
-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`
-
-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`
-
-The :numeric_tolerance option allows for a small numeric tolerance.
-
-```ruby
-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.should == [["~", "x", 5, 6]]
-```
-
-#### `:strip`
-
-The :strip option strips all strings before comparing.
-
-```ruby
-a = {x:5, s:'foo '}
-b = {x:6, s:'foo'}
-
-diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1, strip: true)
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:case_insensitive`
-
-The :case_insensitive option makes string comparisons ignore case.
-
-```ruby
-a = {x:5, s:'FooBar'}
-b = {x:6, s:'foobar'}
-
-diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1, case_insensitive: true)
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:array_path`
-
-The :array_path option represents the path of the diff in an array rather than
-a string. This can be used to show differences in between hash key types and
-is useful for `patch!` when used on hashes without string keys.
-
-```ruby
-a = {x:5}
-b = {'x'=>6}
-
-diff = Hashdiff.diff(a, b, array_path: true)
-diff.should == [['-', [:x], 5], ['+', ['x'], 6]]
-```
-
-For cases where there are arrays in paths their index will be added to the path.
-```ruby
-a = {x:[0,1]}
-b = {x:[0,2]}
-
-diff = Hashdiff.diff(a, b, array_path: true)
-diff.should == [["-", [:x, 1], 1], ["+", [:x, 1], 2]]
-```
-
-This shouldn't cause problems if you are comparing an array with a hash:
-
-```ruby
-a = {x:{0=>1}}
-b = {x:[1]}
-
-diff = Hashdiff.diff(a, b, array_path: true)
-diff.should == [["~", [:x], {0=>1}, [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.
-
-```ruby
-a = {a:'car', b:'boat', c:'plane'}
-b = {a:'bus', b:'truck', c:' plan'}
-
-diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
-  case path
-  when  /a|b|c/
-    obj1.length == obj2.length
-  end
-end
-
-diff.should == [['~', 'b', 'boat', 'truck']]
-```
-
-The yielded params of the comparison block is `|path, obj1, obj2|`, in which path is the key (or delimited compound key) to the value being compared. When comparing elements in array, the path is with the format `array[*]`. For example:
-
-```ruby
-a = {a:'car', b:['boat', 'plane'] }
-b = {a:'bus', b:['truck', ' plan'] }
-
-diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
-  case path
-  when 'b[*]'
-    obj1.length == obj2.length
-  end
-end
-
-diff.should == [["~", "a", "car", "bus"], ["~", "b[1]", "plane", " plan"], ["-", "b[0]", "boat"], ["+", "b[0]", "truck"]]
-```
-
-When a comparison block is given, it'll be given priority over other specified options. If the block returns value other than `true` or `false`, then the two values will be compared with other specified options.
-
-When used in conjunction with the `array_path` option, the path passed in as an argument will be an array. When determining the ordering of an array a key of `"*"` will be used in place of the `key[*]` field. It is possible, if you have hashes with integer or `"*"` keys, to have problems distinguishing between arrays and hashes - although this shouldn't be an issue unless your data is very difficult to predict and/or your custom rules are very specific.
-
-#### Sorting arrays before comparison
-
-An order difference alone between two arrays can create too many diffs to be useful. Consider sorting them prior to diffing.
-
-```ruby
-a = {a:'car', b:['boat', 'plane'] }
-b = {a:'car', b:['plane', 'boat'] }
-
-Hashdiff.diff(a, b).should == [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
-
-b[:b].sort!
-
-Hashdiff.diff(a, b).should == []
-```
-
-## Maintainers
-
-- Krzysztof Rybka ([@krzysiek1507](https://github.com/krzysiek1507))
-- Fengyun Liu ([@liufengyun](https://github.com/liufengyun))
-
-## License
-
-Hashdiff is distributed under the MIT-LICENSE.

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.1.2/changelog.md

@@ -1,119 +0,0 @@
-# Change Log
-
-## 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
-* Bump rspec dep ~> 3.5
-* Bump rubocop dep >= 1.52.1
-* Bump rubocop-rspec dep > 1.16.0
-
-## 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
-
-## v0.3.6 2017-08-22
-
-* add option `use_lcs` #35
-
-## v0.3.5 2017-08-06
-
-* add option `array_path` #34
-
-## v0.3.4 2017-05-01
-
-* performance improvement of `#similar?` #31
-
-## v0.3.2 2016-12-27
-
-* replace `Fixnum` by `Integer` #28
-
-## v0.3.1 2016-11-24
-
-* fix an error when a hash has mixed types #26
-
-## 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 `.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/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.1.2/lib/hashdiff/compare_hashes.rb

@@ -1,75 +0,0 @@
-# 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 = []
-
-        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|
-          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

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.1.2/lib/hashdiff/diff.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-module Hashdiff
-  # Best diff two objects, which tries to generate the smallest change set using different similarity values.
-  #
-  # Hashdiff.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 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) 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.
-  #   * :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.
-  #
-  # @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 = Hashdiff.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)
-    diffs1 = diff(obj1, obj2, opts)
-    count1 = count_diff diffs1
-
-    opts = { similarity: 0.5 }.merge!(options)
-    diffs2 = diff(obj1, obj2, opts)
-    count2 = count_diff diffs2
-
-    opts = { similarity: 0.8 }.merge!(options)
-    diffs3 = diff(obj1, obj2, opts)
-    count3 = count_diff diffs3
-
-    count, diffs = count1 < count2 ? [count1, diffs1] : [count2, diffs2]
-    count < count3 ? diffs : diffs3
-  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 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) 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
-  #   * :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.
-  #
-  # @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 = Hashdiff.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,
-      ignore_keys: [],
-      indifferent: false,
-      strip: false,
-      numeric_tolerance: 0,
-      array_path: false,
-      use_lcs: true
-    }.merge!(options)
-
-    opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
-
-    opts[:ignore_keys] = [*opts[:ignore_keys]]
-
-    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
-
-    return [] if obj1.nil? && obj2.nil?
-
-    return [['~', opts[:prefix], obj1, obj2]] if obj1.nil? || obj2.nil?
-
-    return [['~', opts[:prefix], obj1, obj2]] unless comparable?(obj1, obj2, opts[:strict])
-
-    return LcsCompareArrays.call(obj1, obj2, opts) if obj1.is_a?(Array) && opts[:use_lcs]
-
-    return LinearCompareArray.call(obj1, obj2, opts) if obj1.is_a?(Array) && !opts[:use_lcs]
-
-    return CompareHashes.call(obj1, obj2, opts) if obj1.is_a?(Hash)
-
-    return [] if compare_values(obj1, obj2, opts)
-
-    [['~', opts[:prefix], obj1, obj2]]
-  end
-
-  # @private
-  #
-  # diff array using LCS algorithm
-  def self.diff_array_lcs(arraya, arrayb, options = {})
-    return [] if arraya.empty? && arrayb.empty?
-
-    change_set = []
-
-    if arraya.empty?
-      arrayb.each_index do |index|
-        change_set << ['+', index, arrayb[index]]
-      end
-
-      return change_set
-    end
-
-    if arrayb.empty?
-      arraya.each_index do |index|
-        i = arraya.size - index - 1
-        change_set << ['-', i, arraya[i]]
-      end
-
-      return change_set
-    end
-
-    opts = {
-      prefix: '',
-      similarity: 0.8,
-      delimiter: '.'
-    }.merge!(options)
-
-    links = lcs(arraya, arrayb, opts)
-
-    # yield common
-    yield links if block_given?
-
-    # padding the end
-    links << [arraya.size, arrayb.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) && (x - last_x - 2).downto(0).each do |i|
-        change_set << ['-', last_y + i + 1, arraya[i + last_x + 1]]
-      end
-
-      # add from b, beginning from the head
-      (y > last_y + 1) && 0.upto(y - last_y - 2).each do |i|
-        change_set << ['+', last_y + i + 1, arrayb[i + last_y + 1]]
-      end
-
-      # update flags
-      last_x = x
-      last_y = y
-    end
-
-    change_set
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.1.2/lib/hashdiff/version.rb

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

data/vendor/bundle/ruby/2.6.0/gems/rspec-3.13.0/lib/rspec/version.rb

@@ -1,5 +0,0 @@
-module RSpec # :nodoc:
-  module Version # :nodoc:
-    STRING = '3.13.0'
-  end
-end