hash_deep_diff 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe3724394c10b36b7537f35bce5c7f079cae0ee3344062a78bdfe7256363624b
-  data.tar.gz: e9baa112b03013b91f75ebea9f243a0a6d51ca746ca8c8e66ea6fa38803198fd
+  metadata.gz: 24756c15f3f48bbe108e5c2bb12c2db3e6030cef78ab91a6cf76044ca70d2dd5
+  data.tar.gz: a8cca8ab8a23c704f6f69c2613ded6b4d0d2c7b0e5caed34d437fe0951582a45
 SHA512:
-  metadata.gz: b7393bb437eddfb8e0ed66d4eba3b4135e221c7c2262df14aa4509dba98345c4766b598bd3c3f11f311c84b25b4f9f0b2bca3dfc5083c023c87c582fa607761a
-  data.tar.gz: 57708513050ac1e63c0ce64b9650e0ae0e3128127cbb4dfc5b248cc3caca3267cbd26bed7b939be4413c11f1a7038f5503aef143119a09e336cc113324ae182a
+  metadata.gz: 731ccc90f750c6796374ae83ccf9c78741e47251c7940add8f0e9c9c34417f84f8375e74c639891c4e37e5976200bb8786e4bd2dbbe9357bb9b92e8a14b46c7b
+  data.tar.gz: 8dfbab0f3e5fd2666e2d5eb3458d9df858e204e49cd604348676af43c511bd855dba61720702cc69c7e3ecd0751e29606eec10bef41ee1a0e8bdd4ba33db79f7

data/README.md

@@ -2,6 +2,9 @@
 
 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)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -29,10 +32,10 @@ HashDeepDiff::Comparison.new(left, right).report
 ```
 ```diff
 - left[a] = a
-+ right[a] = b 
++ left[a] = b
 ```
 
 ## Contributing
 
 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,8 +24,8 @@ module HashDeepDiff
       @path = path.to_ary
     end
 
-    def deep_delta(&block)
-      delta(&block).flat_map do |diff|
+    def deep_delta
+      delta.flat_map do |diff|
         if diff.complex?
           self.class.new(diff.left, diff.right, diff.path).diff
         else
@@ -36,37 +34,19 @@ module HashDeepDiff
       end
     end
 
-    def left_delta
-      left_diff_keys.map { |key| Delta::Left.new(path: path + [key], value: left[key]) }
-    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 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.3'
+  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.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-13 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,69 +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
-        # overrides parameter in initializer
-        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
-
-        def complex?
-          raise NoMethodError, "expected #{self.class} to implement #complex?"
-        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 }
-            @value = value
-            @prefix = path[0..-2]
-          else
-            @delta = { path => value }
-            @value = value
-            @prefix = []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/inner.rb

@@ -1,40 +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
-        return diff unless complex?
-
-        HashDeepDiff::Comparison.new(left, right, path).report
-      end
-
-      def diff
-        lines = <<~Q
-          -left#{diff_prefix} = #{left}
-          +right#{diff_prefix} = #{right}
-        Q
-        lines.strip
-      end
-
-      def complex?
-        left.respond_to?(:to_hash) && right.respond_to?(:to_hash)
-      end
-
-      def left
-        @value[:left]
-      end
-
-      def right
-        @value[:right]
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/left.rb

@@ -1,30 +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
-        return "+left#{diff_prefix} = #{left}" unless left.respond_to?(:to_hash)
-
-        left.keys.map do |key|
-          self.class.new(path: path + [key], value: left[key])
-        end.join("\n").strip
-      end
-
-      def left
-        @value
-      end
-
-      def right
-        nil
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/right.rb

@@ -1,30 +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
-        return "-left#{diff_prefix} = #{right}" unless right.respond_to?(:to_hash)
-
-        right.keys.map do |key|
-          self.class.new(path: path + [key], value: right[key])
-        end.join("\n").strip
-      end
-
-      def left
-        nil
-      end
-
-      def right
-        @value
-      end
-    end
-  end
-end