hashdiff 0.3.7 → 1.0.1

data/spec/hashdiff/lcs_spec.rb

@@ -1,75 +1,76 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe HashDiff do
-  it "should be able to find LCS between two equal array" do
+describe Hashdiff do
+  it 'is able to find LCS between two equal array' do
     a = [1, 2, 3]
     b = [1, 2, 3]
 
-    lcs = HashDiff.lcs(a, b)
+    lcs = described_class.lcs(a, b)
     lcs.should == [[0, 0], [1, 1], [2, 2]]
   end
 
-  it "should be able to find LCS between two close arrays" do
+  it 'is able to find LCS between two close arrays' do
     a = [1.05, 2, 3.25]
     b = [1.06, 2, 3.24]
 
-    lcs = HashDiff.lcs(a, b, :numeric_tolerance => 0.1)
+    lcs = described_class.lcs(a, b, numeric_tolerance: 0.1)
     lcs.should == [[0, 0], [1, 1], [2, 2]]
   end
 
-  it "should strip strings when finding LCS if requested" do
-    a = ['foo', 'bar', 'baz']
+  it 'strips strings when finding LCS if requested' do
+    a = %w[foo bar baz]
     b = [' foo', 'bar', 'zab']
 
-    lcs = HashDiff.lcs(a, b, :strip => true)
+    lcs = described_class.lcs(a, b, strip: true)
     lcs.should == [[0, 0], [1, 1]]
   end
 
-  it "should be able to find LCS with one common elements" do
+  it 'is able to find LCS with one common elements' do
     a = [1, 2, 3]
     b = [1, 8, 7]
 
-    lcs = HashDiff.lcs(a, b)
+    lcs = described_class.lcs(a, b)
     lcs.should == [[0, 0]]
   end
 
-  it "should be able to find LCS with two common elements" do
+  it 'is able to find LCS with two common elements' do
     a = [1, 3, 5, 7]
     b = [2, 3, 7, 5]
 
-    lcs = HashDiff.lcs(a, b)
+    lcs = described_class.lcs(a, b)
     lcs.should == [[1, 1], [2, 3]]
   end
 
-  it "should be able to find LCS with two close elements" do
+  it 'is able to find LCS with two close elements' do
     a = [1, 3.05, 5, 7]
     b = [2, 3.06, 7, 5]
 
-    lcs = HashDiff.lcs(a, b, :numeric_tolerance => 0.1)
+    lcs = described_class.lcs(a, b, numeric_tolerance: 0.1)
     lcs.should == [[1, 1], [2, 3]]
   end
 
-  it "should be able to find LCS with two common elements in different ordering" do
+  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 = HashDiff.lcs(a, b)
+    lcs = described_class.lcs(a, b)
     lcs.should == [[1, 1], [3, 2]]
   end
 
-  it "should be able to find LCS with a similarity value" do
+  it 'is able to find LCS with a similarity value' do
     a = [
-          {"value" => "New", "onclick" => "CreateNewDoc()"},
-          {"value" => "Close", "onclick" => "CloseDoc()"}
-        ]
+      { 'value' => 'New', 'onclick' => 'CreateNewDoc()' },
+      { 'value' => 'Close', 'onclick' => 'CloseDoc()' }
+    ]
     b = [
-          {"value" => "New1", "onclick" => "CreateNewDoc()"},
-          {"value" => "Open", "onclick" => "OpenDoc()"},
-          {"value" => "Close", "onclick" => "CloseDoc()"}
-        ]
+      { 'value' => 'New1', 'onclick' => 'CreateNewDoc()' },
+      { 'value' => 'Open', 'onclick' => 'OpenDoc()' },
+      { 'value' => 'Close', 'onclick' => 'CloseDoc()' }
+    ]
 
-    lcs = HashDiff.lcs(a, b, :similarity => 0.5)
+    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,48 +1,50 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe HashDiff::LinearCompareArray do
-  it "should find no differences between two empty arrays" do
+describe Hashdiff::LinearCompareArray do
+  it 'finds no differences between two empty arrays' do
     difference = described_class.call([], [])
     difference.should == []
   end
 
-  it "should find added items when the old array is empty" do
-    difference = described_class.call([], [:a, :b])
+  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 "should find removed items when the new array is empty" do
-    difference = described_class.call([:a, :b], [])
+  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 "should find no differences between identical arrays" do
-    difference = described_class.call([:a, :b], [:a, :b])
+  it 'finds no differences between identical arrays' do
+    difference = described_class.call(%i[a b], %i[a b])
     difference.should == []
   end
 
-  it "should find added items in an array" do
-    difference = described_class.call([:a, :d], [:a, :b, :c, :d])
+  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 "should find removed items in an array" do
-    difference = described_class.call([:a, :b, :c, :d, :e, :f], [:a, :d, :f])
+  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 "should show additions and deletions as changed items" do
-    difference = described_class.call([:a, :b, :c], [:c, :b, :a])
+  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 "should show changed items in a hash" do
-    difference = described_class.call([{ :a => :b }], [{ :a => :c }])
+  it 'shows changed items in a hash' do
+    difference = described_class.call([{ a: :b }], [{ a: :c }])
     difference.should == [['~', '[0].a', :b, :c]]
   end
 
-  it "should show changed items and added items" do
-    difference = described_class.call([{ :a => 1, :b => 2 }], [{ :a => 2, :b => 2 }, :item])
+  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,183 +1,185 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe HashDiff do
-  it "it should be 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 = HashDiff.diff(a, b)
+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)
 
-    HashDiff.patch!(a, diff).should == 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}
-    HashDiff.unpatch!(b, diff).should == a
+    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 "should be able to patch value type changes" do
-    a = {"a" => 3}
-    b = {"a" => {"a1" => 1, "a2" => 2}}
-    diff = HashDiff.diff(a, b)
+  it 'is able to patch value type changes' do
+    a = { 'a' => 3 }
+    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
+    diff = described_class.diff(a, b)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 3}
-    b = {"a" => {"a1" => 1, "a2" => 2}}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 3 }
+    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch value array <=> []" do
-    a = {"a" => 1, "b" => [1, 2]}
-    b = {"a" => 1, "b" => []}
-    diff = HashDiff.diff(a, b)
+  it 'is able to patch value array <=> []' do
+    a = { 'a' => 1, 'b' => [1, 2] }
+    b = { 'a' => 1, 'b' => [] }
+    diff = described_class.diff(a, b)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => [1, 2]}
-    b = {"a" => 1, "b" => []}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => [1, 2] }
+    b = { 'a' => 1, 'b' => [] }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch value array <=> nil" do
-    a = {"a" => 1, "b" => [1, 2]}
-    b = {"a" => 1, "b" => nil}
-    diff = HashDiff.diff(a, b)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => [1, 2]}
-    b = {"a" => 1, "b" => nil}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => [1, 2] }
+    b = { 'a' => 1, 'b' => nil }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch array value removal" do
-    a = {"a" => 1, "b" => [1, 2]}
-    b = {"a" => 1}
-    diff = HashDiff.diff(a, b)
+  it 'is able to patch array value removal' do
+    a = { 'a' => 1, 'b' => [1, 2] }
+    b = { 'a' => 1 }
+    diff = described_class.diff(a, b)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => [1, 2]}
-    b = {"a" => 1}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => [1, 2] }
+    b = { 'a' => 1 }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be 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 = HashDiff.diff(a, b)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b-b" => [1, 2]}
-    b = {"a" => 1, "b-b" => [2, 1]}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b-b' => [1, 2] }
+    b = { 'a' => 1, 'b-b' => [2, 1] }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch hash value removal" do
-    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
-    b = {"a" => 1}
-    diff = HashDiff.diff(a, b)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
-    b = {"a" => 1}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
+    b = { 'a' => 1 }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch value hash <=> {}" do
-    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
-    b = {"a" => 1, "b" => {}}
-    diff = HashDiff.diff(a, b)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
-    b = {"a" => 1, "b" => {}}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
+    b = { 'a' => 1, 'b' => {} }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch value hash <=> nil" do
-    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
-    b = {"a" => 1, "b" => nil}
-    diff = HashDiff.diff(a, b)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
-    b = {"a" => 1, "b" => nil}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
+    b = { 'a' => 1, 'b' => nil }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be able to patch value nil removal" do
-    a = {"a" => 1, "b" => nil}
-    b = {"a" => 1}
-    diff = HashDiff.diff(a, b)
+  it 'is able to patch value nil removal' do
+    a = { 'a' => 1, 'b' => nil }
+    b = { 'a' => 1 }
+    diff = described_class.diff(a, b)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => nil}
-    b = {"a" => 1}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => nil }
+    b = { 'a' => 1 }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be 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}]
+  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 = HashDiff.diff(a, b)
-    HashDiff.patch!(a, diff).should == b
+    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}]
-    HashDiff.unpatch!(b, diff).should == a
+    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 "should be 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}]
+  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 = HashDiff.diff(a, b)
-    HashDiff.patch!(a, diff).should == b
+    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}]
-    HashDiff.unpatch!(b, diff).should == a
+    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 "should be 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 = HashDiff.diff(a, b, :delimiter => "\n")
+  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")
 
-    HashDiff.patch!(a, diff, :delimiter => "\n").should == b
+    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} }
-    HashDiff.unpatch!(b, diff, :delimiter => "\n").should == a
+    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 "should be able to patch when the diff is generated with an array_path" do
-    a = {"a" => 1, "b" => 1}
-    b = {"a" => 1, "b" => 2}
-    diff = HashDiff.diff(a, b, :array_path => true)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, "b" => 1}
-    b = {"a" => 1, "b" => 2}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, 'b' => 1 }
+    b = { 'a' => 1, 'b' => 2 }
+    described_class.unpatch!(b, diff).should == a
   end
 
-  it "should be 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 = HashDiff.diff(a, b, :array_path => true)
+  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)
 
-    HashDiff.patch!(a, diff).should == b
+    expect(described_class.patch!(a, diff)).to eq(b)
 
-    a = {"a" => 1, :a => 2, 0 => 3}
-    b = {"a" => 5, :a => 6, 0 => 7}
-    HashDiff.unpatch!(b, diff).should == a
+    a = { 'a' => 1, :a => 2, 0 => 3 }
+    b = { 'a' => 5, :a => 6, 0 => 7 }
+    described_class.unpatch!(b, diff).should == a
   end
 end