hashdiff_sym 0.3.1

data/spec/hashdiff_sym/patch_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe HashDiffSym 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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == 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}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 3}
+    b = {"a" => {"a1" => 1, "a2" => 2}}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => []}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1, "b" => nil}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => [1, 2]}
+    b = {"a" => 1}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b-b" => [1, 2]}
+    b = {"a" => 1, "b-b" => [2, 1]}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => {}}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
+    b = {"a" => 1, "b" => nil}
+    HashDiffSym.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 = HashDiffSym.diff(a, b)
+
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = {"a" => 1, "b" => nil}
+    b = {"a" => 1}
+    HashDiffSym.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}]
+
+    diff = HashDiffSym.diff(a, b)
+    HashDiffSym.patch!(a, diff).should == b
+
+    a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, 3]
+    b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+    HashDiffSym.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}]
+
+    diff = HashDiffSym.diff(a, b)
+    HashDiffSym.patch!(a, diff).should == 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}]
+    HashDiffSym.unpatch!(b, diff).should == a
+  end
+
+  it "should patch hashes with symbols correctly" do
+    a = {a: 3}
+    b = {a: {a1: 1, a2: 2}}
+    diff = HashDiffSym.diff(a, b)
+    HashDiffSym.patch!(a, diff).should == b
+  end
+end

data/spec/hashdiff_sym/util_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe HashDiffSym do
+  it "should be able to decode property path" do
+    decoded = HashDiffSym.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 = HashDiffSym.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}
+    HashDiffSym.similar?(a, b).should be_truthy
+    HashDiffSym.similar?(a, b, :similarity => 1).should be_falsey
+  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}
+    HashDiffSym.similar?(a, b, :numeric_tolerance => 0.05).should be_truthy
+    HashDiffSym.similar?(a, b).should be_falsey
+  end
+
+  it "should be able to tell numbers and strings" do
+    HashDiffSym.similar?(1, 2).should be_falsey
+    HashDiffSym.similar?("a", "b").should be_falsey
+    HashDiffSym.similar?("a", [1, 2, 3]).should be_falsey
+    HashDiffSym.similar?(1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}).should be_falsey
+  end
+
+  it "should be able to tell true when similarity == 0.5" do
+    a = {"value" => "New1", "onclick" => "CreateNewDoc()"}
+    b = {"value" => "New", "onclick" => "CreateNewDoc()"}
+
+    HashDiffSym.similar?(a, b, :similarity => 0.5).should be_truthy
+  end
+
+  it "should be able to tell false when similarity == 0.5" do
+    a = {"value" => "New1", "onclick" => "open()"}
+    b = {"value" => "New", "onclick" => "CreateNewDoc()"}
+
+    HashDiffSym.similar?(a, b, :similarity => 0.5).should be_falsey
+  end
+
+  describe '.compare_values' do
+    it "should compare numeric values exactly when no tolerance" do
+      expect(HashDiffSym.compare_values(10.004, 10.003)).to be_falsey
+    end
+
+    it "should allow tolerance with numeric values" do
+      expect(HashDiffSym.compare_values(10.004, 10.003, :numeric_tolerance => 0.01)).to be_truthy
+    end
+
+    it "should compare other objects with or without tolerance" do
+      expect(HashDiffSym.compare_values('hats', 'ninjas')).to be_falsey
+      expect(HashDiffSym.compare_values('hats', 'ninjas', :numeric_tolerance => 0.01)).to be_falsey
+      expect(HashDiffSym.compare_values('horse', 'horse')).to be_truthy
+    end
+
+    it 'should compare strings exactly by default' do
+      expect(HashDiffSym.compare_values(' horse', 'horse')).to be_falsey
+      expect(HashDiffSym.compare_values('horse', 'Horse')).to be_falsey
+    end
+
+    it 'should strip strings before comparing when requested' do
+      expect(HashDiffSym.compare_values(' horse', 'horse', :strip => true)).to be_truthy
+    end
+
+    it "should ignore string case when requested" do
+      expect(HashDiffSym.compare_values('horse', 'Horse', :case_insensitive => true)).to be_truthy
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'rspec'
+require 'rspec/autorun'
+
+require 'hashdiff_sym'
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+
+  config.include RSpec::Matchers
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: hashdiff_sym
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Liu Fengyun
+- Alexander Morozov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: 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'
+description: " HashDiffSym is a diff lib to compute the smallest difference between
+  two hashes. "
+email:
+- ntcomp12@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- changelog.md
+- hashdiff_sym.gemspec
+- lib/hashdiff_sym.rb
+- lib/hashdiff_sym/diff.rb
+- lib/hashdiff_sym/lcs.rb
+- lib/hashdiff_sym/patch.rb
+- lib/hashdiff_sym/util.rb
+- lib/hashdiff_sym/version.rb
+- spec/hashdiff_sym/best_diff_spec.rb
+- spec/hashdiff_sym/diff_array_spec.rb
+- spec/hashdiff_sym/diff_spec.rb
+- spec/hashdiff_sym/lcs_spec.rb
+- spec/hashdiff_sym/patch_spec.rb
+- spec/hashdiff_sym/util_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kengho/hashdiff_sym
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: HashDiffSym is a diff lib to compute the smallest difference between two
+  hashes.
+test_files: []