hash_deep_diff 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24756c15f3f48bbe108e5c2bb12c2db3e6030cef78ab91a6cf76044ca70d2dd5
-  data.tar.gz: a8cca8ab8a23c704f6f69c2613ded6b4d0d2c7b0e5caed34d437fe0951582a45
+  metadata.gz: ddbaa8e8f12ba99330973c609c00ab710e9fa39b369797b80dd46f24aa6740e1
+  data.tar.gz: 6a5954a960ca0876cdb9e28f3e535be687de5596ed07be61581102b75b178ab4
 SHA512:
-  metadata.gz: 731ccc90f750c6796374ae83ccf9c78741e47251c7940add8f0e9c9c34417f84f8375e74c639891c4e37e5976200bb8786e4bd2dbbe9357bb9b92e8a14b46c7b
-  data.tar.gz: 8dfbab0f3e5fd2666e2d5eb3458d9df858e204e49cd604348676af43c511bd855dba61720702cc69c7e3ecd0751e29606eec10bef41ee1a0e8bdd4ba33db79f7
+  metadata.gz: af66a50e5a7eb848c96b757e8e37a4d767868de6fd96ebfd4f528085111e2fe1c9e39215b8514d534d33f94cfc4c024c5c2bba1813acad729fa906e18eee796a
+  data.tar.gz: 358e25298ee3c42ea469e44113fe62935ec8f564c4111c52e170bd25764d99cc4b71c42d154689ad2a9c54ff21f9359dad57cfbd450677853eb60655b90aecf4

data/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+on:
+  pull_request:
+
+jobs:
+  minitest:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v2
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+          bundler-cache: false
+
+      - name: Install Gems
+        run: bin/bundle
+
+      - name: Run Minitest
+        run: bin/rake test
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v2
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+          bundler-cache: false
+
+      - name: Install Gems
+        run: bin/bundle
+
+      - name: Run Rubocop
+        run: bin/rubocop

data/.yardopts

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

data/Guardfile

@@ -20,14 +20,17 @@
 guard :rubocop do
   watch(/.+\.rb$/)
   watch(/.+\.gemspec$/)
-  watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
 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/MIT-LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 - 2022 Bohdan Pohorilets
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,9 +1,11 @@
 # HashDeepDiff
+[![Gem
+Version](https://badge.fury.io/rb/hash_deep_diff.svg)](https://badge.fury.io/rb/hash_deep_diff) ![GitHub Workflow
+Status](https://img.shields.io/github/workflow/status/bpohoriletz/hash_deep_diff/CI)
+![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
 
-[![Gem
-Version](https://badge.fury.io/rb/hash_deep_diff.svg)](https://badge.fury.io/rb/hash_deep_diff)
+Find the exact difference between two Hash objects and build a report to visualize it
 
 ## Installation
 
@@ -34,6 +36,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 
+
+## 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/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  t.test_files = FileList['test/**/*_spec.rb']
+  t.test_files = FileList['test/hash_deep_diff/test_*.rb']
   t.verbose = true
 end
 

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'
@@ -39,13 +40,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.17.2'
+  spec.add_development_dependency 'bundler', '~> 2.3.11'
   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 '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,150 @@
 # 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
+
+      @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
 
-    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 << delta(key: key)
+      end
+    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: :right).diff,
+          comparison(delta: complex_delta, modifier: :left).diff
+        ].compact.flatten
+        # TOFIX add test an drop flatten
+      else
+        comparison(delta: complex_delta).diff
       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,83 @@ 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 [HashDeepDiff::Delta, NilClass]
+    def placebo
+      return nil unless partial?
+
+      placebo = simple_left? ? { left: NO_VALUE, right: {} } : { left: {}, right: NO_VALUE }
+
+      self.class.new(change_key: change_key, value: placebo)
+    end
+
+    # true if at least one of the values is a Hash
+    # @return [Bool]
+    def partial?
+      !composite? && !simple?
     end
 
-    def complex?
-      left.respond_to?(:to_hash) && right.respond_to?(:to_hash)
+    # true if both valus are Hashes
+    # @return [Bool]
+    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 [Bool]
+    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
 
-    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
+    # @return [Hash]
+    def to_hash
+      { change_key[-1] => value }
     end
 
-    def deletion
-      return nil if left == NO_VALUE
+    private
 
-      if left.respond_to?(:to_hash)
-        left.keys.map { |key| "-left#{diff_prefix}[#{key}] = #{left[key]}" }.join("\n")
-      else
-        "-left#{diff_prefix} = #{left}"
-      end
-    end
+    attr_reader :value
 
-    def addition
-      return nil if right == NO_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
 
-      if right.respond_to?(:to_hash)
-        right.keys.map { |key| "+left#{diff_prefix}[#{key}] = #{right[key]}" }.join("\n")
-      else
-        "+left#{diff_prefix} = #{right}"
-      end
+    # Returns true if left value has no nested Hashes
+    # @return [Bool]
+    def simple_left?
+      !left.respond_to?(:to_hash)
     end
 
-    # TOFIX poor naming
-    def diff_prefix
-      path.map { |key| "[#{key}]" }.join
+    # Returns true if right value has no nested Hashes
+    # @return [Bool]
+    def simple_right?
+      !right.respond_to?(:to_hash)
     end
   end
 end

data/lib/hash_deep_diff/factories/comparison.rb

@@ -0,0 +1,58 @@
+# 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
+
+      # factory function
+      # @return [Comparison]
+      def comparison(delta:, modifier: nil)
+        @delta = delta
+
+        case modifier
+        when nil
+          full_compare
+        when :left
+          compare_left
+        when :right
+          compare_right
+        end
+      end
+
+      private
+
+      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)
+      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)
+      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)
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/reports/base.rb

@@ -0,0 +1,42 @@
+# 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
+
+      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,47 @@
+# 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
+
+      # old value
+      # @return [String]
+      def original
+        return '' if old_val == NO_VALUE
+
+        return "#{deletion}#{path} = #{old_val}\n"
+      end
+
+      # new value
+      # @return [String]
+      def replacement
+        return '' if new_val == NO_VALUE
+
+        return "#{addition}#{path} = #{new_val}\n"
+      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.0'
+  # Version of a gem
+  VERSION = '0.6.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.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-14 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.17.2
+        version: 2.3.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.17.2
+        version: 2.3.11
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -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,20 @@ 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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -173,11 +201,14 @@ extra_rdoc_files: []
 files:
 - ".bundle/.keep"
 - ".bundle/config"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - Guardfile
+- MIT-LICENSE
 - README.md
 - Rakefile
 - bin/_guard-core
@@ -187,11 +218,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:
@@ -199,6 +235,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