hashdiff 0.3.7 → 1.0.1

data/lib/hashdiff/diff.rb

@@ -1,13 +1,15 @@
-module HashDiff
+# 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.
+  # 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
+  #   * :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
@@ -22,27 +24,27 @@ module HashDiff
   # @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 = 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)
-    diffs_1 = diff(obj1, obj2, opts)
-    count_1 = count_diff diffs_1
+    opts = { similarity: 0.3 }.merge!(options)
+    diffs1 = diff(obj1, obj2, opts)
+    count1 = count_diff diffs1
 
-    opts = { :similarity => 0.5 }.merge!(options)
-    diffs_2 = diff(obj1, obj2, opts)
-    count_2 = count_diff diffs_2
+    opts = { similarity: 0.5 }.merge!(options)
+    diffs2 = diff(obj1, obj2, opts)
+    count2 = count_diff diffs2
 
-    opts = { :similarity => 0.8 }.merge!(options)
-    diffs_3 = diff(obj1, obj2, opts)
-    count_3 = count_diff diffs_3
+    opts = { similarity: 0.8 }.merge!(options)
+    diffs3 = diff(obj1, obj2, opts)
+    count3 = count_diff diffs3
 
-    count, diffs = count_1 < count_2 ? [count_1, diffs_1] : [count_2, diffs_2]
-    diffs = count < count_3 ? diffs : diffs_3
+    count, diffs = count1 < count2 ? [count1, diffs1] : [count2, diffs2]
+    count < count3 ? diffs : diffs3
   end
 
   # Compute the diff of two hashes or arrays
@@ -51,6 +53,7 @@ module HashDiff
   # @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
+  #   * :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.
@@ -68,20 +71,21 @@ module HashDiff
   #   a = {"a" => 1, "b" => {"b1" => 1, "b2" =>2}}
   #   b = {"a" => 1, "b" => {}}
   #
-  #   diff = HashDiff.diff(a, 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,
-      :strip       =>   false,
-      :numeric_tolerance => 0,
-      :array_path  =>   false,
-      :use_lcs     =>   true
+      prefix: '',
+      similarity: 0.8,
+      delimiter: '.',
+      strict: true,
+      indifferent: false,
+      strip: false,
+      numeric_tolerance: 0,
+      array_path: false,
+      use_lcs: true
     }.merge!(options)
 
     opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
@@ -92,120 +96,61 @@ module HashDiff
     result = custom_compare(opts[:comparison], opts[:prefix], obj1, obj2)
     return result if result
 
-    if obj1.nil? and obj2.nil?
-      return []
-    end
+    return [] if obj1.nil? && obj2.nil?
 
-    if obj1.nil?
-      return [['~', opts[:prefix], nil, obj2]]
-    end
+    return [['~', opts[:prefix], obj1, obj2]] if obj1.nil? || obj2.nil?
 
-    if obj2.nil?
-      return [['~', opts[:prefix], obj1, nil]]
-    end
+    return [['~', opts[:prefix], obj1, obj2]] unless comparable?(obj1, obj2, opts[:strict])
 
-    unless comparable?(obj1, obj2, opts[:strict])
-      return [['~', opts[:prefix], obj1, obj2]]
-    end
+    return LcsCompareArrays.call(obj1, obj2, opts) if obj1.is_a?(Array) && opts[:use_lcs]
 
-    result = []
-    if obj1.is_a?(Array) && opts[:use_lcs]
-      changeset = diff_array_lcs(obj1, obj2, opts) do |lcs|
-        # use a's index for similarity
-        lcs.each do |pair|
-          prefix = prefix_append_array_index(opts[:prefix], pair[0], opts)
-          result.concat(diff(obj1[pair[0]], obj2[pair[1]], opts.merge(:prefix => prefix)))
-        end
-      end
+    return LinearCompareArray.call(obj1, obj2, opts) if obj1.is_a?(Array) && !opts[:use_lcs]
 
-      changeset.each do |change|
-        change_key = prefix_append_array_index(opts[:prefix], change[1], opts)
-        if change[0] == '-'
-          result << ['-', change_key, change[2]]
-        elsif change[0] == '+'
-          result << ['+', change_key, change[2]]
-        end
-      end
-    elsif obj1.is_a?(Array) && !opts[:use_lcs]
-      result.concat(LinearCompareArray.call(obj1, obj2, opts))
-    elsif obj1.is_a?(Hash)
-
-      deleted_keys = obj1.keys - obj2.keys
-      common_keys = obj1.keys & obj2.keys
-      added_keys = obj2.keys - obj1.keys
-
-      # add deleted properties
-      deleted_keys.sort_by{|k,v| k.to_s }.each do |k|
-        change_key = prefix_append_key(opts[:prefix], k, opts)
-        custom_result = custom_compare(opts[:comparison], change_key, obj1[k], nil)
-
-        if custom_result
-          result.concat(custom_result)
-        else
-          result << ['-', change_key, obj1[k]]
-        end
-      end
-
-      # recursive comparison for common keys
-      common_keys.sort_by{|k,v| k.to_s }.each do |k|
-        prefix = prefix_append_key(opts[:prefix], k, opts)
-        result.concat(diff(obj1[k], obj2[k], opts.merge(:prefix => prefix)))
-      end
+    return CompareHashes.call(obj1, obj2, opts) if obj1.is_a?(Hash)
 
-      # added properties
-      added_keys.sort_by{|k,v| k.to_s }.each do |k|
-        change_key = prefix_append_key(opts[:prefix], k, opts)
-        unless obj1.key?(k)
-          custom_result = custom_compare(opts[:comparison], change_key, nil, obj2[k])
-
-          if custom_result
-            result.concat(custom_result)
-          else
-            result << ['+', change_key, obj2[k]]
-          end
-        end
-      end
-    else
-      return [] if compare_values(obj1, obj2, opts)
-      return [['~', opts[:prefix], obj1, obj2]]
-    end
+    return [] if compare_values(obj1, obj2, opts)
 
-    result
+    [['~', opts[:prefix], obj1, obj2]]
   end
 
   # @private
   #
   # diff array using LCS algorithm
-  def self.diff_array_lcs(a, b, options = {})
-    opts = {
-      :prefix      =>   '',
-      :similarity  =>   0.8,
-      :delimiter   =>   '.'
-    }.merge!(options)
+  def self.diff_array_lcs(arraya, arrayb, options = {})
+    return [] if arraya.empty? && arrayb.empty?
 
     change_set = []
-    if a.size == 0 and b.size == 0
-      return []
-    elsif a.size == 0
-      b.each_index do |index|
-        change_set << ['+', index, b[index]]
+
+    if arraya.empty?
+      arrayb.each_index do |index|
+        change_set << ['+', index, arrayb[index]]
       end
+
       return change_set
-    elsif b.size == 0
-      a.each_index do |index|
-        i = a.size - index - 1
-        change_set << ['-', i, a[i]]
+    end
+
+    if arrayb.empty?
+      arraya.each_index do |index|
+        i = arraya.size - index - 1
+        change_set << ['-', i, arraya[i]]
       end
+
       return change_set
     end
 
-    links = lcs(a, b, opts)
+    opts = {
+      prefix: '',
+      similarity: 0.8,
+      delimiter: '.'
+    }.merge!(options)
+
+    links = lcs(arraya, arrayb, opts)
 
     # yield common
     yield links if block_given?
 
     # padding the end
-    links << [a.size, b.size]
+    links << [arraya.size, arrayb.size]
 
     last_x = -1
     last_y = -1
@@ -213,13 +158,13 @@ module HashDiff
       x, y = pair
 
       # remove from a, beginning from the end
-      (x > last_x + 1) and (x - last_x - 2).downto(0).each do |i|
-        change_set << ['-', last_y + i + 1, a[i + last_x + 1]]
+      (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) and 0.upto(y - last_y - 2).each do |i|
-        change_set << ['+', last_y + i + 1, b[i + last_y + 1]]
+      (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

data/lib/hashdiff/lcs.rb

@@ -1,46 +1,44 @@
-module HashDiff
+# frozen_string_literal: true
+
+module Hashdiff
   # @private
   #
   # caculate array difference using LCS algorithm
   # http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
-  def self.lcs(a, b, options = {})
-    opts = { :similarity => 0.8 }.merge!(options)
+  def self.lcs(arraya, arrayb, options = {})
+    return [] if arraya.empty? || arrayb.empty?
 
-    opts[:prefix] = prefix_append_array_index(opts[:prefix], '*', opts)
+    opts = { similarity: 0.8 }.merge!(options)
 
-    return [] if a.size == 0 or b.size == 0
+    opts[:prefix] = prefix_append_array_index(opts[:prefix], '*', opts)
 
     a_start = b_start = 0
-    a_finish = a.size - 1
-    b_finish = b.size - 1
+    a_finish = arraya.size - 1
+    b_finish = arrayb.size - 1
     vector = []
 
     lcs = []
     (b_start..b_finish).each do |bi|
-      lcs[bi] = [] 
+      lcs[bi] = []
       (a_start..a_finish).each do |ai|
-        if similar?(a[ai], b[bi], opts)
-          topleft = (ai > 0 and bi > 0)? lcs[bi-1][ai-1][1] : 0
+        if similar?(arraya[ai], arrayb[bi], opts)
+          topleft = (ai > 0) && (bi > 0) ? lcs[bi - 1][ai - 1][1] : 0
           lcs[bi][ai] = [:topleft, topleft + 1]
-        elsif
-          top = (bi > 0)? lcs[bi-1][ai][1] : 0
-          left = (ai > 0)? lcs[bi][ai-1][1] : 0
-          count = (top > left) ? top : left
+        elsif (top = bi > 0 ? lcs[bi - 1][ai][1] : 0)
+          left = ai > 0 ? lcs[bi][ai - 1][1] : 0
+          count = top > left ? top : left
 
-          direction = :both
-          if top > left
-            direction = :top
-          elsif top < left
-            direction = :left
-          else
-            if bi == 0
-              direction = :top
-            elsif ai == 0
-              direction = :left
-            else
-              direction = :both
-            end
-          end
+          direction = if top > left
+                        :top
+                      elsif top < left
+                        :left
+                      elsif bi.zero?
+                        :top
+                      elsif ai.zero?
+                        :left
+                      else
+                        :both
+                      end
 
           lcs[bi][ai] = [direction, count]
         end
@@ -49,7 +47,7 @@ module HashDiff
 
     x = a_finish
     y = b_finish
-    while x >= 0 and y >= 0 and lcs[y][x][1] > 0
+    while (x >= 0) && (y >= 0) && (lcs[y][x][1] > 0)
       if lcs[y][x][0] == :both
         x -= 1
       elsif lcs[y][x][0] == :topleft
@@ -65,5 +63,4 @@ module HashDiff
 
     vector
   end
-
 end

data/lib/hashdiff/lcs_compare_arrays.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare arrays using the lcs algorithm
+  class LcsCompareArrays
+    class << self
+      def call(obj1, obj2, opts = {})
+        result = []
+
+        changeset = Hashdiff.diff_array_lcs(obj1, obj2, opts) do |lcs|
+          # use a's index for similarity
+          lcs.each do |pair|
+            prefix = Hashdiff.prefix_append_array_index(opts[:prefix], pair[0], opts)
+
+            result.concat(Hashdiff.diff(obj1[pair[0]], obj2[pair[1]], opts.merge(prefix: prefix)))
+          end
+        end
+
+        changeset.each do |change|
+          next if change[0] != '-' && change[0] != '+'
+
+          change_key = Hashdiff.prefix_append_array_index(opts[:prefix], change[1], opts)
+
+          result << [change[0], change_key, change[2]]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/hashdiff/linear_compare_array.rb

@@ -1,11 +1,13 @@
-module HashDiff
+# frozen_string_literal: true
+
+module Hashdiff
   # @private
   #
   # Used to compare arrays in a linear complexity, which produces longer diffs
   # than using the lcs algorithm but is considerably faster
   class LinearCompareArray
     def self.call(old_array, new_array, options = {})
-      instance = self.new(old_array, new_array, options)
+      instance = new(old_array, new_array, options)
       instance.call
     end
 
@@ -78,8 +80,8 @@ module HashDiff
     end
 
     def item_difference(old_item, new_item, item_index)
-      prefix = HashDiff.prefix_append_array_index(options[:prefix], item_index, options)
-      HashDiff.diff(old_item, new_item, options.merge(:prefix => prefix))
+      prefix = Hashdiff.prefix_append_array_index(options[:prefix], item_index, options)
+      Hashdiff.diff(old_item, new_item, options.merge(prefix: prefix))
     end
 
     # look ahead in the new array to see if the current item appears later
@@ -120,6 +122,7 @@ module HashDiff
 
     def append_addititions_before_match(match_index)
       return unless match_index
+
       (new_index...match_index).each { |i| append_addition(new_array[i], i) }
       self.expected_additions = expected_additions - (match_index - new_index)
       self.new_index = match_index
@@ -127,18 +130,19 @@ module HashDiff
 
     def append_deletions_before_match(match_index)
       return unless match_index
+
       (old_index...match_index).each { |i| append_deletion(old_array[i], i) }
       self.expected_additions = expected_additions + (match_index - new_index)
       self.old_index = match_index
     end
 
     def append_addition(item, index)
-      key = HashDiff.prefix_append_array_index(options[:prefix], index, options)
+      key = Hashdiff.prefix_append_array_index(options[:prefix], index, options)
       additions << ['+', key, item]
     end
 
     def append_deletion(item, index)
-      key = HashDiff.prefix_append_array_index(options[:prefix], index, options)
+      key = Hashdiff.prefix_append_array_index(options[:prefix], index, options)
       deletions << ['-', key, item]
     end
 

data/lib/hashdiff/patch.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 #
 # This module provides methods to diff two hash, patch and unpatch hash
 #
-module HashDiff
-
+module Hashdiff
   # Apply patch to object
   #
   # @param [Hash, Array] obj the object to be patched, can be an Array or a Hash
@@ -22,7 +23,7 @@ module HashDiff
 
       last_part = parts.last
 
-      parent_node = node(obj, parts[0, parts.size-1])
+      parent_node = node(obj, parts[0, parts.size - 1])
 
       if change[0] == '+'
         if parent_node.is_a?(Array)
@@ -63,7 +64,7 @@ module HashDiff
 
       last_part = parts.last
 
-      parent_node = node(obj, parts[0, parts.size-1])
+      parent_node = node(obj, parts[0, parts.size - 1])
 
       if change[0] == '+'
         if parent_node.is_a?(Array)
@@ -84,5 +85,4 @@ module HashDiff
 
     obj
   end
-
 end