hash_deep_diff 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 184fe8aaacd6b6d10635f8ff8f0986381c8e2d907b14a80d86050aea75896136
-  data.tar.gz: e4e33cc8c4ce40d84b0fbbe78fa380d1d62f65805f3ce5dc01e2049100db5b16
+  metadata.gz: 965ed70dc327febfcab65e1d8a9ae2511e06b117316a368140eae6a00dc8afba
+  data.tar.gz: f905ef6c174c729ec28f9d585db116deb32727276ae61b1e448f4c17917cbf47
 SHA512:
-  metadata.gz: b299b5217a613175c47e5d56da723e0691cf7e2344abc9bbf9fab9525c96c776616971636365f0c2067f05ec8d22c205c98d896df4b1b17ee73f3541bb4e5736
-  data.tar.gz: 159ffbeb7cdef03c130ed356f965379db05ebf8adec8b7e5186e1a45b4cbcc68489ce17b92a7e2bc38e58cdd2fafcb31c573703f566f348b0efdc0ef8c504d4e
+  metadata.gz: 6669aa02e12598277b0d59e0abb1f173a1a28dfb5aa9770e5c209bde4972bb7e9166788dfcae30743fcc95050bf23104e768edae1ecec855f07b72fa704ad46a
+  data.tar.gz: d4f9fc51fc4acbaaf0228f84c8aa47e84cb1b17dbad6e45df7047df0cf086b7ff6deeab85de648ec5916174b0d12e1a982bac975d9a05ef65609714f23ab91dc

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/Guardfile

@@ -20,7 +20,6 @@
 guard :rubocop do
   watch(/.+\.rb$/)
   watch(/.+\.gemspec$/)
-  watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
 end
 
 guard :minitest do

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,8 +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)
 
-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.
 
-TODO: Delete this and the text above, and describe your gem
+Find the exact difference between two Hash objects and build a report to visualize it
 
 ## Installation
 
@@ -21,15 +24,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/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/hash_deep_diff.gemspec

@@ -39,7 +39,7 @@ 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'

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.2'
+  VERSION = '0.4.1'
 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.2
+  version: 0.4.1
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-12 00:00:00.000000000 Z
+date: 2022-04-17 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
@@ -173,10 +173,13 @@ extra_rdoc_files: []
 files:
 - ".bundle/.keep"
 - ".bundle/config"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
+- MIT-LICENSE
 - README.md
 - Rakefile
 - bin/_guard-core
@@ -188,11 +191,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,66 +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
-
-        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 }
-            @prefix = path[0..-2]
-          else
-            @delta = { path => value }
-            @prefix = []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hash_deep_diff/delta/inner.rb

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