hashdiff 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6af49f121e2b09e5dcdf8a649f6d48c25f63ae03
-  data.tar.gz: c6738c2b03d36f622ac1e0a3c228a863b691ac29
+  metadata.gz: 482b0233e91f747074eada75539247148a14d31d
+  data.tar.gz: 0aba247c54a9e96d433d77ecc76b3e4cf1396075
 SHA512:
-  metadata.gz: 8dfda8cd1b17af2c64ea4626570e7d858b76a5ed918df4b6a5703c63e0ae43c371cbe5e3573b4382aa1491915f48335e62d3b4300f3c678660f329f39e8d9b62
-  data.tar.gz: 71ab91ba878e19c436dbad30cc08c85645aadf6aabeed889dc8e3661102d2ddf5a98b12c7a6a8b1007a5115f64e082829f88d99abe11ad87f2a69cf504f28885
+  metadata.gz: 10fe5b5b37c1a80d317d509b133a880211723ff4b184e892678eb7211de5bcf41b27d482151237052efabd6c9eee336507d5df4f19e2b0e727de970e47280cb4
+  data.tar.gz: 22baf87f78115a872a6df5600b8a31c2d8e3c35991ca114aff60a89af70d29b530f3771386d8bb67578324884f30291e120ed418f78c2768baa746e456f65d71

data/.rubocop.yml

@@ -0,0 +1,21 @@
+require: rubocop-rspec
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/LineLength:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+RSpec/ExampleLength:
+  Enabled: false

data/.travis.yml

@@ -1,13 +1,10 @@
 sudo: false
 language: ruby
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.10
   - 2.2.8
   - 2.3.4
   - 2.4.2
-script: "bundle exec rake spec"
-
-before_install:
-  - gem install bundler
+  - 2.5.3
+  - 2.6.0

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 gemspec
 
 group :test do

data/README.md

@@ -1,4 +1,4 @@
-# HashDiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.png)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.png)](http://badge.fury.io/rb/hashdiff)
+# HashDiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.svg)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.svg)](http://badge.fury.io/rb/hashdiff)
 
 HashDiff is a ruby library to compute the smallest difference between two hashes.
 

data/Rakefile

@@ -1,13 +1,16 @@
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'rubocop/rake_task'
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 
-task :default => :spec
+RuboCop::RakeTask.new
+
+task default: %w[spec rubocop]
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = "./spec/**/*_spec.rb"
+  spec.pattern = './spec/**/*_spec.rb'
 end
-

data/changelog.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## v0.3.8 2018-12-30
+
+* Add Rubocop and drops Ruby 1.9 support #47
+
 ## v0.3.7 2017-10-08
 
 * remove 1.8.7 support from gemspec #39

data/hashdiff.gemspec

@@ -1,25 +1,27 @@
-$LOAD_PATH << File.expand_path("../lib", __FILE__)
+$LOAD_PATH << File.expand_path('lib', __dir__)
 require 'hashdiff/version'
 
 Gem::Specification.new do |s|
-  s.name        = %q{hashdiff}
+  s.name        = 'hashdiff'
   s.version     = HashDiff::VERSION
   s.license     = 'MIT'
-  s.summary     = %q{ HashDiff is a diff lib to compute the smallest difference between two hashes. }
-  s.description = %q{ HashDiff is a diff lib to compute the smallest difference between two hashes. }
+  s.summary     = ' HashDiff is a diff lib to compute the smallest difference between two hashes. '
+  s.description = ' HashDiff is a diff lib to compute the smallest difference between two hashes. '
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- Appraisals {spec}/*`.split("\n")
 
   s.require_paths = ['lib']
-  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+  s.required_ruby_version = Gem::Requirement.new('>= 1.9.3')
 
-  s.authors = ["Liu Fengyun"]
-  s.email   = ["liufengyunchina@gmail.com"]
+  s.authors = ['Liu Fengyun']
+  s.email   = ['liufengyunchina@gmail.com']
 
-  s.homepage = "https://github.com/liufengyun/hashdiff"
+  s.homepage = 'https://github.com/liufengyun/hashdiff'
 
-  s.add_development_dependency("rspec",    "~> 2.0")
-  s.add_development_dependency("yard")
-  s.add_development_dependency("bluecloth")
+  s.add_development_dependency('bluecloth')
+  s.add_development_dependency('rspec', '~> 2.0')
+  s.add_development_dependency('rubocop')
+  s.add_development_dependency('rubocop-rspec')
+  s.add_development_dependency('yard')
 end

data/lib/hashdiff/diff.rb

@@ -1,5 +1,4 @@
 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.
@@ -29,20 +28,20 @@ module HashDiff
   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
@@ -74,14 +73,14 @@ module HashDiff
   # @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,
+      strip: false,
+      numeric_tolerance: 0,
+      array_path: false,
+      use_lcs: true
     }.merge!(options)
 
     opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''
@@ -92,21 +91,13 @@ 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], nil, obj2]] if obj1.nil?
 
-    if obj2.nil?
-      return [['~', opts[:prefix], obj1, nil]]
-    end
+    return [['~', opts[:prefix], obj1, nil]] if obj2.nil?
 
-    unless comparable?(obj1, obj2, opts[:strict])
-      return [['~', opts[:prefix], obj1, obj2]]
-    end
+    return [['~', opts[:prefix], obj1, obj2]] unless comparable?(obj1, obj2, opts[:strict])
 
     result = []
     if obj1.is_a?(Array) && opts[:use_lcs]
@@ -114,7 +105,7 @@ module HashDiff
         # 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)))
+          result.concat(diff(obj1[pair[0]], obj2[pair[1]], opts.merge(prefix: prefix)))
         end
       end
 
@@ -135,7 +126,7 @@ module HashDiff
       added_keys = obj2.keys - obj1.keys
 
       # add deleted properties
-      deleted_keys.sort_by{|k,v| k.to_s }.each do |k|
+      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)
 
@@ -147,26 +138,27 @@ module HashDiff
       end
 
       # recursive comparison for common keys
-      common_keys.sort_by{|k,v| k.to_s }.each do |k|
+      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)))
+        result.concat(diff(obj1[k], obj2[k], opts.merge(prefix: prefix)))
       end
 
       # added properties
-      added_keys.sort_by{|k,v| k.to_s }.each do |k|
+      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
+        next if 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
     else
       return [] if compare_values(obj1, obj2, opts)
+
       return [['~', opts[:prefix], obj1, obj2]]
     end
 
@@ -176,36 +168,36 @@ module HashDiff
   # @private
   #
   # diff array using LCS algorithm
-  def self.diff_array_lcs(a, b, options = {})
+  def self.diff_array_lcs(arraya, arrayb, options = {})
     opts = {
-      :prefix      =>   '',
-      :similarity  =>   0.8,
-      :delimiter   =>   '.'
+      prefix: '',
+      similarity: 0.8,
+      delimiter: '.'
     }.merge!(options)
 
     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]]
+    return [] if arraya.empty? && arrayb.empty?
+
+    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]]
+    elsif 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)
+    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 +205,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

@@ -3,44 +3,40 @@ module HashDiff
   #
   # 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 = {})
+    opts = { similarity: 0.8 }.merge!(options)
 
     opts[:prefix] = prefix_append_array_index(opts[:prefix], '*', opts)
 
-    return [] if a.size == 0 or b.size == 0
+    return [] if arraya.empty? || arrayb.empty?
 
     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 +45,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 +61,4 @@ module HashDiff
 
     vector
   end
-
 end

data/lib/hashdiff/linear_compare_array.rb

@@ -5,7 +5,7 @@ module HashDiff
   # 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
 
@@ -79,7 +79,7 @@ module HashDiff
 
     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))
+      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 +120,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,6 +128,7 @@ 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