hash_deep_diff 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43343dfc0eed6ad00b863b65b535f206b6a14544c8c23560f01954e16c7ef19b
-  data.tar.gz: 613e764bf1a0390bfba99eceaa6e65e69355903858c229f8d150661c8a923af4
+  metadata.gz: 24756c15f3f48bbe108e5c2bb12c2db3e6030cef78ab91a6cf76044ca70d2dd5
+  data.tar.gz: a8cca8ab8a23c704f6f69c2613ded6b4d0d2c7b0e5caed34d437fe0951582a45
 SHA512:
-  metadata.gz: 701aad97711690dbaff2719a3c0f6a4c0bbbf2a3ffdcd088b6451803c392a019dd37dba9b3cffc3a7843862b8341d6a7e17eaa2935aba8be4f069fb81160a052
-  data.tar.gz: 920a5d22b16bb78866c752c5a60469f37af9d58f8f0f3852c1822f594223f995ed4c87f14777d3dc857a73310d1c851581edd9fdba36bc3b433d069133211d95
+  metadata.gz: 731ccc90f750c6796374ae83ccf9c78741e47251c7940add8f0e9c9c34417f84f8375e74c639891c4e37e5976200bb8786e4bd2dbbe9357bb9b92e8a14b46c7b
+  data.tar.gz: 8dfbab0f3e5fd2666e2d5eb3458d9df858e204e49cd604348676af43c511bd855dba61720702cc69c7e3ecd0751e29606eec10bef41ee1a0e8bdd4ba33db79f7

data/README.md

@@ -1,8 +1,9 @@
 # HashDeepDiff
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/hash_deep_diff`. To experiment with that code, run `bin/console` for an interactive prompt.
+Find the exact difference between two Hash objects and build a report to visualize it
 
-TODO: Delete this and the text above, and describe your gem
+[![Gem
+Version](https://badge.fury.io/rb/hash_deep_diff.svg)](https://badge.fury.io/rb/hash_deep_diff)
 
 ## Installation
 
@@ -21,15 +22,20 @@ Or install it yourself as:
     $ gem install hash_deep_diff
 
 ## Usage
+Basic example
 
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```ruby
+left = { a: :a }
+right = { a: :b }
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+HashDeepDiff::Comparison.new(left, right).report
+```
+```diff
+- left[a] = a
++ left[a] = b
+```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/hash_deep_diff.
+Bug reports and pull requests are welcome on GitHub at [bpohoriletz](https://github.com/bpohoriletz/hash_deep_diff).
+	

data/lib/hash_deep_diff/acts_as_hash.rb

@@ -0,0 +1,27 @@
+# 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

data/lib/hash_deep_diff/comparison.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require_relative 'delta/left'
-require_relative 'delta/inner'
-require_relative 'delta/right'
+require_relative 'delta'
 
 # :nodoc:
 module HashDeepDiff
-  # :nodoc:
+  # An instrument to build and report the difference between two hash-like objects
   class Comparison
     attr_reader :left, :right, :path
 
-    def diff(&block)
-      left_delta + deep_delta(&block) + right_delta
+    def diff
+      deep_delta
     end
 
     def report
@@ -26,80 +24,29 @@ module HashDeepDiff
       @path = path.to_ary
     end
 
-    def extra_report(memo, keys, value)
-      if value.respond_to?(:to_hash)
-        value.each_key { |key| extra_report(memo, keys + [key], value[key]) }
-      else
-        memo << Delta::Left.new(path: keys, value: value)
-      end
-    end
-
-    def missing_report(memo, keys, value)
-      if value.respond_to?(:to_hash)
-        value.each_key { |key| missing_report(memo, keys + [key], value[key]) }
-      else
-        memo << Delta::Right.new(path: keys, value: value)
-      end
-    end
-
-    def delta_report(memo, keys, value)
-      if value.respond_to?(:to_hash) && value.keys != %i[left right]
-        value.each_key { |key| delta_report(memo, keys + [key], value[key]) }
-      elsif value.instance_of?(Array) && value.size == 3 && value.all? { |el| el.respond_to?(:to_hash) }
-        # [{}, {}, {:i=>:i}]
-        extra_report(memo, keys, value[0]) unless value[0].empty?
-        delta_report(memo, keys, value[1]) unless value[1].empty?
-        missing_report(memo, keys, value[2]) unless value[2].empty?
-      else
-        memo << Delta::Inner.new(path: keys, value: value)
-      end
-    end
-
-    def deep_delta(&block)
-      result = delta(&block)
-
-      result.each_with_object([]) do |diff, memo|
-        if left.dig(*diff.path).respond_to?(:to_hash) && right.dig(*diff.path).respond_to?(:to_hash)
-          self.class.new(left.dig(*diff.path), right.dig(*diff.path), path + diff.path).diff.each do |diff|
-            memo << diff
-          end
+    def deep_delta
+      delta.flat_map do |diff|
+        if diff.complex?
+          self.class.new(diff.left, diff.right, diff.path).diff
         else
-          memo << diff
+          diff
         end
       end
     end
 
-    def right_delta
-      right_diff_keys.map { |key| Delta::Right.new(path: path + [key], value: right[key]) }
-    end
-
-    def delta(&block)
-      block ||= ->(val) { val }
-
+    def delta
       common_keys.each_with_object([]) do |key, memo|
-        value_left = block.call(left[key])
-        value_right = block.call(right[key])
+        value_left = left[key] || NO_VALUE
+        value_right = right[key] || NO_VALUE
 
         next if value_right.instance_of?(value_left.class) && (value_right == value_left)
 
-        memo << Delta::Inner.new(path: path + [key], value: { left: value_left, right: value_right })
+        memo << Delta.new(path: path + [key], value: { left: value_left, right: value_right })
       end
     end
 
-    def left_delta
-      left_diff_keys.map { |key| Delta::Left.new(path: path + [key], value: left[key]) }
-    end
-
     def common_keys
-      left.keys & right.keys
-    end
-
-    def right_diff_keys
-      right.keys - left.keys
-    end
-
-    def left_diff_keys
-      left.keys - right.keys
+      (left.keys + right.keys).uniq
     end
   end
 end

data/lib/hash_deep_diff/delta.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative 'acts_as_hash'
+
+module HashDeepDiff
+  # Representation of the diff of two values
+  # examples:
+  #   - diff of { a: a } and {} is { a: { left: a, right: HashDeepDiff::NO_VALUE } }
+  #   - 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
+
+    def to_str
+      [deletion, addition].compact.join("\n")
+    end
+
+    def complex?
+      left.respond_to?(:to_hash) && right.respond_to?(:to_hash)
+    end
+
+    # TOFIX poor naming
+    # overrides parameter in initializer
+    def path
+      @prefix + [@delta.keys.first]
+    end
+
+    def left
+      @value[:left]
+    end
+
+    def right
+      @value[:right]
+    end
+
+    def to_s
+      to_str
+    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
+    end
+
+    def deletion
+      return nil if left == NO_VALUE
+
+      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
+
+    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
+    end
+
+    # TOFIX poor naming
+    def diff_prefix
+      path.map { |key| "[#{key}]" }.join
+    end
+  end
+end

data/lib/hash_deep_diff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HashDeepDiff
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/hash_deep_diff.rb

@@ -4,5 +4,6 @@ require 'hash_deep_diff/version'
 require 'hash_deep_diff/comparison'
 
 module HashDeepDiff
+  NO_VALUE = Class.new(NilClass)
   class Error < StandardError; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_deep_diff
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-11 00:00:00.000000000 Z
+date: 2022-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -175,6 +175,7 @@ files:
 - ".bundle/config"
 - ".gitignore"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - README.md
@@ -188,11 +189,9 @@ files:
 - bin/setup
 - 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/acts_as_delta.rb
-- lib/hash_deep_diff/delta/inner.rb
-- lib/hash_deep_diff/delta/left.rb
-- lib/hash_deep_diff/delta/right.rb
+- lib/hash_deep_diff/delta.rb
 - lib/hash_deep_diff/version.rb
 homepage: https://github.com/bpohoriletz/hash_deep_diff
 licenses:

data/lib/hash_deep_diff/delta/acts_as_delta.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module HashDeepDiff
-  module Delta
-    # This module includes behavior that is needed to use deltas instead of Hash inside this gem
-    module ActsAsDelta
-      def self.included(base)
-        base.prepend(Initialize)
-        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
-        # TOFIX poor naming
-        def diff_prefix
-          path.map { |key| "[#{key}]" }.join
-        end
-
-        # TOFIX poor naming
-        def path
-          @prefix + [@delta.keys.first]
-        end
-
-        def to_h
-          @delta
-        end
-
-        def to_hash
-          @delta
-        end
-
-        def to_s
-          to_str
-        end
-
-        def to_str
-          raise NoMethodError, "expected #{self.class} to implement #to_str"
-        end
-      end
-
-      # Override #initialize method
-      module Initialize
-        def initialize(path:, value:)
-          # TOFIX this may prohibit usage of hashes with Array keys
-          if path.respond_to?(:to_ary)
-            @delta = { path[-1] => value }
-            @prefix = path[0..-2]
-          else
-            @delta = { path => value }
-            @prefix = []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/inner.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'acts_as_delta'
-
-module HashDeepDiff
-  module Delta
-    # Representation of the pure left diff
-    # i.e element that are missing in the hash on the right of the comparison
-    # for example left diff of { a: a } and {} is { a: a }
-    class Inner
-      include Delta::ActsAsDelta
-
-      def to_str
-        if @delta.values.first.respond_to?(:to_hash)
-          if @delta.values.first.keys == %i[left right]
-            if @delta.values.first[:left].respond_to?(:to_hash) && @delta.values.first[:right].respond_to?(:to_hash)
-              HashDeepDiff::Comparison.new(
-                @delta.values.first[:left],
-                @delta.values.first[:right],
-                path
-              ).report
-            else
-              lines = <<~Q
-                -left#{diff_prefix} = #{@delta.values.first[:left]}
-                +right#{diff_prefix} = #{@delta.values.first[:right]}
-              Q
-              lines.strip
-            end
-          else
-            @delta.values.first.keys.map do |key|
-              self.class.new(path: path + [key], value: @delta.values.first[key])
-            end.join("\n").strip
-          end
-        else
-          lines = <<~Q
-            -left#{diff_prefix} = #{@delta.values.first[:left]}
-            +right#{diff_prefix} = #{@delta.values.first[:right]}
-          Q
-          lines.strip
-        end
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/left.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'acts_as_delta'
-
-module HashDeepDiff
-  module Delta
-    # Representation of the pure left diff
-    # i.e element that are missing in the hash on the right of the comparison
-    # for example left diff of { a: a } and {} is { a: a }
-    class Left
-      include Delta::ActsAsDelta
-
-      def to_str
-        if @delta.values.first.respond_to?(:to_hash)
-          @delta.values.first.keys.map do |key|
-            self.class.new(path: path + [key], value: @delta.values.first[key])
-          end.join("\n").strip
-        else
-          "+left#{diff_prefix} = #{@delta.values.first}"
-        end
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/right.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'acts_as_delta'
-
-module HashDeepDiff
-  module Delta
-    # Representation of the pure right diff
-    # i.e element that are missing in the hash on the right of the comparison
-    # for example right diff of {} and { a: a } is { a: a }
-    class Right
-      include Delta::ActsAsDelta
-
-      def to_str
-        if @delta.values.first.respond_to?(:to_hash)
-          @delta.values.first.keys.map do |key|
-            self.class.new(path: path + [key], value: @delta.values.first[key])
-          end.join("\n").strip
-        else
-          "-left#{diff_prefix} = #{@delta.values.first}"
-        end
-      end
-    end
-  end
-end