hash_deep_diff 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc574fc78f743f8b629ecbb87baebea7e75789d99401f7e54691ad02469572ec
-  data.tar.gz: 0f378780b1f08173779e3684a8d42361c0532411c7972952a626bc3e4a0bebb0
+  metadata.gz: 0e7ceeb1c2e935cc4b6c9d27e6d718f63f627d3adeba269df367c37464f3e9c0
+  data.tar.gz: 00053a3c87a26ea7dff3513594c6fb85e1235be3c341bc58f30d4934faa3de57
 SHA512:
-  metadata.gz: dd12f9bc333f1a8ab3d4967bcdaeee7eac9cf66a97883a122cfa3f3e831165da62cce4b4dadf0e5e3c750cc43dcd59629b20c279d215b42ebd2d6fd65ebcc497
-  data.tar.gz: 64b6e8dbf48807f23ca32e84cfec991e14ff56ffda7bb65b71a1db3bc7d800ca0f94f00038e49dc1cd2bd30b84ad6c05496de599038d97960dece9f827cde4fb
+  metadata.gz: 612c398c02060fd908f449ac44893a8a81d33f3c1f13ec86bb3042d748034f18a20fbd99559c211af58e5f70d77d0b107fda0fae6cb2be3a1f94e1e0299c0f2e
+  data.tar.gz: c63d6e0ddad970dce331a5460981916b821805a8a3fe8b95f5ab6ea73a029942091acdf6b9681da533630fd6da38440749419d25436979e07cd15da5a2020658

data/.rubocop.yml

@@ -10,6 +10,7 @@ AllCops:
     - '.git/**/*'
     - '.bundle/**/*'
     - 'bin/*'
+  TargetRubyVersion: 2.6.1
 
 Style/RedundantReturn:
   Enabled: false
@@ -18,3 +19,9 @@ Metrics/BlockLength:
   Exclude:
     - 'test/**/test_*.rb'
     - '*.gemspec'
+Style/YodaCondition:
+  EnforcedStyle: require_for_all_comparison_operators
+
+Minitest/AssertEmptyLiteral:
+  Exclude:
+    - 'test/unit/test_change_key.rb'

data/README.md

@@ -7,7 +7,7 @@ Status](https://img.shields.io/github/workflow/status/bpohoriletz/hash_deep_diff
 
 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)
+Alternative solutions [hashdiff](https://github.com/liufengyun/hashdiff) by liufengyun and [hash_diff](https://github.com/CodingZeal/hash_diff) by CodingZeal
 
 ## Installation
 
@@ -26,21 +26,93 @@ Or install it yourself as:
     $ gem install hash_deep_diff
 
 ## Usage
-Basic example
+### Basic
 
 ```ruby
 left = { a: :a }
 right = { a: :b }
 
-HashDeepDiff::Comparison.new(left, right).report
+print HashDeepDiff::Comparison.new(left, right).report
 ```
 ```diff
 - left[a] = a
 + left[a] = b
 ```
+### Arrays
+```ruby
+left = [1, 2, { a: :a }]
+right = [2, { a: :b }, 3]
+
+print HashDeepDiff::Comparison.new(left, right).report
+```
+```diff
+-left[...] = [1]
++left[...] = [3]
+-left[{}][a] = a
++left[{}][a] = b
+```
+### Nesting
+```ruby
+left  = { a: [1, 2, { a: :a } ], b: { c: [1, 2, { d: :e } ] } }
+right = { a: [2, { a: :b }, 3], b: { c: { f: { g: :h } } } }
+
+print HashDeepDiff::Comparison.new(left, right).report
+```
+```diff
+-left[a][...] = [1]
++left[a][...] = [3]
+-left[a][{}][a] = a
++left[a][{}][a] = b
++left[b][c][...][f] = {}
++left[b][c][...][f][g] = h
+-left[b][c][...][f] = [1, 2]
+-left[b][c][{}][d] = e
+```
+### Reporting Engines
+You can choose from the default diff-like reporting engine (examples are above) and YML reporting engine
+
+```ruby
+left  = { a: [1, 2, { a: :a } ], b: { c: [1, 2, { d: :e } ] } }
+right = { a: [2, { a: :b }, 3], b: { c: { f: { g: :h } } } }
+```
+#### Raw Report
+
+```ruby
+print HashDeepDiff::Comparison.new(left, right, reporting_engine: HashDeepDiff::Reports::Yml).raw_report
+=> {"additions"=>{:a=>[3, {:a=>:b}], :b=>{:c=>[{:f=>{:g=>:h}}]}},
+    "deletions"=>{:a=>[1, {:a=>:a}], :b=>{:c=>[1, 2, {:d=>:e}]}}}
+```
+
+#### YML Report
+
+```ruby
+print HashDeepDiff::Comparison.new(left, right, reporting_engine: HashDeepDiff::Reports::Yml).report
+
+---
+additions:
+  :a:
+  - 3
+  - :a: :b
+  :b:
+    :c:
+    - :f:
+        :g: :h
+deletions:
+  :a:
+  - 1
+  - :a: :a
+  :b:
+    :c:
+    - 1
+    - 2
+    - :d: :e
+```
+
 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`

data/hash_deep_diff.gemspec

@@ -53,5 +53,7 @@ Gem::Specification.new do |spec|
   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'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.13.3'
   spec.add_development_dependency 'rubocop-rake', '~> 0.6.0'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.10.0'
 end

data/lib/hash_deep_diff/change_key.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module HashDeepDiff
+  # Key for a compared value inside Array or Hash
+  class ChangeKey
+    extend Forwardable
+    def_delegators :to_ary, :[], :+, :map, :==, :first, :shift, :empty?
+    # element that indicates nested Hash
+    NESTED_HASH = '{}'
+    # element that indicates Array value
+    ARRAY_VALUE = '...'
+
+    # based on the first element of the key returns the initial object
+    # to buld the change representation
+    # @return [Array, Hash]
+    def self.initial_object(values:)
+      return [] if values.size.positive? && [NESTED_HASH, ARRAY_VALUE].include?(values[0][0][0])
+
+      {}
+    end
+
+    # set the value inside Hash based on the change_key
+    # @return [Array, Hash]
+    # TOFIX; check if @path are mutated
+    def set(obj, value, clone_keys = path.clone)
+      # 1. Fetch key
+      current_key = clone_keys.shift
+      # 2. Prepare object for further processing
+      init_value(current_key, obj, clone_keys)
+      init_nesting(current_key, obj, clone_keys)
+      # 3. Set value - directly or recursively
+      set_value(current_key, obj, value, clone_keys)
+      recursive_set(current_key, obj, value, clone_keys)
+
+      return obj
+    end
+
+    # see {#to_ary}
+    # @return [Array]
+    def to_a
+      to_ary
+    end
+
+    # array with keysused to initialize the object
+    # @return [Array]
+    def to_ary
+      path
+    end
+
+    # see {#to_str}
+    # @return [String]
+    def to_s
+      to_str
+    end
+
+    # visual representation of the change key
+    # @return [String]
+    def to_str
+      path.map { |key| "[#{key}]" }.join
+    end
+
+    private
+
+    attr_reader :path
+
+    def initialize(path:)
+      @path = path.to_ary
+    end
+
+    # prepare an object before further processing
+    def init_value(current_key, obj, clone_keys)
+      if [ARRAY_VALUE] == clone_keys || NESTED_HASH == clone_keys.first
+        obj[current_key] ||= []
+      elsif !clone_keys.empty? && ![ARRAY_VALUE, NESTED_HASH].include?(current_key)
+        obj[current_key] ||= {}
+      end
+    end
+
+    # prepare nesting before further processing
+    def init_nesting(current_key, obj, clone_keys)
+      element = if NESTED_HASH == current_key
+                  obj
+                elsif NESTED_HASH == clone_keys.first
+                  obj[current_key]
+                end
+      element << {} unless element.nil? || element.last.respond_to?(:to_hash)
+    end
+
+    # no more nesting - set value inside object
+    def set_value(current_key, obj, value, clone_keys)
+      if ARRAY_VALUE == current_key
+        obj.prepend(*value)
+        clone_keys.pop
+      elsif clone_keys.empty?
+        obj[current_key] = value
+        clone_keys.pop
+      elsif [ARRAY_VALUE] == clone_keys
+        obj[current_key] = value + obj[current_key]
+        clone_keys.pop
+      end
+    end
+
+    # recursion for deeply nested values
+    def recursive_set(current_key, obj, value, clone_keys)
+      if NESTED_HASH == current_key
+        set(obj.last, value, clone_keys)
+      elsif NESTED_HASH == clone_keys.first
+        set(obj[current_key].last, value, clone_keys[1..])
+      elsif !clone_keys.empty?
+        set(obj[current_key], value, clone_keys)
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/comparison.rb

@@ -21,36 +21,22 @@ module HashDeepDiff
   #       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],
+  #    #<HashDeepDiff::Delta:0x00007fc7bc8a6e58
+  #      @change_key=#<HashDeepDiff::ChangeKey:0x00007fc7bc8a6d40 @path=[:one, :two]>,
   #      @value={:left=>:a, :right=>:b}>,
-  #    #<HashDeepDiff::Delta
-  #      @delta={:zero=>{:left=>:z, :right=>HashDeepDiff::NO_VALUE}},
-  #      @prefix=[:one],
+  #    #<HashDeepDiff::Delta:0x00007fc7bc8a6b60
+  #      @change_key=#<HashDeepDiff::ChangeKey:0x00007fc7bc8a6a48 @path=[:one, :zero]>,
   #      @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}>
+  #    #<HashDeepDiff::Delta:0x00007fc7bc8a6930
+  #      @change_key=#<HashDeepDiff::ChangeKey:0x00007fc7bc8a6818 @path=[:one, :three]>,
+  #      @value={:left=>HashDeepDiff::NO_VALUE, :right=>:c}>]
   #  ]
   class Comparison
     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
+    def_delegators :report_engine_factory, :report, :raw_report
 
     # @return [Array<HashDeepDiff::Delta>]
     def diff
@@ -79,6 +65,9 @@ module HashDeepDiff
 
     private
 
+    # @!attribute [r] path
+    #    @return [Array<Object>] subset of keys from original Hashes to fetch compared values
+    #    (is empty for top-level comparison)
     attr_reader :path
 
     # @param [Object] original original version
@@ -132,18 +121,23 @@ module HashDeepDiff
       keys.uniq
     end
 
+    # factory function
+    # @return [HashDeepDiff::Delta]
+    def delta(key: NO_VALUE)
+      keys = path
+      keys += [key] unless key == NO_VALUE
+
+      HashDeepDiff::Delta.new(path: keys, value: { left: left(key), right: right(key) })
+    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) })
+    # @return [HashDeepDiff::Reports::Base]
+    def report_engine_factory
+      reporting_engine.new(diff: diff)
     end
   end
 end

data/lib/hash_deep_diff/delta.rb

@@ -20,7 +20,7 @@ module HashDeepDiff
     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)]
+      [self.class.new(path: change_key, value: placebo)]
     end
 
     # true if any value is an +Array+ with hashes
@@ -59,11 +59,25 @@ module HashDeepDiff
       simple_left? && simple_right?
     end
 
+    # removed element(s)
+    def deletion
+      return left unless array_with_array?
+
+      return left - right
+    end
+
     # Original value
     def left
       value[:left]
     end
 
+    # added element(s)
+    def addition
+      return right unless array_with_array?
+
+      return right - left
+    end
+
     # Value we compare to
     def right
       value[:right]
@@ -84,12 +98,12 @@ module HashDeepDiff
 
     attr_reader :value
 
-    # @param [Array] change_key list of keys to fetch values we're comparing
+    # @param [Array] path 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:)
+    def initialize(path:, value:)
       @value = value
-      @change_key = change_key
+      @change_key = HashDeepDiff::ChangeKey.new(path: path)
     end
 
     # an indication of added/removed nested Hash
@@ -111,5 +125,11 @@ module HashDeepDiff
     def simple_right?
       !right.respond_to?(:to_hash) && !complex_right?
     end
+
+    # true if both left and right are arrays
+    # @return [TrueClass, FalseClass]
+    def array_with_array?
+      left.respond_to?(:to_ary) && right.respond_to?(:to_ary)
+    end
   end
 end

data/lib/hash_deep_diff/factories/comparison.rb

@@ -42,8 +42,8 @@ module HashDeepDiff
         when :change
           return [[value_left, value_right, change_key]] unless complex?
 
-          [[value_left, value_right, change_key + ['...']],
-           [nesting_left, nesting_right, change_key + ['{}']]]
+          [[value_left, value_right, change_key + [ChangeKey::ARRAY_VALUE]],
+           [nesting_left, nesting_right, change_key + [ChangeKey::NESTED_HASH]]]
         when :deletion
           [[value_left, NO_VALUE, change_key]]
         when :addition
@@ -54,6 +54,7 @@ module HashDeepDiff
       # original value without nested hashes
       # @return [Object]
       def value_left
+        return NO_VALUE if left.respond_to?(:to_hash) && right.respond_to?(:to_ary)
         return left unless left.respond_to?(:to_ary)
 
         left.reject { |el| el.respond_to?(:to_hash) }
@@ -62,6 +63,7 @@ module HashDeepDiff
       # changed value without nested hashes
       # @return [Object]
       def value_right
+        return NO_VALUE if right.respond_to?(:to_hash) && left.respond_to?(:to_ary)
         return right unless right.respond_to?(:to_ary)
 
         right.reject { |el| el.respond_to?(:to_hash) }
@@ -70,6 +72,7 @@ module HashDeepDiff
       # nested hashes from original value
       # @return [Array<Hash>]
       def nesting_left
+        return left if left.respond_to?(:to_hash)
         return NO_VALUE unless complex_left?
 
         left
@@ -80,6 +83,7 @@ module HashDeepDiff
       # nested hashes from changed value
       # @return [Array<Hash>]
       def nesting_right
+        return right if right.respond_to?(:to_hash)
         return NO_VALUE unless complex_right?
 
         right

data/lib/hash_deep_diff/reports/base.rb

@@ -5,44 +5,39 @@ module HashDeepDiff
   module Reports
     # Abstract Class
     class Base
+      # raw data for {#report}
+      def raw_report
+        raise AbstractMethodError
+      end
+
       # see {#to_str}
       # @return [String]
       def to_s
         to_str
       end
 
-      # A report on additions and deletions
+      # see {#report}
       # @return [String]
       def to_str
-        original + replacement
+        report
       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
+      # A report on additions and deletions
+      # @return [String]
+      def report
         raise AbstractMethodError
       end
 
-      # new value
-      def replacement
-        raise AbstractMethodError
+      private
+
+      # @!attribute [r] diff
+      #    @return [Array<HashDeepDiff::Delta>] set of deltas from Comparison of two objects
+      attr_reader :diff
+
+      # @param [Array<HashDeepDiff::Delta>] diff comparison data to report
+      def initialize(diff:, change_key_engine: HashDeepDiff::ChangeKey)
+        @diff = diff.to_ary
+        @change_key = change_key_engine
       end
     end
   end

data/lib/hash_deep_diff/reports/diff.rb

@@ -7,50 +7,57 @@ module HashDeepDiff
   module Reports
     # Visual representation of the {Delta} as diff
     class Diff < Base
+      # additiond and deletions represented as diff
+      # @return [String]
+      def report
+        raw_report.map { |delta| original(delta) + replacement(delta) }.join
+      end
+
+      # additiond and deletions raw
+      # @return [Array<HashDeepDiff::Delta>]
+      def raw_report
+        diff
+      end
+
       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?
+      def original(delta)
+        return '' if delta.left == NO_VALUE
+        return "#{deletion}#{delta.change_key} = #{delta.left}\n" unless array_to_array?(delta)
+        return '' if array_deletion(delta).empty?
 
-        "#{deletion}#{path} = #{array_deletion}\n"
+        "#{deletion}#{delta.change_key} = #{array_deletion(delta)}\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?
+      def replacement(delta)
+        return '' if delta.right == NO_VALUE
+        return "#{addition}#{delta.change_key} = #{delta.right}\n" unless array_to_array?(delta)
+        return '' if array_addition(delta).empty?
 
-        "#{addition}#{path} = #{array_addition}\n"
+        "#{addition}#{delta.change_key} = #{array_addition(delta)}\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)
+      # TOFIX drop
+      def array_to_array?(delta)
+        delta.left.instance_of?(Array) && delta.right.instance_of?(Array)
       end
 
       # added elemnts of array
       # @return [Array]
-      def array_addition
-        new_val - old_val
+      def array_addition(delta)
+        delta.right - delta.left
       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
+      def array_deletion(delta)
+        delta.left - delta.right
       end
 
       # visual indication of addition

data/lib/hash_deep_diff/reports/yml.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'forwardable'
+require 'yaml'
+
+module HashDeepDiff
+  # Different reporting enjines for {Delta}
+  module Reports
+    # Visual representation of the {Delta} as diff
+    class Yml < Base
+      extend Forwardable
+      def_delegators :@change_key, :initial_object, :dig_set
+
+      # additions and deletions represented as YAML
+      # @return [String]
+      def report
+        YAML.dump(raw_report)
+      end
+
+      # additions and deletiond represented as Hash
+      # @return [Hash]
+      def raw_report
+        @raw = { 'additions' => initial_object(values: additions), 'deletions' => initial_object(values: deletions) }
+
+        additions.each { |(change_key, addition)| change_key.set(raw['additions'], addition) }
+        deletions.each { |(change_key, deletion)| change_key.set(raw['deletions'], deletion) }
+
+        return raw
+      end
+
+      private
+
+      attr_reader :raw
+
+      # added values
+      # @return [Array<HashDeepDiff::Delta>]
+      def additions
+        diff.reject { |delta| delta.right == NO_VALUE }
+            .map { |delta| [delta.change_key, delta.addition] }
+            .reject { |(_, addition)| [] == addition }
+      end
+
+      # deleted values
+      # @return [Array<HashDeepDiff::Delta>]
+      def deletions
+        diff.reject { |delta| delta.left == NO_VALUE }
+            .map { |delta| [delta.change_key, delta.deletion] }
+            .reject { |(_, deletion)| [] == deletion }
+      end
+    end
+  end
+end

data/lib/hash_deep_diff/version.rb

@@ -2,5 +2,5 @@
 
 module HashDeepDiff
   # Version of a gem
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/hash_deep_diff.rb

@@ -2,7 +2,9 @@
 
 require 'hash_deep_diff/version'
 require 'hash_deep_diff/reports/diff'
+require 'hash_deep_diff/reports/yml'
 require 'hash_deep_diff/delta'
+require 'hash_deep_diff/change_key'
 require 'hash_deep_diff/comparison'
 
 # Global namespace

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_deep_diff
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Bohdan Pohorilets
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-05 00:00:00.000000000 Z
+date: 2022-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.18.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +220,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.0
 description: Find the exact difference between two Hash objects
 email:
 - bohdan.pohorilets@gmail.com
@@ -237,11 +265,13 @@ files:
 - bin/yri
 - hash_deep_diff.gemspec
 - lib/hash_deep_diff.rb
+- lib/hash_deep_diff/change_key.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/reports/yml.rb
 - lib/hash_deep_diff/version.rb
 homepage: https://github.com/bpohoriletz/hash_deep_diff
 licenses: