cloudsmith-api 2.0.6 → 2.0.8

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

@@ -0,0 +1,182 @@
+# 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)
+  #   * :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)
+  #   * :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]] # splat covers single sym/string case
+
+    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.0/lib/hashdiff/version.rb

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

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.1.0/spec/hashdiff/diff_spec.rb

@@ -0,0 +1,375 @@
+# 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