hash_deep_diff 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aab07a4c397dbc84845d5f0faff052bbae89eb8be4bf24a5ed9df0d5129c3da
-  data.tar.gz: 2ea89b301d808655625e0fa6a9c5028b9d194bba3c4dc54cf1f5c6859c59fc6f
+  metadata.gz: 0e7ceeb1c2e935cc4b6c9d27e6d718f63f627d3adeba269df367c37464f3e9c0
+  data.tar.gz: 00053a3c87a26ea7dff3513594c6fb85e1235be3c341bc58f30d4934faa3de57
 SHA512:
-  metadata.gz: f0a05ee023dbbd4d8551b5065a57a65b645ca3b0a864eace0de91b10ec08da77b0a15df6422af0f5ce0afd4459ca141e227398f9560198f6d350963fac1a99f0
-  data.tar.gz: 279185ca8464992a65f2fff626b6ee90f44ac7b7e98706e34443390ad24457961b642e5b2ebee10c4c8e3e5c72b7bfee454dd644f8f7ef68db5872c426137dc7
+  metadata.gz: 612c398c02060fd908f449ac44893a8a81d33f3c1f13ec86bb3042d748034f18a20fbd99559c211af58e5f70d77d0b107fda0fae6cb2be3a1f94e1e0299c0f2e
+  data.tar.gz: c63d6e0ddad970dce331a5460981916b821805a8a3fe8b95f5ab6ea73a029942091acdf6b9681da533630fd6da38440749419d25436979e07cd15da5a2020658

data/.rubocop.yml

@@ -10,6 +10,7 @@ AllCops:
     - '.git/**/*'
     - '.bundle/**/*'
     - 'bin/*'
+  TargetRubyVersion: 2.6.1
 
 Style/RedundantReturn:
   Enabled: false
@@ -18,3 +19,9 @@ Metrics/BlockLength:
   Exclude:
     - 'test/**/test_*.rb'
     - '*.gemspec'
+Style/YodaCondition:
+  EnforcedStyle: require_for_all_comparison_operators
+
+Minitest/AssertEmptyLiteral:
+  Exclude:
+    - 'test/unit/test_change_key.rb'

data/CHANGELOG.md

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

data/Guardfile

@@ -25,8 +25,8 @@ end
 guard :minitest do
   # with Minitest::Unit
   watch(%r{^test/(.*)/?test_(.*)\.rb$})
-  # watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
-  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { 'test' }
+  watch(%r{^lib/hash_deep_diff/(.*/)?([^/]+)\.rb$}) { |m| "test/unit/#{m[1]}test_#{m[2]}.rb" }
+  # watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { 'test' }
   watch(%r{^test/test_helper\.rb$})      { 'test' }
   watch(%r{^test/support/.*$})           { 'test' }
 end

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](https://github.com/liufengyun/hashdiff) by liufengyun and [hash_diff](https://github.com/CodingZeal/hash_diff) by CodingZeal
 
 ## Installation
 
@@ -24,20 +26,103 @@ Or install it yourself as:
     $ gem install hash_deep_diff
 
 ## Usage
-Basic example
+### Basic
 
 ```ruby
 left = { a: :a }
 right = { a: :b }
 
-HashDeepDiff::Comparison.new(left, right).report
+print HashDeepDiff::Comparison.new(left, right).report
 ```
 ```diff
 - left[a] = a
 + left[a] = b
 ```
-please see [Documentation](https://rdoc.info/gems/hash_deep_diff) for
-more info
+### Arrays
+```ruby
+left = [1, 2, { a: :a }]
+right = [2, { a: :b }, 3]
+
+print HashDeepDiff::Comparison.new(left, right).report
+```
+```diff
+-left[...] = [1]
++left[...] = [3]
+-left[{}][a] = a
++left[{}][a] = b
+```
+### Nesting
+```ruby
+left  = { a: [1, 2, { a: :a } ], b: { c: [1, 2, { d: :e } ] } }
+right = { a: [2, { a: :b }, 3], b: { c: { f: { g: :h } } } }
+
+print HashDeepDiff::Comparison.new(left, right).report
+```
+```diff
+-left[a][...] = [1]
++left[a][...] = [3]
+-left[a][{}][a] = a
++left[a][{}][a] = b
++left[b][c][...][f] = {}
++left[b][c][...][f][g] = h
+-left[b][c][...][f] = [1, 2]
+-left[b][c][{}][d] = e
+```
+### Reporting Engines
+You can choose from the default diff-like reporting engine (examples are above) and YML reporting engine
+
+```ruby
+left  = { a: [1, 2, { a: :a } ], b: { c: [1, 2, { d: :e } ] } }
+right = { a: [2, { a: :b }, 3], b: { c: { f: { g: :h } } } }
+```
+#### Raw Report
+
+```ruby
+print HashDeepDiff::Comparison.new(left, right, reporting_engine: HashDeepDiff::Reports::Yml).raw_report
+=> {"additions"=>{:a=>[3, {:a=>:b}], :b=>{:c=>[{:f=>{:g=>:h}}]}},
+    "deletions"=>{:a=>[1, {:a=>:a}], :b=>{:c=>[1, 2, {:d=>:e}]}}}
+```
+
+#### YML Report
+
+```ruby
+print HashDeepDiff::Comparison.new(left, right, reporting_engine: HashDeepDiff::Reports::Yml).report
+
+---
+additions:
+  :a:
+  - 3
+  - :a: :b
+  :b:
+    :c:
+    - :f:
+        :g: :h
+deletions:
+  :a:
+  - 1
+  - :a: :a
+  :b:
+    :c:
+    - 1
+    - 2
+    - :d: :e
+```
+
+please see [Documentation](https://rdoc.info/gems/hash_deep_diff/HashDeepDiff/Comparison) for
+more information or [Reporting test](https://github.com/bpohoriletz/hash_deep_diff/blob/a525d239189b0310aec3741dfc4862834805252d/test/integration/locales/test_uk_ru.rb#L59)
+
+
+
+## Customization
+
+You can implement and use your own reporting engines with the default `HashDeepDiff::Delta` objects as a source of the report. In order to do so implement your own version of the reporting engine (example can be found [here](https://github.com/bpohoriletz/hash_deep_diff/tree/main/lib/hash_deep_diff/reports)) and inject it into a `Comparison`
+
+```ruby
+left = { a: :a }
+right = { a: :b }
+
+HashDeepDiff::Comparison.new(left, right, reporting_engine: CustomEngine).report
+```
 
 ## Contributing
 

data/hash_deep_diff.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
     spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
 
     spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['documentation_uri'] = 'https://rdoc.info/gems/hash_deep_diff'
     spec.metadata['source_code_uri'] = 'https://github.com/bpohoriletz/hash_deep_diff'
     spec.metadata['changelog_uri'] = 'https://github.com/bpohoriletz/hash_deep_diff/blob/main/CHANGELOG.md'
     spec.metadata['rubygems_mfa_required'] = 'true'
@@ -47,8 +48,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest', '~> 5.15.0'
   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'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.13.3'
   spec.add_development_dependency 'rubocop-rake', '~> 0.6.0'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.10.0'
 end

data/lib/hash_deep_diff/change_key.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module HashDeepDiff
+  # Key for a compared value inside Array or Hash
+  class ChangeKey
+    extend Forwardable
+    def_delegators :to_ary, :[], :+, :map, :==, :first, :shift, :empty?
+    # element that indicates nested Hash
+    NESTED_HASH = '{}'
+    # element that indicates Array value
+    ARRAY_VALUE = '...'
+
+    # based on the first element of the key returns the initial object
+    # to buld the change representation
+    # @return [Array, Hash]
+    def self.initial_object(values:)
+      return [] if values.size.positive? && [NESTED_HASH, ARRAY_VALUE].include?(values[0][0][0])
+
+      {}
+    end
+
+    # set the value inside Hash based on the change_key
+    # @return [Array, Hash]
+    # TOFIX; check if @path are mutated
+    def set(obj, value, clone_keys = path.clone)
+      # 1. Fetch key
+      current_key = clone_keys.shift
+      # 2. Prepare object for further processing
+      init_value(current_key, obj, clone_keys)
+      init_nesting(current_key, obj, clone_keys)
+      # 3. Set value - directly or recursively
+      set_value(current_key, obj, value, clone_keys)
+      recursive_set(current_key, obj, value, clone_keys)
+
+      return obj
+    end
+
+    # see {#to_ary}
+    # @return [Array]
+    def to_a
+      to_ary
+    end
+
+    # array with keysused to initialize the object
+    # @return [Array]
+    def to_ary
+      path
+    end
+
+    # see {#to_str}
+    # @return [String]
+    def to_s
+      to_str
+    end
+
+    # visual representation of the change key
+    # @return [String]
+    def to_str
+      path.map { |key| "[#{key}]" }.join
+    end
+
+    private
+
+    attr_reader :path
+
+    def initialize(path:)
+      @path = path.to_ary
+    end
+
+    # prepare an object before further processing
+    def init_value(current_key, obj, clone_keys)
+      if [ARRAY_VALUE] == clone_keys || NESTED_HASH == clone_keys.first
+        obj[current_key] ||= []
+      elsif !clone_keys.empty? && ![ARRAY_VALUE, NESTED_HASH].include?(current_key)
+        obj[current_key] ||= {}
+      end
+    end
+
+    # prepare nesting before further processing
+    def init_nesting(current_key, obj, clone_keys)
+      element = if NESTED_HASH == current_key
+                  obj
+                elsif NESTED_HASH == clone_keys.first
+                  obj[current_key]
+                end
+      element << {} unless element.nil? || element.last.respond_to?(:to_hash)
+    end
+
+    # no more nesting - set value inside object
+    def set_value(current_key, obj, value, clone_keys)
+      if ARRAY_VALUE == current_key
+        obj.prepend(*value)
+        clone_keys.pop
+      elsif clone_keys.empty?
+        obj[current_key] = value
+        clone_keys.pop
+      elsif [ARRAY_VALUE] == clone_keys
+        obj[current_key] = value + obj[current_key]
+        clone_keys.pop
+      end
+    end
+
+    # recursion for deeply nested values
+    def recursive_set(current_key, obj, value, clone_keys)
+      if NESTED_HASH == current_key
+        set(obj.last, value, clone_keys)
+      elsif NESTED_HASH == clone_keys.first
+        set(obj[current_key].last, value, clone_keys[1..])
+      elsif !clone_keys.empty?
+        set(obj[current_key], value, clone_keys)
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/comparison.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'delta'
+require_relative 'factories/comparison'
 
 module HashDeepDiff
   # Representation of the recursive difference between two hashes
@@ -11,94 +11,133 @@ module HashDeepDiff
   #
   # Examples:
   #   - { one: :a } compared with { one: :b } does not have nesting so we compare keys and values
-  #   - { one: { two: :a, zero: z } } compared with { one: { two: :b, three: :c } } has nesting, so is represented as
+  #   - { one: { two: :a, zero: :z } } compared with { one: { two: :b, three: :c } } has nesting, so is represented as
   #     - { two: :a } compared with { two: :b, three: :c }, as there is no more nesting we compare keys and values
   #       and have the following comparisons
   #       { one: { two: :a } } compared to { one: { two: :b } } - value was changed
   #         i.e :a vas replaced with :b on path [:one, :two]
-  #       { one: { zero: z } } compared to NO_VALUE - value was deleted
+  #       { one: { zero: :z } } compared to NO_VALUE - value was deleted
   #         i.e :z vas replaced with NO_VALUE on path [:one, :zero]
   #       NO_VALUE compared to { one: { three: :c } } compared - value was added
   #         i.e NO_VALUE vas replaced with :c on path [:one, :three]
   #  [
-  #    #<HashDeepDiff::Delta
-  #      @delta={:two=>{:left=>:a, :right=>:b}},
-  #      @prefix=[:one],
+  #    #<HashDeepDiff::Delta:0x00007fc7bc8a6e58
+  #      @change_key=#<HashDeepDiff::ChangeKey:0x00007fc7bc8a6d40 @path=[:one, :two]>,
   #      @value={:left=>:a, :right=>:b}>,
-  #    #<HashDeepDiff::Delta
-  #      @delta={:zero=>{:left=>:z, :right=>HashDeepDiff::NO_VALUE}},
-  #      @prefix=[:one],
+  #    #<HashDeepDiff::Delta:0x00007fc7bc8a6b60
+  #      @change_key=#<HashDeepDiff::ChangeKey:0x00007fc7bc8a6a48 @path=[:one, :zero]>,
   #      @value={:left=>:z, :right=>HashDeepDiff::NO_VALUE}>,
-  #    #<HashDeepDiff::Delta
-  #     @delta={:three=>{:left=>HashDeepDiff::NO_VALUE, :right=>:c}},
-  #     @prefix=[:one],
-  #     @value={:left=>HashDeepDiff::NO_VALUE, :right=>:c}>
+  #    #<HashDeepDiff::Delta:0x00007fc7bc8a6930
+  #      @change_key=#<HashDeepDiff::ChangeKey:0x00007fc7bc8a6818 @path=[:one, :three]>,
+  #      @value={:left=>HashDeepDiff::NO_VALUE, :right=>:c}>]
   #  ]
   class Comparison
-    # @!attribute [r] left
-    #    @return [Hash] original version of the Hash
-    # @!attribute [r] right
-    #    @return [Hash] Hash that the original is compared to
-    # @!attribute [r] path
-    #    @return [Array<Object>] to a compared Hashes (is empty for top-level comparison)
-    attr_reader :left, :right, :path
+    extend Forwardable
+    attr_reader :reporting_engine, :delta_engine
 
-    # @return [String]
-    def report
-      diff.join("\n")
-    end
+    def_delegators :comparison_factory, :comparison
+    def_delegators :report_engine_factory, :report, :raw_report
 
     # @return [Array<HashDeepDiff::Delta>]
     def diff
-      comparison.flat_map do |delta|
-        # if there are nested hashes we need to compare them furter
-        # if no we return difference between values (HashDeepDiff::Delta)
-        delta.complex? ? self.class.new(delta.left, delta.right, delta.path).diff : delta
-      end
+      return [] if left == right
+
+      deltas.flat_map { |new_delta| new_delta.simple? ? new_delta : inward_comparison(new_delta) }
+    end
+
+    # @param [Object] key the key which value we're currently comparing
+    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
+
+    # @param [Object] key the key which value we're currently comparing
+    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
 
     private
 
-    # @param [Hash] left original version of the hash
-    # @param [Hash] right new version of the hash
+    # @!attribute [r] path
+    #    @return [Array<Object>] subset of keys from original Hashes to fetch compared values
+    #    (is empty for top-level comparison)
+    attr_reader :path
+
+    # @param [Object] original original version
+    # @param [Object] changed new version
     # @param [Array] prefix keys to fetch current comparison (not empty for nested comparisons)
-    def initialize(left, right, prefix = [])
-      @left = left.to_hash
-      @right = right.to_hash
+    def initialize(original, changed, prefix = [], reporting_engine: Reports::Diff, delta_engine: Delta)
+      @left = original
+      @right = changed
       @path = prefix.to_ary
+      @reporting_engine = reporting_engine
+      @delta_engine = delta_engine
     end
 
+    # {Comparison} broken down into array of {Delta}
     # @return [Array<HashDeepDiff::Delta>]
-    def comparison
+    def deltas
+      return [delta] if common_keys.empty?
+
       common_keys.each_with_object([]) do |key, memo|
         next if values_equal?(key)
 
-        memo << Delta.new(path: path + [key], value: { left: value_left(key), right: value_right(key) })
+        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: :addition).map(&:diff).flatten +
+          comparison(delta: complex_delta, modifier: :deletion).map(&:diff).flatten
+      else
+        comparison(delta: complex_delta).map(&:diff).flatten
       end
     end
 
     # @param [Object] key the key which value we're currently comparing
     # @return [Bool]
     def values_equal?(key)
-      value_right(key).instance_of?(value_left(key).class) && (value_right(key) == value_left(key))
+      right(key).instance_of?(left(key).class) && (right(key) == left(key))
     end
 
-    # Original value
-    # @param [Object] key the key which value we're currently comparing
-    def value_left(key)
-      left[key] || NO_VALUE
+    # All keys from both original and compared objects
+    # @return [Array]
+    def common_keys
+      keys = []
+      keys += left.keys if left.respond_to?(:keys)
+      keys += right.keys if right.respond_to?(:keys)
+
+      keys.uniq
     end
 
-    # Value we compare to
-    # @param [Object] key the key which value we're currently comparing
-    def value_right(key)
-      right[key] || NO_VALUE
+    # factory function
+    # @return [HashDeepDiff::Delta]
+    def delta(key: NO_VALUE)
+      keys = path
+      keys += [key] unless key == NO_VALUE
+
+      HashDeepDiff::Delta.new(path: keys, value: { left: left(key), right: right(key) })
     end
 
-    # All keys from both original and compared objects
-    # @return [Array]
-    def common_keys
-      (left.keys + right.keys).uniq
+    # @return [HashDeepDiff::Factories::Comparison]
+    def comparison_factory
+      HashDeepDiff::Factories::Comparison.new(reporting_engine: reporting_engine)
+    end
+
+    # @return [HashDeepDiff::Reports::Base]
+    def report_engine_factory
+      reporting_engine.new(diff: diff)
     end
   end
 end

data/lib/hash_deep_diff/delta.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'acts_as_hash'
-require_relative 'report'
+require 'forwardable'
 
 module HashDeepDiff
   # Representation of the diff of two values
@@ -10,74 +9,127 @@ module HashDeepDiff
   #   - diff of { a: a } and { a: b } is { a: { left: a, right: b } }
   #   - diff of {} and { a: b } is { a: { left: HashDeepDiff::NO_VALUE, right: b } }
   class Delta
-    include ActsAsHash
+    extend Forwardable
 
-    # Visual representation of additions and deletiond at given +path+
-    # @return [String]
-    def to_str
-      [deletion, addition].compact.join("\n")
+    def_delegators :to_hash, :==, :each_with_object, :each_key, :[],
+                   :to_a, :empty?, :keys
+    attr_reader :change_key
+
+    # an indication that nested Hash was deleted/added
+    # @return [Array<HashDeepDiff::Delta>]
+    def placebo
+      placebo = simple_left? ? { left: NO_VALUE, right: placebo_elment } : { left: placebo_elment, right: NO_VALUE }
+
+      [self.class.new(path: change_key, value: placebo)]
     end
 
-    # Returns true if we have nested Hashes
-    # @return [Bool]
+    # true if any value is an +Array+ with hashes
+    # @return [TrueClass, FalseClass]
     def complex?
-      left.respond_to?(:to_hash) && right.respond_to?(:to_hash)
+      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
+
+    # 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 [TrueClass, FalseClass]
+    def partial?
+      !composite? && !simple? && !complex_left? && !complex_right?
+    end
+
+    # true if both valus are Hashes
+    # @return [TrueClass, FalseClass]
+    def composite?
+      !simple_left? && !simple_right?
     end
 
-    # Keys needed to fetch values that we're comparing
-    # @return [Array]
-    def path
-      @prefix + [@delta.keys.first]
+    # true if none of the values is a Hash
+    # @return [TrueClass, FalseClass]
+    def simple?
+      simple_left? && simple_right?
+    end
+
+    # removed element(s)
+    def deletion
+      return left unless array_with_array?
+
+      return left - right
     end
 
     # Original value
     def left
-      @value[:left]
+      value[:left]
+    end
+
+    # added element(s)
+    def addition
+      return right unless array_with_array?
+
+      return right - left
     end
 
     # Value we compare to
     def right
-      @value[:right]
+      value[:right]
     end
 
-    # See {#to_str}
-    def to_s
-      to_str
+    # see {#to_hash}
+    # @return [Hash]
+    def to_h
+      to_hash
+    end
+
+    # @return [Hash]
+    def to_hash
+      { change_key[-1] => value }
     end
 
     private
 
-    # @param [Array, Object] path list of keys to fetch values we're comparing
+    attr_reader :value
+
+    # @param [Array] path list of keys to fetch values we're comparing
     # @param [Hash<(:left, :right), Object>] value +Hash+ object with two keys - :left and :right,
     #   that represents compared original value (at :left) and value we compare to (at :right)
     def initialize(path:, value:)
-      # TOFIX this may prohibit usage of hashes with Array keys
-      # TOFIX extract path to a separate object
-      if path.respond_to?(:to_ary)
-        @delta = { path[-1] => value }
-        @value = value
-        @prefix = path[0..-2]
-      else
-        @delta = { path => value }
-        @value = value
-        @prefix = []
-      end
-    end
-
-    # Visual representation of additions
-    # @return [NillClass, String]
-    def deletion
-      return nil if left == NO_VALUE
+      @value = value
+      @change_key = HashDeepDiff::ChangeKey.new(path: path)
+    end
 
-      Report.new(path: path, value: left, mode: Report::Mode::DELETION)
+    # an indication of added/removed nested Hash
+    # @return [Array, Hash]
+    def placebo_elment
+      return [{}] if complex_left? || complex_right?
+
+      return {}
     end
 
-    # Visual representation of deletions
-    # @return [NillClass, String]
-    def addition
-      return nil if right == NO_VALUE
+    # true if left value has no nested Hashes
+    # @return [TrueClass, FalseClass]
+    def simple_left?
+      !left.respond_to?(:to_hash) && !complex_left?
+    end
+
+    # true if right value has no nested Hashes
+    # @return [TrueClass, FalseClass]
+    def simple_right?
+      !right.respond_to?(:to_hash) && !complex_right?
+    end
 
-      Report.new(path: path, value: right)
+    # true if both left and right are arrays
+    # @return [TrueClass, FalseClass]
+    def array_with_array?
+      left.respond_to?(:to_ary) && right.respond_to?(:to_ary)
     end
   end
 end

data/lib/hash_deep_diff/factories/comparison.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module HashDeepDiff
+  # factories
+  module Factories
+    # Factory for {HashDeepDiff::Comparison}
+    class Comparison
+      extend Forwardable
+
+      def_delegators :delta, :left, :right, :change_key, :complex?, :complex_left?, :complex_right?
+
+      # factory function
+      # @return [HashDeepDiff::Comparison]
+      def comparison(delta:, modifier: :change)
+        @delta = delta
+
+        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
+
+      # 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 + [ChangeKey::ARRAY_VALUE]],
+           [nesting_left, nesting_right, change_key + [ChangeKey::NESTED_HASH]]]
+        when :deletion
+          [[value_left, NO_VALUE, change_key]]
+        when :addition
+          [[NO_VALUE, value_right, change_key]]
+        end
+      end
+
+      # original value without nested hashes
+      # @return [Object]
+      def value_left
+        return NO_VALUE if left.respond_to?(:to_hash) && right.respond_to?(:to_ary)
+        return left unless left.respond_to?(:to_ary)
+
+        left.reject { |el| el.respond_to?(:to_hash) }
+      end
+
+      # changed value without nested hashes
+      # @return [Object]
+      def value_right
+        return NO_VALUE if right.respond_to?(:to_hash) && left.respond_to?(:to_ary)
+        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 left if left.respond_to?(:to_hash)
+        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 right if right.respond_to?(:to_hash)
+        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
+end

data/lib/hash_deep_diff/reports/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module HashDeepDiff
+  # Different reporting enjines for {Delta}
+  module Reports
+    # Abstract Class
+    class Base
+      # raw data for {#report}
+      def raw_report
+        raise AbstractMethodError
+      end
+
+      # see {#to_str}
+      # @return [String]
+      def to_s
+        to_str
+      end
+
+      # see {#report}
+      # @return [String]
+      def to_str
+        report
+      end
+
+      # A report on additions and deletions
+      # @return [String]
+      def report
+        raise AbstractMethodError
+      end
+
+      private
+
+      # @!attribute [r] diff
+      #    @return [Array<HashDeepDiff::Delta>] set of deltas from Comparison of two objects
+      attr_reader :diff
+
+      # @param [Array<HashDeepDiff::Delta>] diff comparison data to report
+      def initialize(diff:, change_key_engine: HashDeepDiff::ChangeKey)
+        @diff = diff.to_ary
+        @change_key = change_key_engine
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/reports/diff.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module HashDeepDiff
+  # Different reporting enjines for {Delta}
+  module Reports
+    # Visual representation of the {Delta} as diff
+    class Diff < Base
+      # additiond and deletions represented as diff
+      # @return [String]
+      def report
+        raw_report.map { |delta| original(delta) + replacement(delta) }.join
+      end
+
+      # additiond and deletions raw
+      # @return [Array<HashDeepDiff::Delta>]
+      def raw_report
+        diff
+      end
+
+      private
+
+      # line of the report with deleted value
+      # @return [String]
+      def original(delta)
+        return '' if delta.left == NO_VALUE
+        return "#{deletion}#{delta.change_key} = #{delta.left}\n" unless array_to_array?(delta)
+        return '' if array_deletion(delta).empty?
+
+        "#{deletion}#{delta.change_key} = #{array_deletion(delta)}\n"
+      end
+
+      # line of the report with added value
+      # @return [String]
+      def replacement(delta)
+        return '' if delta.right == NO_VALUE
+        return "#{addition}#{delta.change_key} = #{delta.right}\n" unless array_to_array?(delta)
+        return '' if array_addition(delta).empty?
+
+        "#{addition}#{delta.change_key} = #{array_addition(delta)}\n"
+      end
+
+      # returns true if original value and replacement are instances of +Array+
+      # @return Bool
+      # TOFIX drop
+      def array_to_array?(delta)
+        delta.left.instance_of?(Array) && delta.right.instance_of?(Array)
+      end
+
+      # added elemnts of array
+      # @return [Array]
+      def array_addition(delta)
+        delta.right - delta.left
+      end
+
+      # added elemnts of array
+      # @return [Array]
+      def array_deletion(delta)
+        delta.left - delta.right
+      end
+
+      # visual indication of addition
+      # @return [String]
+      def addition
+        '+left'
+      end
+
+      # visual indication of deletion
+      # @return [String]
+      def deletion
+        '-left'
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/reports/yml.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'forwardable'
+require 'yaml'
+
+module HashDeepDiff
+  # Different reporting enjines for {Delta}
+  module Reports
+    # Visual representation of the {Delta} as diff
+    class Yml < Base
+      extend Forwardable
+      def_delegators :@change_key, :initial_object, :dig_set
+
+      # additions and deletions represented as YAML
+      # @return [String]
+      def report
+        YAML.dump(raw_report)
+      end
+
+      # additions and deletiond represented as Hash
+      # @return [Hash]
+      def raw_report
+        @raw = { 'additions' => initial_object(values: additions), 'deletions' => initial_object(values: deletions) }
+
+        additions.each { |(change_key, addition)| change_key.set(raw['additions'], addition) }
+        deletions.each { |(change_key, deletion)| change_key.set(raw['deletions'], deletion) }
+
+        return raw
+      end
+
+      private
+
+      attr_reader :raw
+
+      # added values
+      # @return [Array<HashDeepDiff::Delta>]
+      def additions
+        diff.reject { |delta| delta.right == NO_VALUE }
+            .map { |delta| [delta.change_key, delta.addition] }
+            .reject { |(_, addition)| [] == addition }
+      end
+
+      # deleted values
+      # @return [Array<HashDeepDiff::Delta>]
+      def deletions
+        diff.reject { |delta| delta.left == NO_VALUE }
+            .map { |delta| [delta.change_key, delta.deletion] }
+            .reject { |(_, deletion)| [] == deletion }
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/version.rb

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

data/lib/hash_deep_diff.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
 
 require 'hash_deep_diff/version'
+require 'hash_deep_diff/reports/diff'
+require 'hash_deep_diff/reports/yml'
+require 'hash_deep_diff/delta'
+require 'hash_deep_diff/change_key'
 require 'hash_deep_diff/comparison'
 
 # Global namespace
 module HashDeepDiff
   # value was not found
   NO_VALUE = Class.new(NilClass)
+  # Abstract method
+  AbstractMethodError = Class.new(NoMethodError)
+  # Any error
+  Error = Class.new(StandardError)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_deep_diff
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-18 00:00:00.000000000 Z
+date: 2022-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: naught
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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
@@ -164,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.18.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +220,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.0
 description: Find the exact difference between two Hash objects
 email:
 - bohdan.pohorilets@gmail.com
@@ -209,10 +265,13 @@ files:
 - bin/yri
 - hash_deep_diff.gemspec
 - lib/hash_deep_diff.rb
-- lib/hash_deep_diff/acts_as_hash.rb
+- lib/hash_deep_diff/change_key.rb
 - lib/hash_deep_diff/comparison.rb
 - lib/hash_deep_diff/delta.rb
-- lib/hash_deep_diff/report.rb
+- lib/hash_deep_diff/factories/comparison.rb
+- lib/hash_deep_diff/reports/base.rb
+- lib/hash_deep_diff/reports/diff.rb
+- lib/hash_deep_diff/reports/yml.rb
 - lib/hash_deep_diff/version.rb
 homepage: https://github.com/bpohoriletz/hash_deep_diff
 licenses:
@@ -220,6 +279,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org/
   homepage_uri: https://github.com/bpohoriletz/hash_deep_diff
+  documentation_uri: https://rdoc.info/gems/hash_deep_diff
   source_code_uri: https://github.com/bpohoriletz/hash_deep_diff
   changelog_uri: https://github.com/bpohoriletz/hash_deep_diff/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'

data/lib/hash_deep_diff/acts_as_hash.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module HashDeepDiff
-  # This module includes behavior that is needed to use instances of Delta instead of Hash
-  # in this gem
-  module ActsAsHash
-    # @param [Object] base a hook that is invoked when module is included in a class
-    def self.included(base)
-      base.extend Forwardable
-      base.def_delegators :@delta, :==, :each_with_object, :each_key, :[],
-                          :to_a, :empty?, :keys
-      base.include InstanceMethods
-    end
-
-    # We assume that the class will initialize instance variable +@delta+ that will return
-    # a representation of an instance of a class as a +Hash+ object
-    module InstanceMethods
-      # a +Hash+ representation of an object
-      def to_h
-        to_hash
-      end
-
-      # a +Hash+ representation of an object
-      def to_hash
-        @delta
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/report.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module HashDeepDiff
-  # Visual representation of the difference between two values
-  class Report
-    # We have two cases
-    #   * added - when value on the left is missing
-    #   * deleted - when the value on the right is missing
-    module Mode
-      # for additions
-      ADDITION = '+left'
-      # for deletions
-      DELETION = '-left'
-    end
-
-    # A report with all additions and deletions
-    # @return [String]
-    def to_str
-      if @value.respond_to?(:to_hash) && !@value.empty?
-        [@mode, diff_prefix, ' = ', "{}\n"].join +
-          @value.keys.map do |key|
-            Report.new(path: @path + [key], value: @value[key], mode: @mode)
-          end.join("\n")
-      else
-        [@mode, diff_prefix, ' = ', @value.to_s].join
-      end
-    end
-
-    # A report with all additions and deletions
-    # @return [String]
-    def to_s
-      to_str
-    end
-
-    private
-
-    # @param [Array] path Keys from compared objects to fetch the compared values
-    # @param [Object] value value from a  compared object at +@path+
-    # @param [Mode::ADDITION, Mode::DELETION] mode
-    def initialize(path:, value:, mode: Mode::ADDITION)
-      @path = path.to_ary
-      @value = value
-      @mode = mode
-    end
-
-    # Visual representation of keys from compared objects needed to fetch the compared values
-    # @return [String]
-    def diff_prefix
-      # TOFIX poor naming
-      @path.map { |key| "[#{key}]" }.join
-    end
-  end
-end