hash_deep_diff 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddbaa8e8f12ba99330973c609c00ab710e9fa39b369797b80dd46f24aa6740e1
-  data.tar.gz: 6a5954a960ca0876cdb9e28f3e535be687de5596ed07be61581102b75b178ab4
+  metadata.gz: dc574fc78f743f8b629ecbb87baebea7e75789d99401f7e54691ad02469572ec
+  data.tar.gz: 0f378780b1f08173779e3684a8d42361c0532411c7972952a626bc3e4a0bebb0
 SHA512:
-  metadata.gz: af66a50e5a7eb848c96b757e8e37a4d767868de6fd96ebfd4f528085111e2fe1c9e39215b8514d534d33f94cfc4c024c5c2bba1813acad729fa906e18eee796a
-  data.tar.gz: 358e25298ee3c42ea469e44113fe62935ec8f564c4111c52e170bd25764d99cc4b71c42d154689ad2a9c54ff21f9359dad57cfbd450677853eb60655b90aecf4
+  metadata.gz: dd12f9bc333f1a8ab3d4967bcdaeee7eac9cf66a97883a122cfa3f3e831165da62cce4b4dadf0e5e3c750cc43dcd59629b20c279d215b42ebd2d6fd65ebcc497
+  data.tar.gz: 64b6e8dbf48807f23ca32e84cfec991e14ff56ffda7bb65b71a1db3bc7d800ca0f94f00038e49dc1cd2bd30b84ad6c05496de599038d97960dece9f827cde4fb

data/CHANGELOG.md

@@ -0,0 +1 @@
+Changes will be recorded for version 1.0.0 and later

data/README.md

@@ -5,7 +5,9 @@ Status](https://img.shields.io/github/workflow/status/bpohoriletz/hash_deep_diff
 ![GitHub](https://img.shields.io/github/license/bpohoriletz/hash_deep_diff)
 
 
-Find the exact difference between two Hash objects and build a report to visualize it
+Find the exact difference between two Hash objects and build a report to visualize it. Works for other objects too but why would you do that :/
+
+Alternative solutions [hashdiff by liufengyun](https://github.com/liufengyun/hashdiff) and [hash_hdiff by CodingZeal](https://github.com/CodingZeal/hash_diff)
 
 ## Installation
 
@@ -37,7 +39,7 @@ HashDeepDiff::Comparison.new(left, right).report
 + left[a] = b
 ```
 please see [Documentation](https://rdoc.info/gems/hash_deep_diff/HashDeepDiff/Comparison) for
-more information 
+more information or [Reporting test](https://github.com/bpohoriletz/hash_deep_diff/blob/a525d239189b0310aec3741dfc4862834805252d/test/integration/locales/test_uk_ru.rb#L59)
 
 ## Customization
 

data/hash_deep_diff.gemspec

@@ -49,6 +49,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-focus', '~> 1.3.1'
   spec.add_development_dependency 'minitest-reporters', '~> 1.5.0'
   spec.add_development_dependency 'naught', '~> 1.1.0'
+  spec.add_development_dependency 'pry-byebug', '~> 3.9.0'
   spec.add_development_dependency 'rake', '~> 10.5.0'
   spec.add_development_dependency 'rubocop', '~> 1.26.1'
   spec.add_development_dependency 'rubocop-minitest', '~> 0.18.0'

data/lib/hash_deep_diff/comparison.rb

@@ -63,6 +63,7 @@ module HashDeepDiff
     def left(key = NO_VALUE)
       return NO_VALUE if @left == NO_VALUE
       return @left if key == NO_VALUE
+      return @left unless left.respond_to?(:to_hash)
 
       @left[key] || NO_VALUE
     end
@@ -71,6 +72,7 @@ module HashDeepDiff
     def right(key = NO_VALUE)
       return NO_VALUE if @right == NO_VALUE
       return @right if key == NO_VALUE
+      return @right unless right.respond_to?(:to_hash)
 
       @right[key] || NO_VALUE
     end
@@ -98,22 +100,19 @@ module HashDeepDiff
       common_keys.each_with_object([]) do |key, memo|
         next if values_equal?(key)
 
-        memo << delta(key: key)
-      end
+        memo.append(delta(key: key))
+      end.flatten
     end
 
     # depending on circumstances will return necessary comparisons
     # @return [Array<HashDeepDiff::Delta>]
     def inward_comparison(complex_delta)
       if complex_delta.partial?
-        [
-          complex_delta.placebo,
-          comparison(delta: complex_delta, modifier: :right).diff,
-          comparison(delta: complex_delta, modifier: :left).diff
-        ].compact.flatten
-        # TOFIX add test an drop flatten
+        complex_delta.placebo +
+          comparison(delta: complex_delta, modifier: :addition).map(&:diff).flatten +
+          comparison(delta: complex_delta, modifier: :deletion).map(&:diff).flatten
       else
-        comparison(delta: complex_delta).diff
+        comparison(delta: complex_delta).map(&:diff).flatten
       end
     end
 

data/lib/hash_deep_diff/delta.rb

@@ -16,29 +16,45 @@ module HashDeepDiff
     attr_reader :change_key
 
     # an indication that nested Hash was deleted/added
-    # @return [HashDeepDiff::Delta, NilClass]
+    # @return [Array<HashDeepDiff::Delta>]
     def placebo
-      return nil unless partial?
+      placebo = simple_left? ? { left: NO_VALUE, right: placebo_elment } : { left: placebo_elment, right: NO_VALUE }
 
-      placebo = simple_left? ? { left: NO_VALUE, right: {} } : { left: {}, right: NO_VALUE }
+      [self.class.new(change_key: change_key, value: placebo)]
+    end
+
+    # true if any value is an +Array+ with hashes
+    # @return [TrueClass, FalseClass]
+    def complex?
+      complex_left? || complex_right?
+    end
+
+    # true if right part is an +Array+ with hashes
+    # @return [TrueClass, FalseClass]
+    def complex_right?
+      right.respond_to?(:to_ary) && right.any? { |el| el.respond_to?(:to_hash) }
+    end
 
-      self.class.new(change_key: change_key, value: placebo)
+    # true if left part is an +Array+ with hashes
+    # @return [TrueClass, FalseClass]
+    def complex_left?
+      left.respond_to?(:to_ary) && left.any? { |el| el.respond_to?(:to_hash) }
     end
 
     # true if at least one of the values is a Hash
-    # @return [Bool]
+    # @return [TrueClass, FalseClass]
     def partial?
-      !composite? && !simple?
+      !composite? && !simple? && !complex_left? && !complex_right?
     end
 
     # true if both valus are Hashes
-    # @return [Bool]
+    # @return [TrueClass, FalseClass]
     def composite?
       !simple_left? && !simple_right?
     end
 
     # true if none of the values is a Hash
-    # @return [Bool]
+    # @return [TrueClass, FalseClass]
     def simple?
       simple_left? && simple_right?
     end
@@ -76,16 +92,24 @@ module HashDeepDiff
       @change_key = change_key
     end
 
-    # Returns true if left value has no nested Hashes
-    # @return [Bool]
+    # an indication of added/removed nested Hash
+    # @return [Array, Hash]
+    def placebo_elment
+      return [{}] if complex_left? || complex_right?
+
+      return {}
+    end
+
+    # true if left value has no nested Hashes
+    # @return [TrueClass, FalseClass]
     def simple_left?
-      !left.respond_to?(:to_hash)
+      !left.respond_to?(:to_hash) && !complex_left?
     end
 
-    # Returns true if right value has no nested Hashes
-    # @return [Bool]
+    # true if right value has no nested Hashes
+    # @return [TrueClass, FalseClass]
     def simple_right?
-      !right.respond_to?(:to_hash)
+      !right.respond_to?(:to_hash) && !complex_right?
     end
   end
 end

data/lib/hash_deep_diff/factories/comparison.rb

@@ -8,50 +8,83 @@ module HashDeepDiff
     # Factory for {HashDeepDiff::Comparison}
     class Comparison
       extend Forwardable
-      def_delegators :delta, :left, :right, :change_key
+
+      def_delegators :delta, :left, :right, :change_key, :complex?, :complex_left?, :complex_right?
 
       # factory function
-      # @return [Comparison]
-      def comparison(delta:, modifier: nil)
+      # @return [HashDeepDiff::Comparison]
+      def comparison(delta:, modifier: :change)
         @delta = delta
 
-        case modifier
-        when nil
-          full_compare
-        when :left
-          compare_left
-        when :right
-          compare_right
+        fragments(modifier).map do |(left, right, change_key)|
+          HashDeepDiff::Comparison.new(left, right, change_key,
+                                       delta_engine: delta.class,
+                                       reporting_engine: reporting_engine)
         end
       end
 
       private
 
+      # @!attribute [r] reporting_engine
+      #    @return [HashDeepDiff::Reports::Base] descendant of
+      # @!attribute [r] delta
+      #    @return [HashDeepDiff::Delta]
       attr_reader :reporting_engine, :delta
 
       def initialize(reporting_engine:)
         @reporting_engine = reporting_engine
       end
 
-      # compare two hashes
-      def full_compare
-        HashDeepDiff::Comparison.new(left, right, change_key,
-                                     delta_engine: delta.class,
-                                     reporting_engine: reporting_engine)
+      # entities for further comparison
+      # @return [Array]
+      def fragments(mode)
+        case mode
+        when :change
+          return [[value_left, value_right, change_key]] unless complex?
+
+          [[value_left, value_right, change_key + ['...']],
+           [nesting_left, nesting_right, change_key + ['{}']]]
+        when :deletion
+          [[value_left, NO_VALUE, change_key]]
+        when :addition
+          [[NO_VALUE, value_right, change_key]]
+        end
       end
 
-      # compare Hash with nothing (deletion)
-      def compare_left
-        HashDeepDiff::Comparison.new(left, NO_VALUE, change_key,
-                                     delta_engine: delta.class,
-                                     reporting_engine: reporting_engine)
+      # original value without nested hashes
+      # @return [Object]
+      def value_left
+        return left unless left.respond_to?(:to_ary)
+
+        left.reject { |el| el.respond_to?(:to_hash) }
       end
 
-      # compare nothing with Hash (addition)
-      def compare_right
-        HashDeepDiff::Comparison.new(NO_VALUE, right, change_key,
-                                     delta_engine: delta.class,
-                                     reporting_engine: reporting_engine)
+      # changed value without nested hashes
+      # @return [Object]
+      def value_right
+        return right unless right.respond_to?(:to_ary)
+
+        right.reject { |el| el.respond_to?(:to_hash) }
+      end
+
+      # nested hashes from original value
+      # @return [Array<Hash>]
+      def nesting_left
+        return NO_VALUE unless complex_left?
+
+        left
+          .select { |el| el.respond_to?(:to_hash) }
+          .each_with_object({}) { |el, memo| memo.merge!(el) }
+      end
+
+      # nested hashes from changed value
+      # @return [Array<Hash>]
+      def nesting_right
+        return NO_VALUE unless complex_right?
+
+        right
+          .select { |el| el.respond_to?(:to_hash) }
+          .each_with_object({}) { |el, memo| memo.merge!(el) }
       end
     end
   end

data/lib/hash_deep_diff/reports/base.rb

@@ -19,6 +19,13 @@ module HashDeepDiff
 
       private
 
+      # @!attribute [r] old_val
+      #    @return [Object] original value
+      # @!attribute [r] new_val
+      #    @return [Object] replacement of the original value
+      # @!attribute [r] change_key
+      #    @return [Array<Object>] subset of keys from original Hashes to fetch reported values
+      #    (is empty for top-level comparison)
       attr_reader :old_val, :new_val, :change_key
 
       # @param [Delta] delta diff to report

data/lib/hash_deep_diff/reports/diff.rb

@@ -9,20 +9,42 @@ module HashDeepDiff
     class Diff < Base
       private
 
-      # old value
+      # line of the report with deleted value
       # @return [String]
       def original
         return '' if old_val == NO_VALUE
+        return "#{deletion}#{path} = #{old_val}\n" unless array_to_array?
+        return '' if array_deletion.empty?
 
-        return "#{deletion}#{path} = #{old_val}\n"
+        "#{deletion}#{path} = #{array_deletion}\n"
       end
 
-      # new value
+      # line of the report with added value
       # @return [String]
       def replacement
         return '' if new_val == NO_VALUE
+        return "#{addition}#{path} = #{new_val}\n" unless array_to_array?
+        return '' if array_addition.empty?
 
-        return "#{addition}#{path} = #{new_val}\n"
+        "#{addition}#{path} = #{array_addition}\n"
+      end
+
+      # returns true if original value and replacement are instances of +Array+
+      # @return Bool
+      def array_to_array?
+        old_val.instance_of?(Array) && new_val.instance_of?(Array)
+      end
+
+      # added elemnts of array
+      # @return [Array]
+      def array_addition
+        new_val - old_val
+      end
+
+      # added elemnts of array
+      # @return [Array]
+      def array_deletion
+        old_val - new_val
       end
 
       # Visual representation of keys from compared objects needed to fetch the compared values

data/lib/hash_deep_diff/version.rb

@@ -2,5 +2,5 @@
 
 module HashDeepDiff
   # Version of a gem
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_deep_diff
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-25 00:00:00.000000000 Z
+date: 2022-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement