hashdiff 0.3.4 → 0.4.0

data/lib/hashdiff/util.rb

@@ -1,21 +1,22 @@
-module HashDiff
+# frozen_string_literal: true
 
+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)
+  def self.similar?(obja, objb, options = {})
+    return compare_values(obja, objb, options) if !options[:comparison] && !any_hash_or_array?(obja, objb)
 
-    count_a = count_nodes(a)
-    count_b = count_nodes(b)
-    diffs = count_diff diff(a, b, opts)
+    count_a = count_nodes(obja)
+    count_b = count_nodes(objb)
 
-    if count_a + count_b == 0
-      return true
-    else
-      (1 - diffs.to_f/(count_a + count_b).to_f) >= opts[:similarity]
-    end
+    return true if (count_a + count_b).zero?
+
+    opts = { similarity: 0.8 }.merge!(options)
+
+    diffs = count_diff diff(obja, objb, opts)
+
+    (1 - diffs.to_f / (count_a + count_b).to_f) >= opts[:similarity]
   end
 
   # @private
@@ -25,7 +26,7 @@ module HashDiff
     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)
+      sum + (old_change_count + new_change_count)
     end
   end
 
@@ -37,9 +38,9 @@ module HashDiff
 
     count = 0
     if obj.is_a?(Array)
-      obj.each {|e| count += count_nodes(e) }
+      obj.each { |e| count += count_nodes(e) }
     elsif obj.is_a?(Hash)
-      obj.each {|k, v| count += count_nodes(v) }
+      obj.each_value { |v| count += count_nodes(v) }
     else
       return 1
     end
@@ -54,20 +55,18 @@ module HashDiff
   # @param [String] delimiter Property-string delimiter
   #
   # e.g. "a.b[3].c" => ['a', 'b', 3, 'c']
-  def self.decode_property_path(path, delimiter='.')
-    parts = path.split(delimiter).collect do |part|
+  def self.decode_property_path(path, delimiter = '.')
+    path.split(delimiter).inject([]) do |memo, part|
       if part =~ /^(.*)\[(\d+)\]$/
-        if $1.size > 0
-          [$1, $2.to_i]
+        if !Regexp.last_match(1).empty?
+          memo + [Regexp.last_match(1), Regexp.last_match(2).to_i]
         else
-          $2.to_i
+          memo + [Regexp.last_match(2).to_i]
         end
       else
-        part
+        memo + [part]
       end
     end
-
-    parts.flatten
   end
 
   # @private
@@ -85,8 +84,8 @@ module HashDiff
   #
   # 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 }
+    if options[:numeric_tolerance].is_a?(Numeric) &&
+       obj1.is_a?(Numeric) && obj2.is_a?(Numeric)
       return (obj1 - obj2).abs <= options[:numeric_tolerance]
     end
 
@@ -107,10 +106,9 @@ module HashDiff
   #
   # 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 (obj1.is_a?(Array) || obj1.is_a?(Hash)) && obj2.is_a?(obj1.class)
     return true if !strict && obj1.is_a?(Numeric) && obj2.is_a?(Numeric)
+
     obj1.is_a?(obj2.class) && obj2.is_a?(obj1.class)
   end
 
@@ -118,15 +116,39 @@ module HashDiff
   #
   # 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
+    return unless method
+
+    res = method.call(key, obj1, obj2)
+
+    # nil != false here
+    return [['~', key, obj1, obj2]] if res == false
+    return [] if res == true
+  end
+
+  def self.prefix_append_key(prefix, key, opts)
+    if opts[:array_path]
+      prefix + [key]
+    else
+      prefix.empty? ? key.to_s : "#{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
+
+  class << self
+    private
+
+    # @private
+    #
+    # checks if both objects are Arrays or Hashes
+    def any_hash_or_array?(obja, objb)
+      obja.is_a?(Array) || obja.is_a?(Hash) || objb.is_a?(Array) || objb.is_a?(Hash)
     end
   end
 end

data/lib/hashdiff/version.rb

@@ -1,3 +1,5 @@
-module HashDiff
-  VERSION = '0.3.4'
+# frozen_string_literal: true
+
+module Hashdiff
+  VERSION = '0.4.0'.freeze
 end

data/lib/hashdiff.rb

@@ -1,5 +1,14 @@
+# frozen_string_literal: true
+
 require 'hashdiff/util'
+require 'hashdiff/compare_hashes'
 require 'hashdiff/lcs'
+require 'hashdiff/lcs_compare_arrays'
+require 'hashdiff/linear_compare_array'
 require 'hashdiff/diff'
 require 'hashdiff/patch'
 require 'hashdiff/version'
+
+HashDiff = Hashdiff
+
+warn '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.'

data/spec/hashdiff/best_diff_spec.rb

@@ -1,65 +1,75 @@
+# frozen_string_literal: true
+
 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}] }
+describe Hashdiff do
+  it 'is 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}]]
+    diff = described_class.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}] }
+  it 'uses 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}]]
+    diff = described_class.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'}] }
+  it 'uses 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|
+    diff = described_class.best_diff(a, b) do |path, obj1, obj2|
       case path
       when /^x\[.\]\..$/
-        obj1.length == obj2.length if obj1 and obj2
+        obj1.length == obj2.length if obj1 && obj2
       end
     end
 
-    diff.should == [["-", "x[0].c", 'goat'], ["+", "x[0].b", 'cow'], ["-", "x[1]", {"y"=>'baz'}]]
+    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()"}
+  it 'is 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()"}
+    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 = described_class.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()"}]
+      ['+', 'menu.popup.menuitem[1]', { 'value' => 'Open', 'onclick' => 'OpenDoc()' }]
     ]
   end
+
+  it 'is 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 = described_class.best_diff(a, b, array_path: true)
+    diff.should == [['-', ['x', 0, 'c'], 3], ['+', ['x', 0, 'b'], 2], ['-', ['x', 1], { 'y' => 3 }]]
+  end
 end

data/spec/hashdiff/diff_array_spec.rb

@@ -1,60 +1,60 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe HashDiff do
-  it "should be able to diff two equal array" do
+describe Hashdiff do
+  it 'is able to diff two equal array' do
     a = [1, 2, 3]
     b = [1, 2, 3]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = described_class.diff_array_lcs(a, b)
     diff.should == []
   end
 
-  it "should be able to diff two arrays with one element in common" do
+  it 'is able to diff two arrays with one element in common' do
     a = [1, 2, 3]
     b = [1, 8, 7]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = described_class.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
+  it 'is able to diff two arrays with nothing in common' do
     a = [1, 2]
     b = []
 
-    diff = HashDiff.diff_array(a, b)
+    diff = described_class.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
+  it 'is able to diff an empty array with an non-empty array' do
     a = []
     b = [1, 2]
 
-    diff = HashDiff.diff_array(a, b)
+    diff = described_class.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
+  it 'is 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(a, b)
+    diff = described_class.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
+  it 'is 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(a, b)
+    diff = described_class.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(a, b)
+  it 'is 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 = described_class.diff_array_lcs(a, b)
     diff.should == [['+', 0, 1], ['-', 2, 3]]
   end
-
 end
-