hashdiff 0.3.4 → 0.4.0

data/spec/hashdiff/linear_compare_array_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hashdiff::LinearCompareArray do
+  it 'finds no differences between two empty arrays' do
+    difference = described_class.call([], [])
+    difference.should == []
+  end
+
+  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 '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 'finds no differences between identical arrays' do
+    difference = described_class.call(%i[a b], %i[a b])
+    difference.should == []
+  end
+
+  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 '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 '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 'shows changed items in a hash' do
+    difference = described_class.call([{ a: :b }], [{ a: :c }])
+    difference.should == [['~', '[0].a', :b, :c]]
+  end
+
+  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,161 +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 '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)
+
+    expect(described_class.patch!(a, diff)).to eq(b)
+
+    a = { 'a' => 1, 'b' => 1 }
+    b = { 'a' => 1, 'b' => 2 }
+    described_class.unpatch!(b, diff).should == a
+  end
 
+  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)
+
+    expect(described_class.patch!(a, diff)).to eq(b)
+
+    a = { 'a' => 1, :a => 2, 0 => 3 }
+    b = { 'a' => 5, :a => 6, 0 => 7 }
+    described_class.unpatch!(b, diff).should == a
+  end
 end

data/spec/hashdiff/util_spec.rb

@@ -1,78 +1,95 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe HashDiff do
-  it "should be able to decode property path" do
-    decoded = HashDiff.send(:decode_property_path, "a.b[0].c.city[5]")
+describe Hashdiff do
+  it 'is able to decode property path' do
+    decoded = described_class.send(:decode_property_path, 'a.b[0].c.city[5]')
     decoded.should == ['a', 'b', 0, 'c', 'city', 5]
   end
 
-  it "should be able to decode property path with custom delimiter" do
-    decoded = HashDiff.send(:decode_property_path, "a\tb[0]\tc\tcity[5]", "\t")
+  it 'is able to decode property path with custom delimiter' do
+    decoded = described_class.send(:decode_property_path, "a\tb[0]\tc\tcity[5]", "\t")
     decoded.should == ['a', 'b', 0, 'c', 'city', 5]
   end
 
-  it "should be able to tell similiar hash" do
-    a = {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}
-    b = {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}
-    HashDiff.similar?(a, b).should be true
-    HashDiff.similar?(a, b, :similarity => 1).should be false
+  it 'is able to tell similiar hash' do
+    a = { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }
+    b = { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }
+    described_class.similar?(a, b).should be true
+    described_class.similar?(a, b, similarity: 1).should be false
+  end
+
+  it 'is able to tell similiar empty hash' do
+    described_class.similar?({}, {}, similarity: 1).should be true
+  end
+
+  it 'is able to tell similiar empty array' do
+    described_class.similar?([], [], similarity: 1).should be true
   end
 
-  it "should be able to tell similiar hash with values within tolerance" do
-    a = {'a' => 1.5, 'b' => 2.25, 'c' => 3, 'd' => 4, 'e' => 5}
-    b = {'a' => 1.503, 'b' => 2.22, 'c' => 3, 'e' => 5}
-    HashDiff.similar?(a, b, :numeric_tolerance => 0.05).should be true
-    HashDiff.similar?(a, b).should be false
+  it 'is able to tell similiar hash with values within tolerance' do
+    a = { 'a' => 1.5, 'b' => 2.25, 'c' => 3, 'd' => 4, 'e' => 5 }
+    b = { 'a' => 1.503, 'b' => 2.22, 'c' => 3, 'e' => 5 }
+    described_class.similar?(a, b, numeric_tolerance: 0.05).should be true
+    described_class.similar?(a, b).should be false
   end
 
-  it "should be able to tell numbers and strings" do
-    HashDiff.similar?(1, 2).should be false
-    HashDiff.similar?("a", "b").should be false
-    HashDiff.similar?("a", [1, 2, 3]).should be false
-    HashDiff.similar?(1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}).should be false
+  it 'is able to tell numbers and strings' do
+    described_class.similar?(1, 2).should be false
+    described_class.similar?('a', 'b').should be false
+    described_class.similar?('a', [1, 2, 3]).should be false
+    described_class.similar?(1, 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5).should be false
   end
 
-  it "should be able to tell true when similarity == 0.5" do
-    a = {"value" => "New1", "onclick" => "CreateNewDoc()"}
-    b = {"value" => "New", "onclick" => "CreateNewDoc()"}
+  it 'is able to tell true when similarity == 0.5' do
+    a = { 'value' => 'New1', 'onclick' => 'CreateNewDoc()' }
+    b = { 'value' => 'New', 'onclick' => 'CreateNewDoc()' }
 
-    HashDiff.similar?(a, b, :similarity => 0.5).should be true
+    described_class.similar?(a, b, similarity: 0.5).should be true
   end
 
-  it "should be able to tell false when similarity == 0.5" do
-    a = {"value" => "New1", "onclick" => "open()"}
-    b = {"value" => "New", "onclick" => "CreateNewDoc()"}
+  it 'is able to tell false when similarity == 0.5' do
+    a = { 'value' => 'New1', 'onclick' => 'open()' }
+    b = { 'value' => 'New', 'onclick' => 'CreateNewDoc()' }
 
-    HashDiff.similar?(a, b, :similarity => 0.5).should be false
+    described_class.similar?(a, b, similarity: 0.5).should be false
   end
 
   describe '.compare_values' do
-    it "should compare numeric values exactly when no tolerance" do
-      expect(HashDiff.compare_values(10.004, 10.003)).to be false
+    it 'compares numeric values exactly when no tolerance' do
+      expect(described_class.compare_values(10.004, 10.003)).to be false
     end
 
-    it "should allow tolerance with numeric values" do
-      expect(HashDiff.compare_values(10.004, 10.003, :numeric_tolerance => 0.01)).to be true
+    it 'allows tolerance with numeric values' do
+      expect(described_class.compare_values(10.004, 10.003, numeric_tolerance: 0.01)).to be true
     end
 
-    it "should compare other objects with or without tolerance" do
-      expect(HashDiff.compare_values('hats', 'ninjas')).to be false
-      expect(HashDiff.compare_values('hats', 'ninjas', :numeric_tolerance => 0.01)).to be false
-      expect(HashDiff.compare_values('horse', 'horse')).to be true
+    it 'compares different objects without tolerance' do
+      expect(described_class.compare_values('hats', 'ninjas')).to be false
+    end
+    it 'compares other objects with tolerance' do
+      expect(described_class.compare_values('hats', 'ninjas', numeric_tolerance: 0.01)).to be false
+    end
+
+    it 'compares same objects without tolerance' do
+      expect(described_class.compare_values('horse', 'horse')).to be true
     end
 
-    it 'should compare strings exactly by default' do
-      expect(HashDiff.compare_values(' horse', 'horse')).to be false
-      expect(HashDiff.compare_values('horse', 'Horse')).to be false
+    it 'compares strings for spaces exactly by default' do
+      expect(described_class.compare_values(' horse', 'horse')).to be false
     end
 
-    it 'should strip strings before comparing when requested' do
-      expect(HashDiff.compare_values(' horse', 'horse', :strip => true)).to be true
+    it 'compares strings for capitalization exactly by default' do
+      expect(described_class.compare_values('horse', 'Horse')).to be false
     end
 
-    it "should ignore string case when requested" do
-      expect(HashDiff.compare_values('horse', 'Horse', :case_insensitive => true)).to be true
+    it 'strips strings before comparing when requested' do
+      expect(described_class.compare_values(' horse', 'horse', strip: true)).to be true
     end
 
+    it 'ignores string case when requested' do
+      expect(described_class.compare_values('horse', 'Horse', case_insensitive: true)).to be true
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rubygems'

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-01 00:00:00.000000000 Z
+date: 2019-05-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bluecloth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -25,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +53,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bluecloth
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: " HashDiff is a diff lib to compute the smallest difference between two
+description: " Hashdiff is a diff lib to compute the smallest difference between two
   hashes. "
 email:
 - liufengyunchina@gmail.com
@@ -62,6 +90,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - ".yardopts"
 - Gemfile
@@ -71,8 +100,11 @@ files:
 - changelog.md
 - hashdiff.gemspec
 - lib/hashdiff.rb
+- lib/hashdiff/compare_hashes.rb
 - lib/hashdiff/diff.rb
 - lib/hashdiff/lcs.rb
+- lib/hashdiff/lcs_compare_arrays.rb
+- lib/hashdiff/linear_compare_array.rb
 - lib/hashdiff/patch.rb
 - lib/hashdiff/util.rb
 - lib/hashdiff/version.rb
@@ -80,14 +112,22 @@ files:
 - spec/hashdiff/diff_array_spec.rb
 - spec/hashdiff/diff_spec.rb
 - spec/hashdiff/lcs_spec.rb
+- spec/hashdiff/linear_compare_array_spec.rb
 - spec/hashdiff/patch_spec.rb
 - spec/hashdiff/util_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/liufengyun/hashdiff
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/liufengyun/hashdiff/issues
+  changelog_uri: https://github.com/liufengyun/hashdiff/blob/master/changelog.md
+  documentation_uri: https://www.rubydoc.info/gems/hashdiff
+  homepage_uri: https://github.com/liufengyun/hashdiff
+  source_code_uri: https://github.com/liufengyun/hashdiff
+post_install_message: The HashDiff constant used by this gem conflicts with another
+  gem of a similar name.  As of version 1.0 the HashDiff constant will be completely
+  removed and replaced by Hashdiff.  For more information see https://github.com/liufengyun/hashdiff/issues/45.
 rdoc_options: []
 require_paths:
 - lib
@@ -95,7 +135,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -103,9 +143,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
-summary: HashDiff is a diff lib to compute the smallest difference between two hashes.
+summary: Hashdiff is a diff lib to compute the smallest difference between two hashes.
 test_files: []
-has_rdoc: