hash_deep_diff 0.4.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 965ed70dc327febfcab65e1d8a9ae2511e06b117316a368140eae6a00dc8afba
-  data.tar.gz: f905ef6c174c729ec28f9d585db116deb32727276ae61b1e448f4c17917cbf47
+  metadata.gz: dc574fc78f743f8b629ecbb87baebea7e75789d99401f7e54691ad02469572ec
+  data.tar.gz: 0f378780b1f08173779e3684a8d42361c0532411c7972952a626bc3e4a0bebb0
 SHA512:
-  metadata.gz: 6669aa02e12598277b0d59e0abb1f173a1a28dfb5aa9770e5c209bde4972bb7e9166788dfcae30743fcc95050bf23104e768edae1ecec855f07b72fa704ad46a
-  data.tar.gz: d4f9fc51fc4acbaaf0228f84c8aa47e84cb1b17dbad6e45df7047df0cf086b7ff6deeab85de648ec5916174b0d12e1a982bac975d9a05ef65609714f23ab91dc
+  metadata.gz: dd12f9bc333f1a8ab3d4967bcdaeee7eac9cf66a97883a122cfa3f3e831165da62cce4b4dadf0e5e3c750cc43dcd59629b20c279d215b42ebd2d6fd65ebcc497
+  data.tar.gz: 64b6e8dbf48807f23ca32e84cfec991e14ff56ffda7bb65b71a1db3bc7d800ca0f94f00038e49dc1cd2bd30b84ad6c05496de599038d97960dece9f827cde4fb

data/.yardopts

@@ -0,0 +1 @@
+--private

data/CHANGELOG.md

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

data/Guardfile

@@ -25,8 +25,12 @@ 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
+
+guard 'yard' do
+  watch(%r{lib/.+\.rb})
+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 by liufengyun](https://github.com/liufengyun/hashdiff) and [hash_hdiff by CodingZeal](https://github.com/CodingZeal/hash_diff)
 
 ## Installation
 
@@ -36,6 +38,19 @@ HashDeepDiff::Comparison.new(left, right).report
 - left[a] = a
 + left[a] = b
 ```
+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/bin/yard

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'yard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("yard", "yard")

data/bin/yardoc

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'yardoc' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("yard", "yardoc")

data/bin/yri

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'yri' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("yard", "yri")

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'
@@ -43,9 +44,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'guard', '~> 2.18.0'
   spec.add_development_dependency 'guard-minitest', '~> 2.4.6'
   spec.add_development_dependency 'guard-rubocop', '~> 1.5.0'
+  spec.add_development_dependency 'guard-yard', '~> 2.2.1'
   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'

data/lib/hash_deep_diff/comparison.rb

@@ -1,52 +1,149 @@
 # frozen_string_literal: true
 
-require_relative 'delta'
+require_relative 'factories/comparison'
 
-# :nodoc:
 module HashDeepDiff
-  # An instrument to build and report the difference between two hash-like objects
+  # Representation of the recursive difference between two hashes
+  # main parts are
+  # * path - empty for original hashes, otherwise path to values being compared
+  # * left - basically left.dig(path), left value of two being compared
+  # * right - basically right.dig(path), right value of two being compared
+  #
+  # 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
+  #     - { 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
+  #         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],
+  #      @value={:left=>:a, :right=>:b}>,
+  #    #<HashDeepDiff::Delta
+  #      @delta={:zero=>{:left=>:z, :right=>HashDeepDiff::NO_VALUE}},
+  #      @prefix=[:one],
+  #      @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}>
+  #  ]
   class Comparison
-    attr_reader :left, :right, :path
+    extend Forwardable
+    # @!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>] subset of keys from original Hashes to fetch compared values
+    #    (is empty for top-level comparison)
+    attr_reader :reporting_engine, :delta_engine
 
+    def_delegators :comparison_factory, :comparison
+
+    # @return [String]
+    def report
+      diff.map { |simple_delta| reporting_engine.new(delta: simple_delta).to_s }.join
+    end
+
+    # @return [Array<HashDeepDiff::Delta>]
     def diff
-      deep_delta
+      return [] if left == right
+
+      deltas.flat_map { |new_delta| new_delta.simple? ? new_delta : inward_comparison(new_delta) }
     end
 
-    def report
-      diff.join("\n")
+    # @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
 
-    private
+    # @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)
 
-    def initialize(left, right, path = [])
-      @left = left.to_hash
-      @right = right.to_hash
-      @path = path.to_ary
+      @right[key] || NO_VALUE
     end
 
-    def deep_delta
-      delta.flat_map do |diff|
-        if diff.complex?
-          self.class.new(diff.left, diff.right, diff.path).diff
-        else
-          diff
-        end
-      end
+    private
+
+    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(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
 
-    def delta
+    # {Comparison} broken down into array of {Delta}
+    # @return [Array<HashDeepDiff::Delta>]
+    def deltas
+      return [delta] if common_keys.empty?
+
       common_keys.each_with_object([]) do |key, memo|
-        value_left = left[key] || NO_VALUE
-        value_right = right[key] || NO_VALUE
+        next if values_equal?(key)
 
-        next if value_right.instance_of?(value_left.class) && (value_right == value_left)
+        memo.append(delta(key: key))
+      end.flatten
+    end
 
-        memo << Delta.new(path: path + [key], value: { left: value_left, right: value_right })
+    # 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)
+      right(key).instance_of?(left(key).class) && (right(key) == left(key))
+    end
+
+    # All keys from both original and compared objects
+    # @return [Array]
     def common_keys
-      (left.keys + right.keys).uniq
+      keys = []
+      keys += left.keys if left.respond_to?(:keys)
+      keys += right.keys if right.respond_to?(:keys)
+
+      keys.uniq
+    end
+
+    # @return [HashDeepDiff::Factories::Comparison]
+    def comparison_factory
+      HashDeepDiff::Factories::Comparison.new(reporting_engine: reporting_engine)
+    end
+
+    # factory function
+    # @return [HashDeepDiff::Delta]
+    def delta(key: NO_VALUE)
+      change_key = path
+      change_key += [key] unless key == NO_VALUE
+
+      HashDeepDiff::Delta.new(change_key: change_key, value: { left: left(key), right: right(key) })
     end
   end
 end

data/lib/hash_deep_diff/delta.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'acts_as_hash'
+require 'forwardable'
 
 module HashDeepDiff
   # Representation of the diff of two values
@@ -9,72 +9,107 @@ 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
 
-    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(change_key: change_key, value: placebo)]
     end
 
+    # 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
 
-    # TOFIX poor naming
-    # overrides parameter in initializer
-    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
 
+    # Original value
     def left
-      @value[:left]
+      value[:left]
     end
 
+    # Value we compare to
     def right
-      @value[:right]
+      value[:right]
     end
 
-    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
 
-    def initialize(path:, value:)
-      # TOFIX this may prohibit usage of hashes with Array keys
-      if path.respond_to?(:to_ary)
-        @delta = { path[-1] => value }
-        @value = value
-        @prefix = path[0..-2]
-      else
-        @delta = { path => value }
-        @value = value
-        @prefix = []
-      end
+    attr_reader :value
+
+    # @param [Array] change_key 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(change_key:, value:)
+      @value = value
+      @change_key = change_key
     end
 
-    def deletion
-      return nil if left == NO_VALUE
+    # an indication of added/removed nested Hash
+    # @return [Array, Hash]
+    def placebo_elment
+      return [{}] if complex_left? || complex_right?
 
-      if left.respond_to?(:to_hash)
-        left.keys.map { |key| "-left#{diff_prefix}[#{key}] = #{left[key]}" }.join("\n")
-      else
-        "-left#{diff_prefix} = #{left}"
-      end
+      return {}
     end
 
-    def addition
-      return nil if right == NO_VALUE
-
-      if right.respond_to?(:to_hash)
-        right.keys.map { |key| "+left#{diff_prefix}[#{key}] = #{right[key]}" }.join("\n")
-      else
-        "+left#{diff_prefix} = #{right}"
-      end
+    # true if left value has no nested Hashes
+    # @return [TrueClass, FalseClass]
+    def simple_left?
+      !left.respond_to?(:to_hash) && !complex_left?
     end
 
-    # TOFIX poor naming
-    def diff_prefix
-      path.map { |key| "[#{key}]" }.join
+    # true if right value has no nested Hashes
+    # @return [TrueClass, FalseClass]
+    def simple_right?
+      !right.respond_to?(:to_hash) && !complex_right?
     end
   end
 end

data/lib/hash_deep_diff/factories/comparison.rb

@@ -0,0 +1,91 @@
+# 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 + ['...']],
+           [nesting_left, nesting_right, change_key + ['{}']]]
+        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 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 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
+end

data/lib/hash_deep_diff/reports/base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module HashDeepDiff
+  # Different reporting enjines for {Delta}
+  module Reports
+    # Abstract Class
+    class Base
+      # see {#to_str}
+      # @return [String]
+      def to_s
+        to_str
+      end
+
+      # A report on additions and deletions
+      # @return [String]
+      def to_str
+        original + replacement
+      end
+
+      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
+      def initialize(delta:)
+        @change_key = delta.change_key.to_ary
+        @old_val = delta.left
+        @new_val = delta.right
+      end
+
+      # old value
+      def original
+        raise AbstractMethodError
+      end
+
+      # new value
+      def replacement
+        raise AbstractMethodError
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/reports/diff.rb

@@ -0,0 +1,69 @@
+# 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
+      private
+
+      # 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?
+
+        "#{deletion}#{path} = #{array_deletion}\n"
+      end
+
+      # 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?
+
+        "#{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
+      # @return [String]
+      def path
+        change_key.map { |key| "[#{key}]" }.join
+      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/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module HashDeepDiff
-  VERSION = '0.4.1'
+  # Version of a gem
+  VERSION = '0.7.0'
 end

data/lib/hash_deep_diff.rb

@@ -1,9 +1,16 @@
 # frozen_string_literal: true
 
 require 'hash_deep_diff/version'
+require 'hash_deep_diff/reports/diff'
+require 'hash_deep_diff/delta'
 require 'hash_deep_diff/comparison'
 
+# Global namespace
 module HashDeepDiff
+  # value was not found
   NO_VALUE = Class.new(NilClass)
-  class Error < StandardError; end
+  # 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.4.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-17 00:00:00.000000000 Z
+date: 2022-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -108,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
@@ -176,6 +218,7 @@ files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - Guardfile
@@ -189,11 +232,16 @@ files:
 - bin/rake
 - bin/rubocop
 - bin/setup
+- bin/yard
+- bin/yardoc
+- bin/yri
 - hash_deep_diff.gemspec
 - lib/hash_deep_diff.rb
-- lib/hash_deep_diff/acts_as_hash.rb
 - lib/hash_deep_diff/comparison.rb
 - lib/hash_deep_diff/delta.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/version.rb
 homepage: https://github.com/bpohoriletz/hash_deep_diff
 licenses:
@@ -201,6 +249,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,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module HashDeepDiff
-  # This module includes behavior that is needed to use deltas instead of Hash inside this gem
-  module ActsAsHash
-    def self.included(base)
-      base.include(InstanceMethods)
-      base.extend(Forwardable)
-      base.def_delegators :@delta, :==, :each_with_object, :each_key, :[],
-                          :to_a, :empty?, :keys
-    end
-
-    # Assumes that the class will include method delta that will return a representation of an
-    # instance of a class as a Hash
-    module InstanceMethods
-      def to_h
-        @delta
-      end
-
-      def to_hash
-        @delta
-      end
-    end
-  end
-end