vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.5/Gemfile

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

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.5/README.md

@@ -0,0 +1,243 @@
+# 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 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)
+
+## 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
+
+There are seven options available: `:delimiter`, `:similarity`,
+`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`
+and `:array_path`.
+
+#### `: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, 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).
+
+#### `: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, :comparison => { :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, :comparison => { :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 == [["~", [:a], [1], {0=>1}]]
+```
+
+#### 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) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
+
+b[:b].sort!
+
+HashDiff.diff(a, b) => []
+```
+
+## License
+
+HashDiff is distributed under the MIT-LICENSE.
+

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.5/changelog.md

@@ -0,0 +1,64 @@
+# Change Log
+
+## v0.3.5 2017-08-06
+
+* add option `array_path` #34
+
+## v0.3.4 2017-05-01
+
+* performance improvement of HashDiff#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 HashDiff.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.4.0/gems/hashdiff-0.3.5/lib/hashdiff/diff.rb

@@ -0,0 +1,227 @@
+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
+  #   * :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.
+  #
+  # @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)
+    diffs_1 = diff(obj1, obj2, opts)
+    count_1 = count_diff diffs_1
+
+    opts = { :similarity => 0.5 }.merge!(options)
+    diffs_2 = diff(obj1, obj2, opts)
+    count_2 = count_diff diffs_2
+
+    opts = { :similarity => 0.8 }.merge!(options)
+    diffs_3 = diff(obj1, obj2, opts)
+    count_3 = count_diff diffs_3
+
+    count, diffs = count_1 < count_2 ? [count_1, diffs_1] : [count_2, diffs_2]
+    diffs = count < count_3 ? diffs : diffs_3
+  end
+
+  # Compute the diff of two hashes or arrays
+  #
+  # @param [Array, Hash] obj1
+  # @param [Array, Hash] obj2
+  # @param [Hash] options the options to use when comparing
+  #   * :strict (Boolean) [true] whether numeric values will be compared on type as well as value.  Set to false to allow comparing Integer, Float, BigDecimal to each other
+  #   * :similarity (Numeric) [0.8] should be between (0, 1]. Meaningful if there are similar hashes in arrays. See {best_diff}.
+  #   * :delimiter (String) ['.'] the delimiter used when returning nested key references
+  #   * :numeric_tolerance (Numeric) [0] should be a positive numeric value.  Value by which numeric differences must be greater than.  By default, numeric values are compared exactly; with the :tolerance option, the difference between numeric values must be greater than the given value.
+  #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
+  #   * :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.
+  #
+  # @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,
+      :strip       =>   false,
+      :numeric_tolerance => 0,
+      :array_path  =>   false
+    }.merge!(options)
+
+    opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
+
+    opts[:comparison] = block if block_given?
+
+    # prefer to compare with provided block
+    result = custom_compare(opts[:comparison], opts[:prefix], obj1, obj2)
+    return result if result
+
+    if obj1.nil? and obj2.nil?
+      return []
+    end
+
+    if obj1.nil?
+      return [['~', opts[:prefix], nil, obj2]]
+    end
+
+    if obj2.nil?
+      return [['~', opts[:prefix], obj1, nil]]
+    end
+
+    unless comparable?(obj1, obj2, opts[:strict])
+      return [['~', opts[:prefix], obj1, obj2]]
+    end
+
+    result = []
+    if obj1.is_a?(Array)
+      changeset = diff_array(obj1, obj2, opts) do |lcs|
+        # use a's index for similarity
+        lcs.each do |pair|
+          prefix = prefix_append_array_index(opts[:prefix], pair[0], opts)
+          result.concat(diff(obj1[pair[0]], obj2[pair[1]], opts.merge(:prefix => prefix)))
+        end
+      end
+
+      changeset.each do |change|
+        change_key = prefix_append_array_index(opts[:prefix], change[1], opts)
+        if change[0] == '-'
+          result << ['-', change_key, change[2]]
+        elsif change[0] == '+'
+          result << ['+', change_key, change[2]]
+        end
+      end
+    elsif obj1.is_a?(Hash)
+
+      deleted_keys = obj1.keys - obj2.keys
+      common_keys = obj1.keys & obj2.keys
+      added_keys = obj2.keys - obj1.keys
+
+      # add deleted properties
+      deleted_keys.sort_by{|k,v| k.to_s }.each do |k|
+        change_key = prefix_append_key(opts[:prefix], k, opts)
+        custom_result = 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.sort_by{|k,v| k.to_s }.each do |k|
+        prefix = prefix_append_key(opts[:prefix], k, opts)
+        result.concat(diff(obj1[k], obj2[k], opts.merge(:prefix => prefix)))
+      end
+
+      # added properties
+      added_keys.sort_by{|k,v| k.to_s }.each do |k|
+        change_key = prefix_append_key(opts[:prefix], k, opts)
+        unless obj1.key?(k)
+          custom_result = custom_compare(opts[:comparison], change_key, nil, obj2[k])
+
+          if custom_result
+            result.concat(custom_result)
+          else
+            result << ['+', change_key, obj2[k]]
+          end
+        end
+      end
+    else
+      return [] if compare_values(obj1, obj2, opts)
+      return [['~', opts[:prefix], obj1, obj2]]
+    end
+
+    result
+  end
+
+  # @private
+  #
+  # diff array using LCS algorithm
+  def self.diff_array(a, b, options = {})
+    opts = {
+      :prefix      =>   '',
+      :similarity  =>   0.8,
+      :delimiter   =>   '.'
+    }.merge!(options)
+
+    change_set = []
+    if a.size == 0 and b.size == 0
+      return []
+    elsif a.size == 0
+      b.each_index do |index|
+        change_set << ['+', index, b[index]]
+      end
+      return change_set
+    elsif b.size == 0
+      a.each_index do |index|
+        i = a.size - index - 1
+        change_set << ['-', i, a[i]]
+      end
+      return change_set
+    end
+
+    links = lcs(a, b, opts)
+
+    # yield common
+    yield links if block_given?
+
+    # padding the end
+    links << [a.size, b.size]
+
+    last_x = -1
+    last_y = -1
+    links.each do |pair|
+      x, y = pair
+
+      # remove from a, beginning from the end
+      (x > last_x + 1) and (x - last_x - 2).downto(0).each do |i|
+        change_set << ['-', last_y + i + 1, a[i + last_x + 1]]
+      end
+
+      # add from b, beginning from the head
+      (y > last_y + 1) and 0.upto(y - last_y - 2).each do |i|
+        change_set << ['+', last_y + i + 1, b[i + last_y + 1]]
+      end
+
+      # update flags
+      last_x = x
+      last_y = y
+    end
+
+    change_set
+  end
+
+end