vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/lib/hashdiff/patch.rb

@@ -0,0 +1,88 @@
+#
+# This module provides methods to diff two hash, patch and unpatch hash
+#
+module HashDiff
+
+  # Apply patch to object
+  #
+  # @param [Hash, Array] obj the object to be patched, can be an Array or a Hash
+  # @param [Array] changes e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  # @param [Hash] options supports following keys:
+  #   * :delimiter (String) ['.'] delimiter string for representing nested keys in changes array
+  #
+  # @return the object after patch
+  #
+  # @since 0.0.1
+  def self.patch!(obj, changes, options = {})
+    delimiter = options[:delimiter] || '.'
+
+    changes.each do |change|
+      parts = change[1]
+      parts = decode_property_path(parts, delimiter) unless parts.is_a?(Array)
+
+      last_part = parts.last
+
+      parent_node = node(obj, parts[0, parts.size-1])
+
+      if change[0] == '+'
+        if parent_node.is_a?(Array)
+          parent_node.insert(last_part, change[2])
+        else
+          parent_node[last_part] = change[2]
+        end
+      elsif change[0] == '-'
+        if parent_node.is_a?(Array)
+          parent_node.delete_at(last_part)
+        else
+          parent_node.delete(last_part)
+        end
+      elsif change[0] == '~'
+        parent_node[last_part] = change[3]
+      end
+    end
+
+    obj
+  end
+
+  # Unpatch an object
+  #
+  # @param [Hash, Array] obj the object to be unpatched, can be an Array or a Hash
+  # @param [Array] changes e.g. [[ '+', 'a.b', '45' ], [ '-', 'a.c', '5' ], [ '~', 'a.x', '45', '63']]
+  # @param [Hash] options supports following keys:
+  #   * :delimiter (String) ['.'] delimiter string for representing nested keys in changes array
+  #
+  # @return the object after unpatch
+  #
+  # @since 0.0.1
+  def self.unpatch!(obj, changes, options = {})
+    delimiter = options[:delimiter] || '.'
+
+    changes.reverse_each do |change|
+      parts = change[1]
+      parts = decode_property_path(parts, delimiter) unless parts.is_a?(Array)
+
+      last_part = parts.last
+
+      parent_node = node(obj, parts[0, parts.size-1])
+
+      if change[0] == '+'
+        if parent_node.is_a?(Array)
+          parent_node.delete_at(last_part)
+        else
+          parent_node.delete(last_part)
+        end
+      elsif change[0] == '-'
+        if parent_node.is_a?(Array)
+          parent_node.insert(last_part, change[2])
+        else
+          parent_node[last_part] = change[2]
+        end
+      elsif change[0] == '~'
+        parent_node[last_part] = change[2]
+      end
+    end
+
+    obj
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/lib/hashdiff/util.rb

@@ -0,0 +1,146 @@
+module HashDiff
+
+  # @private
+  #
+  # judge whether two objects are similar
+  def self.similar?(a, b, options = {})
+    return compare_values(a, b, options) unless a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+    opts = { :similarity => 0.8 }.merge(options)
+
+    count_a = count_nodes(a)
+    count_b = count_nodes(b)
+    diffs = count_diff diff(a, b, opts)
+
+    if count_a + count_b == 0
+      return true
+    else
+      (1 - diffs.to_f/(count_a + count_b).to_f) >= opts[:similarity]
+    end
+  end
+
+  # @private
+  #
+  # count node differences
+  def self.count_diff(diffs)
+    diffs.inject(0) do |sum, item|
+      old_change_count = count_nodes(item[2])
+      new_change_count = count_nodes(item[3])
+      sum += (old_change_count + new_change_count)
+    end
+  end
+
+  # @private
+  #
+  # count total nodes for an object
+  def self.count_nodes(obj)
+    return 0 unless obj
+
+    count = 0
+    if obj.is_a?(Array)
+      obj.each {|e| count += count_nodes(e) }
+    elsif obj.is_a?(Hash)
+      obj.each {|k, v| count += count_nodes(v) }
+    else
+      return 1
+    end
+
+    count
+  end
+
+  # @private
+  #
+  # decode property path into an array
+  # @param [String] path Property-string
+  # @param [String] delimiter Property-string delimiter
+  #
+  # e.g. "a.b[3].c" => ['a', 'b', 3, 'c']
+  def self.decode_property_path(path, delimiter='.')
+    path.split(delimiter).inject([]) do |memo, part|
+      if part =~ /^(.*)\[(\d+)\]$/
+        if $1.size > 0
+          memo + [$1, $2.to_i]
+        else
+          memo + [$2.to_i]
+        end
+      else
+        memo + [part]
+      end
+    end
+  end
+
+  # @private
+  #
+  # get the node of hash by given path parts
+  def self.node(hash, parts)
+    temp = hash
+    parts.each do |part|
+      temp = temp[part]
+    end
+    temp
+  end
+
+  # @private
+  #
+  # check for equality or "closeness" within given tolerance
+  def self.compare_values(obj1, obj2, options = {})
+    if (options[:numeric_tolerance].is_a? Numeric) &&
+        [obj1, obj2].all? { |v| v.is_a? Numeric }
+      return (obj1 - obj2).abs <= options[:numeric_tolerance]
+    end
+
+    if options[:strip] == true
+      obj1 = obj1.strip if obj1.respond_to?(:strip)
+      obj2 = obj2.strip if obj2.respond_to?(:strip)
+    end
+
+    if options[:case_insensitive] == true
+      obj1 = obj1.downcase if obj1.respond_to?(:downcase)
+      obj2 = obj2.downcase if obj2.respond_to?(:downcase)
+    end
+
+    obj1 == obj2
+  end
+
+  # @private
+  #
+  # check if objects are comparable
+  def self.comparable?(obj1, obj2, strict = true)
+    [Array, Hash].each do |type|
+      return true if obj1.is_a?(type) && obj2.is_a?(type)
+    end
+    return true if !strict && obj1.is_a?(Numeric) && obj2.is_a?(Numeric)
+    obj1.is_a?(obj2.class) && obj2.is_a?(obj1.class)
+  end
+
+  # @private
+  #
+  # try custom comparison
+  def self.custom_compare(method, key, obj1, obj2)
+    if method
+      res = method.call(key, obj1, obj2)
+
+      # nil != false here
+      if res == false
+        return [['~', key, obj1, obj2]]
+      elsif res == true
+        return []
+      end
+    end
+  end
+
+  def self.prefix_append_key(prefix, key, opts)
+    if opts[:array_path]
+      prefix + [key]
+    else
+      prefix.empty? ? "#{key}" : "#{prefix}#{opts[:delimiter]}#{key}"
+    end
+  end
+
+  def self.prefix_append_array_index(prefix, array_index, opts)
+    if opts[:array_path]
+      prefix + [array_index]
+    else
+      "#{prefix}[#{array_index}]"
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/lib/hashdiff/version.rb

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

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/lib/hashdiff.rb

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

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/spec/hashdiff/best_diff_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to best diff" do
+    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}]]
+  end
+
+  it "should use custom delimiter when provided" do
+    a = {'x' => [{'a' => 1, 'c' => 3, 'e' => 5}, {'y' => 3}]}
+    b = {'x' => [{'a' => 1, 'b' => 2, 'e' => 5}] }
+
+    diff = HashDiff.best_diff(a, b, :delimiter => "\t")
+    diff.should == [["-", "x[0]\tc", 3], ["+", "x[0]\tb", 2], ["-", "x[1]", {"y"=>3}]]
+  end
+
+  it "should use custom comparison when provided" do
+    a = {'x' => [{'a' => 'foo', 'c' => 'goat', 'e' => 'snake'}, {'y' => 'baz'}]}
+    b = {'x' => [{'a' => 'bar', 'b' => 'cow', 'e' => 'puppy'}] }
+
+    diff = HashDiff.best_diff(a, b) do |path, obj1, obj2|
+      case path
+      when /^x\[.\]\..$/
+        obj1.length == obj2.length if obj1 and obj2
+      end
+    end
+
+    diff.should == [["-", "x[0].c", 'goat'], ["+", "x[0].b", 'cow'], ["-", "x[1]", {"y"=>'baz'}]]
+  end
+
+  it "should be 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 = HashDiff.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 "should be 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 = HashDiff.best_diff(a, b, :array_path => true)
+    diff.should == [["-", ["x", 0, "c"], 3], ["+", ["x", 0, "b"], 2], ["-", ["x", 1], {"y"=>3}]]
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/spec/hashdiff/diff_array_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to diff two equal array" do
+    a = [1, 2, 3]
+    b = [1, 2, 3]
+
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == []
+  end
+
+  it "should be able to diff two arrays with one element in common" do
+    a = [1, 2, 3]
+    b = [1, 8, 7]
+
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == [['-', 2, 3], ['-', 1, 2], ['+', 1, 8], ['+', 2, 7]]
+  end
+
+  it "should be able to diff two arrays with nothing in common" do
+    a = [1, 2]
+    b = []
+
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == [['-', 1, 2], ['-', 0, 1]]
+  end
+
+  it "should be able to diff an empty array with an non-empty array" do
+    a = []
+    b = [1, 2]
+
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == [['+', 0, 1], ['+', 1, 2]]
+  end
+
+  it "should be able to diff two arrays with two elements in common" do
+    a = [1, 3, 5, 7]
+    b = [2, 3, 7, 5]
+
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == [['-', 0, 1], ['+', 0, 2], ['+', 2, 7], ['-', 4, 7]]
+  end
+
+  it "should be able to test two arrays with two common elements in different order" do
+    a = [1, 3, 4, 7]
+    b = [2, 3, 7, 5]
+
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == [['-', 0, 1], ['+', 0, 2], ['-', 2, 4], ['+', 3, 5]]
+  end
+
+  it "should be able to diff two arrays with similar elements" do
+    a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, 3]
+    b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+    diff = HashDiff.diff_array_lcs(a, b)
+    diff.should == [['+', 0, 1], ['-', 2, 3]]
+  end
+
+end
+

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.7/spec/hashdiff/diff_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+
+describe HashDiff do
+  it "should be able to diff two empty hashes" do
+    diff = HashDiff.diff({}, {})
+    diff.should == []
+  end
+
+  it "should be able to diff an hash with an empty hash" do
+    a = { 'a' => 3, 'b' => 2 }
+    b = {}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'a', 3], ['-', 'b', 2]]
+
+    diff = HashDiff.diff(b, a)
+    diff.should == [['+', 'a', 3], ['+', 'b', 2]]
+  end
+
+  it "should be able to diff two equal hashes" do
+    diff = HashDiff.diff({ 'a' => 2, 'b' => 2}, { 'a' => 2, 'b' => 2 })
+    diff.should == []
+  end
+
+  it "should be able to diff two equal hashes with mixed key types" do
+    a = { 'a' => 1, :b => 1 }
+    diff = HashDiff.diff(a, a)
+    diff.should == []
+  end
+
+  it "should be able to diff if mixed key types are removed" do
+    a = { 'a' => 1, :b => 1 }
+    b = {}
+    diff = HashDiff.diff(a, b)
+    diff.should == [["-", "a", 1], ["-", "b", 1]]
+  end
+
+  it "should be able to diff if mixed key types are added" do
+    a = { 'a' => 1, :b => 1 }
+    b = {}
+    diff = HashDiff.diff(b, a)
+    diff.should == [["+", "a", 1], ["+", "b", 1]]
+  end
+
+  it "should be able to diff two hashes with equivalent numerics, when strict is false" do
+    diff = HashDiff.diff({ 'a' => 2.0, 'b' => 2 }, { 'a' => 2, 'b' => 2.0 }, :strict => false)
+    diff.should == []
+  end
+
+  it "should be able to diff changes in hash value" do
+    diff = HashDiff.diff({ 'a' => 2, 'b' => 3, 'c' => " hello" }, { 'a' => 2, 'b' => 4, 'c' => "hello" })
+    diff.should == [['~', 'b', 3, 4], ['~', 'c', " hello", "hello"]]
+  end
+
+  it "should be able to diff changes in hash value which is array" do
+    diff = HashDiff.diff({ 'a' => 2, 'b' => [1, 2, 3] }, { 'a' => 2, 'b' => [1, 3, 4]})
+    diff.should == [['-', 'b[1]', 2], ['+', 'b[2]', 4]]
+  end
+
+  it "should be able to diff changes in hash value which is hash" do
+    diff = HashDiff.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 "should be able to diff similar objects in array" do
+    diff = HashDiff.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 'should be 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 = HashDiff.diff(a, b)
+    diff.should == [['+', 'g', 300]]
+
+    diff = HashDiff.diff(b, a)
+    diff.should == [['-', 'g', 300]]
+  end
+
+  it 'should be able to diff value type changes' do
+    a = {"a" => 3}
+    b = {"a" => {"a1" => 1, "a2" => 2}}
+
+    diff = HashDiff.diff(a, b)
+    diff.should  == [['~', 'a', 3, {"a1" => 1, "a2" => 2}]]
+
+    diff = HashDiff.diff(b, a)
+    diff.should  == [['~', 'a', {"a1" => 1, "a2" => 2}, 3]]
+  end
+
+  it "should be able to diff value changes: array <=> []" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => []}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [['-', 'b[1]', 2], ['-', 'b[0]', 1]]
+  end
+
+  it "should be able to diff value changes: array <=> nil" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => nil}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [["~", "b", [1, 2], nil]]
+  end
+
+  it "should be able to diff value chagnes: remove array completely" do
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [["-", "b", [1, 2]]]
+  end
+
+  it "should be able to diff value changes: remove whole hash" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [["-", "b", {"b1"=>1, "b2"=>2}]]
+  end
+
+  it "should be able to diff value changes: hash <=> {}" do
+    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]]
+  end
+
+  it "should be able to diff value changes: hash <=> nil" do
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => nil}
+
+    diff = HashDiff.diff(a, b)
+    diff.should == [["~", "b", {"b1"=>1, "b2"=>2}, nil]]
+  end
+
+  it "should be 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 = HashDiff.diff(a, b)
+    diff.should == [['-', '[0].d', 4], ['+', '[0]', 1], ['-', '[2]', 3]]
+  end
+
+  it "should be 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 = HashDiff.diff(a, b)
+    diff.should == [["-", "[0].d", 4], ["-", "[1]", {"x"=>5, "y"=>6, "z"=>3}]]
+  end
+
+  it "should use 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 = HashDiff.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 "should be 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 = HashDiff.diff(a, b, :numeric_tolerance => 0.01)
+      diff.should == [["~", "b", 0.0, 'hats'], ["~", "c", 0.65, 0.67]]
+
+      diff = HashDiff.diff(b, a, :numeric_tolerance => 0.01)
+      diff.should == [["~", "b", 'hats', 0.0], ["~", "c", 0.67, 0.65]]
+    end
+
+    it "should be 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 = HashDiff.diff(a, b, :numeric_tolerance => 0.01)
+      diff.should == [["~", "a.x", 0.4, 0.6], ["-", "b[0]", 13], ["+", "b[0]", 14]]
+
+      diff = HashDiff.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 "should strip strings before comparing" do
+      a = { 'a' => " foo", 'b' => "fizz buzz"}
+      b = { 'a' => "foo", 'b' => "fizzbuzz"}
+      diff = HashDiff.diff(a, b, :strip => true)
+      diff.should == [['~', 'b', "fizz buzz", "fizzbuzz"]]
+    end
+
+    it "should strip nested strings before comparing" do
+      a = { 'a' => { 'x' => " foo" }, 'b' => ["fizz buzz", "nerf"] }
+      b = { 'a' => { 'x' => "foo" }, 'b' => ["fizzbuzz", "nerf"] }
+      diff = HashDiff.diff(a, b, :strip => true)
+      diff.should == [['-', 'b[0]', "fizz buzz"], ['+', 'b[0]', "fizzbuzz"]]
+    end
+  end
+
+  context 'when :case_insensitive requested' do
+    it "should strip strings before comparing" do
+      a = { 'a' => "Foo", 'b' => "fizz buzz"}
+      b = { 'a' => "foo", 'b' => "fizzBuzz"}
+      diff = HashDiff.diff(a, b, :case_insensitive => true)
+      diff.should == [['~', 'b', "fizz buzz", "fizzBuzz"]]
+    end
+
+    it "should ignore case on nested strings before comparing" do
+      a = { 'a' => { 'x' => "Foo" }, 'b' => ["fizz buzz", "nerf"] }
+      b = { 'a' => { 'x' => "foo" }, 'b' => ["fizzbuzz", "nerf"] }
+      diff = HashDiff.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 'should apply 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 = HashDiff.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 "should apply both filters to strings" do
+      a = { 'a' => " Foo", 'b' => "fizz buzz"}
+      b = { 'a' => "foo", 'b' => "fizzBuzz"}
+      diff = HashDiff.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 'should compare using proc specified in block' do
+      diff = HashDiff.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 'should yield added keys' do
+      x = { 'a' => 'car', 'b' => 'boat'}
+      y = { 'a' => 'car' }
+
+      diff = HashDiff.diff(x, y) do |prefix, obj1, obj2|
+        case prefix
+        when /b/
+          true
+        end
+      end
+      diff.should == []
+    end
+
+    it 'should compare with both proc and :strip when both provided' do
+      diff = HashDiff.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
+  end
+
+  context 'when :array_path is true' do
+    it 'should return the diff path in an array rather than a string' do
+      x = { 'a' => 'foo' }
+      y = { 'a' => 'bar' }
+      diff = HashDiff.diff(x, y, :array_path => true)
+
+      diff.should == [['~', ['a'], 'foo', 'bar']]
+    end
+
+    it 'should show array indexes in paths' do
+      x = { 'a' => [0, 1, 2] }
+      y = { 'a' => [0, 1, 2, 3] }
+
+      diff = HashDiff.diff(x, y, :array_path => true)
+
+      diff.should == [['+', ['a', 3], 3]]
+    end
+
+    it 'should show differences with string and symbol keys' do
+      x = { 'a' => 'foo' }
+      y = { :a => 'bar' }
+
+      diff = HashDiff.diff(x, y, :array_path => true)
+      diff.should == [['-', ['a'], 'foo'], ['+', [:a], 'bar']]
+    end
+
+    it 'should support other key types' do
+      time = Time.now
+      x = { time => 'foo' }
+      y = { 0 => 'bar' }
+
+      diff = HashDiff.diff(x, y, :array_path => true)
+      diff.should == [['-', [time], 'foo'], ['+', [0], 'bar']]
+    end
+  end
+
+  context 'when :use_lcs is false' do
+    it 'should show items in an array as changed' do
+      x = [:a, :b]
+      y = [:c, :d]
+      diff = HashDiff.diff(x, y, :use_lcs => false)
+
+      diff.should == [['~', '[0]', :a, :c], ['~', '[1]', :b, :d]]
+    end
+
+    it 'should show additions to arrays' do
+      x = { :a => [0] }
+      y = { :a => [0, 1] }
+      diff = HashDiff.diff(x, y, :use_lcs => false)
+
+      diff.should == [['+', 'a[1]', 1]]
+    end
+
+    it 'shows changes to nested arrays' do
+      x = { :a => [[0, 1]] }
+      y = { :a => [[1, 2]] }
+      diff = HashDiff.diff(x, y, :use_lcs => false)
+
+      diff.should == [['~', 'a[0][0]', 0, 1], ['~', 'a[0][1]', 1, 2]]
+    end
+  end
+end