specdiff 0.3.0.pre.rc1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68cf98631e494fb5f016c0b3632cce58f616dad54ba11c782b37e3de4f2b36c9
-  data.tar.gz: b97fee8a8e586b383a71bf0dcdcb32be7cf1c135356a90ec2ae7488fc2082071
+  metadata.gz: 16d43f0ff6248844478dc69d99ebb9e5de1212804fba96b859d947e446e5fae7
+  data.tar.gz: 0c9e973795920664617d2c57211e40569a0aee10ee6b6c35b02680a6789edf2f
 SHA512:
-  metadata.gz: b374cadd1aa564cf8252c4b3d6c4ca2be952b147891cdbec9f0799383349bf5bcf61a1ef94979bc2b1f7dbe4d850e586d4c11f1271c74a14dc9be09cffc4e184
-  data.tar.gz: 8379b0c263ae20900ec31b63ea9600e3c15cef8fe9b597c1e1349a708c323d03ee8bfaa46d6f6eeb666e2af0ee751e7ef2cd47917e927eeceb48a7f076a1e126
+  metadata.gz: a21ca995b7418a69deaeb6c024f40b2fc6342200edc33f4179f979ce7555bf346b29012184784b59f0736ac55b089a55836dd21756e14100d7a76260b5c7d69a
+  data.tar.gz: e457b0266ddc5f11df693baae9594dd790498e687ce7a4d263b9b291108af2a14f976499dd3b1eee9294a6827e2f15f527c0ae451035c8f73dc2dbaea9245f2d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# local installed gem bundles, ala node_modules for npm
+.gem-bundle/

data/CHANGELOG.md

@@ -7,7 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.3.0-rc1]
+## [0.3.0] - 2024-04-16
+
+### Changed
+
+- Hashprint now sorts keys (if all the keys are strings or symbols), leading to better text diffs from the hash differ.
+
+## [0.3.0.rc2] - 2024-04-05
+
+### Changed
+
+- Rework how hashdiff's output gets printed.
+- Rework switching heuristic between text diff/hashdiff in hash differ.
+
+### Fixed
+
+- The RSpec integration now inspects hashes and arrays recursively. (Like rspec does by default)
+- RSpec integration no longer breaks description output of matchers when using multi matchers (like .all or .and)
+- The hash differ now deals with recursive hashes and arrays
+- RSpec integration no longer breaks description output of matchers that are part of a diff inside an array or hash. (like when doing `match([have_attributes(...)])`)
+
+## [0.3.0-rc1] - 2024-04-02
 
 ### Added
 

data/DEVELOPMENT.md

@@ -0,0 +1,74 @@
+# Development
+
+## Glossary
+
+Check out the [glossary](./glossary.txt) to make sure we are using the same
+words for things.
+
+## Setup
+
+Install the software versions specified in `.tool-versions`.
+
+Run `bin/setup` to install dependencies. Then, run `bundle exec rake` to run
+the tests and linter and make sure they're green
+before starting to make your changes.
+
+Run `bundle exec rake -AD` for a full list of all the available tasks you may use for development purposes.
+
+Run `bundle exec rake` to run the tests and linter.
+
+## Examples
+
+The `examples/` directory is used as an ad-hoc integration testing method.
+[Read more here](./examples/)
+
+## Pull request checklist
+
+- [ ] Make sure the tests are passing
+- [ ] Make sure the linter is happy
+- [ ] Make sure the `examples/` look the same or have suffered and improvement
+- [ ] Update the unreleased section of the [changelog](./CHANGELOG.md) with a human readable explanation of your changes
+
+## Architecture
+
+High level description of the heuristic specdiff implements
+
+  1. receive 2 pieces of data: `a` and `b`
+  2. determine types for `a` and `b`
+      1. test against plugin types
+      2. test against built in types
+      3. fall back to the `:unknown` type
+  3. determine which differ is appropriate for the types
+      1. test against plugin differs
+      2. test against built in differs
+      3. fall back to the null differ (`NotFound`)
+  7. run the selected differ with a and b
+  8. package it into a `::Specdiff::Diff` which records the detected types
+
+  \<time passes>
+
+  6. at some point later when `#to_s` is invoked, stringify the diff using the differ's `#stringify`
+
+## Maintainer's notes
+
+### Release procedure
+
+  - [ ] unit tests are passing (`$ bundle exec rake test`)
+  - [ ] linter is happy (`$ bundle exec rake lint`)
+  - [ ] `examples/` look good
+  - [ ] check the package size using `$ bundle exec inspect_build`, make sure you haven't added any large files by accident
+  - [ ] update the version number in `version.rb`
+  - [ ] make sure the `examples/` `Gemfile.lock` files are updated (run bundle install)
+  - [ ] make sure `Gemfile.lock` is updated (run bundle install)
+  - [ ] move unreleased changes to the next version in the [changelog](./CHANGELOG.md)
+  - [ ] commit in the form "vX.X.X" and push
+  - [ ] make sure the pipeline is green
+  - [ ] `$ bundle exec rake release`
+
+### Contemplated improvements (AKA the todo list)
+
+- [ ] word diff
+- [ ] yard documentation?
+- [ ] 2.7.0 support
+- [ ] actual integration tests (replacing `examples/`)
+- [ ] real documentation for the plugin interface

data/README.md

@@ -1,36 +1,40 @@
 # Specdiff
 
-A gem for improving diff output in webmock.
+Specdiff is an opinionated gem that provides diffing between arbitrary data. It
+was built in an effort to improve [WebMock](https://rubygems.org/gems/webmock)'s
+and [RSpec](https://rubygems.org/gems/rspec)'s diff output, and
+comes with integrations for both. It produces output that looks very similiar to
+RSpec, but with better support for nested hash/array structures.
 
-Webmock currently has a somewhat hidden feature where it will produce a diff
-between a request body and a registered stub when making an unregistered request
-if they happen to both be json (including setting content type). This gem aims
-to bring text diffing (ala rspec) to webmock via monkey-patch, as well as
-dropping the content type requirement.
+By default, specdiff will produce diff output for multiline text by using
+[diff-lcs](https://rubygems.org/gems/diff-lcs):
 
-Specdiff automagically detects the types of provided data and prints a suitable
-diff between them.
+![example of multiline text](assets/specdiff_multiline_text_diff_example.png)
 
-## Cool, what does it look like?
+It also diffs hashes and arrays:
 
-When specdiff is enabled, webmock will produce a generic text diff using
-[`Diff::LCS`](https://github.com/halostatue/diff-lcs) (basically the same
-diff as rspec uses):
+| ![img](assets/specdiff_hashdiff_diff_example.png) | ![img](assets/specdiff_text_based_hash_diff_example.png) |
+| --- | --- |
+| Hashdiff based hash diff | Text based hash diff |
 
-![webmock_text_with_specdiff](./assets/webmock_text_with_specdiff.png)
+Specdiff will automatically switch between these two types of hash/array diff
+output depending on what it thinks is more readable. The first type of output
+showcased here comes from the
+[hashdiff](https://rubygems.org/gems/hashdiff) gem, one of specdiff's
+dependencies. The other is the *text diff* run on the output of *hashprint*.
+Specdiff switches to using hashprint/text diff when it estimates that a lot of
+the keys changed names, which is a point of weakness for hashdiff's output.
 
-It will also produce a json [hashdiff](https://github.com/liufengyun/hashdiff),
-even if the request did not have the content type header:
-
-![d](./assets/webmock_json_with_specdiff.png)
+## Installation
 
-(The output of the json diff is experimental, feedback would be great!)
+### Requirements
 
-You might also check out the `examples/` directory to play with it:
+Specdiff is tested to work with:
+- Ruby `>= 3.0`.
+- RSpec `3.13.0`, `3.12.2`, `3.12.0`.
+- WebMock `3.19.1`, `3.18.1`.
 
-`$ cd examples/webmock && bundle install`
-
-## Installation
+### Use bundler
 
 Add this line to your application's Gemfile:
 
@@ -40,123 +44,159 @@ gem "specdiff", require: false
 
 And then execute:
 
-    $ bundle install
-
-Or install it yourself as:
+`$ bundle install`
 
-    $ gem install specdiff
+### Loading the gem and its integrations
 
-## Usage
-
-Put the following in your `spec_helper.rb`. (Or equivalent initializer
-for test environment) You probably don't want to load/use this gem in a release
-environment.
+Put the following in the initializer for your test environment (`spec_helper.rb`):
 
 ```rb
-# spec_helper.rb
-
-require "specdiff"
-require "specdiff/webmock" # optional, webmock patches
+require "specdiff" # may be unneccessary if you're using bundler to load your gems
+require "specdiff/rspec" # optional, enables RSpec integration
+require "specdiff/webmock" # optional, enables WebMock integration
+Specdiff.load!(:json) # optional, automatically detects json and uses the hash differ on it
 
-# optionally, you can turn off terminal colors
 Specdiff.configure do |config|
-  config.colorize = true
+  config.colorize = true # toggles color output
 end
 ```
 
+The monkey-patches should go after the gems they are patching.
+
+*This gem is intended for use in test environments, not production or release environments.*
+
+## Usage
+
+Specdiff has two integrations: [WebMock](https://rubygems.org/gems/webmock) and
+[RSpec](https://rubygems.org/gems/rspec). These are the main way specdiff is
+intended to be used.
+
+### RSpec
+
+The RSpec integration improves on RSpec's built in diffing functionality by
+diffing nested hash/array structures with
+[hashdiff](https://rubygems.org/gems/hashdiff). This produces clearer
+output when deeply nested structures are involved:
+
+| ![img](assets/source_hashdiff_hash.png) | ![img](assets/rspecs_hashdiff_hash.png) | ![img](assets/specdiffs_hashdiff_hash.png) |
+| --- | --- | --- |
+| Test source | RSpec's diff | Specdiff's diff |
+
+In some cases specdiff may produce a text-based diff of deeply nested hashes or
+arrays instead. This also represents an improvement over RSpec's text-based diff
+of nested hashes/arrays, by virtue of custom pretty-printing code designed for
+the text differ to work on:
+
+| ![img](assets/source_text_hash.png) | ![img](assets/rspecs_text_hash.png) | ![img](assets/specdiffs_text_hash.png) |
+| --- | --- | --- |
+| Test source | RSpec's diff | Specdiff's diff |
+
+The RSpec integration also prevents RSpec from truncating your data before
+printing it (by replacing the inspect implementation), avoiding the necessity
+of a diff in some instances:
+
+| ![img](assets/rspec_truncating.png) | ![img](assets/specdiff_no_truncating.png) |
+| --- | --- |
+| RSpec truncating your data | Specdiff preventing truncation |
+
+(Although this is an instance where a "word diff" would be more helpful)
+
 ### WebMock
 
-The webmock patch should make webmock show request body diffs by using the
-specdiff gem when stubs mismatch. It only applies to request bodies.
+WebMock already ships with a dependency on
+[hashdiff](https://rubygems.org/gems/hashdiff), providing diffs of json request
+stubs. Specdiff prints hashdiff's output differently, and does not require the
+content type to be specified:
 
-### Direct usage
+(This requires you to enable the json plugin)
 
-You can also use the gem directly:
+| ![img](assets/webmock_json_diff_source.png) | ![img](assets/webmock_json_diff.png) | ![img](assets/webmock_json_diff_specdiff.png) |
+| --- | --- | --- |
+| Source | WebMock | Specdiff |
 
-```rb
-diff = Specdiff.diff(something, and_something_else)
+With specdiff enabled you also get text diffs where previously there were none:
 
-diff.empty? # => true/false, if it is empty you might want to not print the diff, it is probably useless
-diff.to_s # => a string for showing to a developer who may or may not be scratching their head
-```
+| ![img](assets/webmock_newlines_diff_source.png) | ![img](assets/webmock_newlines_diff.png) | ![img](assets/webmock_newlines_diff_specdiff.png) |
+| --- | --- | --- |
+| Source | WebMock | Specdiff |
 
-### Registering plugins
+The WebMock integration continues to respect the `show_body_diff` setting in
+WebMock:
 
 ```rb
-# Specdiff comes with json support, but it must be loaded like so:
-Specdiff.load!(:json)
-
-# Custom plugins can be loaded like this:
-Specdiff.load!(MyCustomType)
+# this will cause diffs to not be produced, regardless of whether specdiff is
+# loaded. body diffs are enabled by default in WebMock so you don't need to
+# touch this.
+WebMock.hide_body_diff!
 ```
 
-[Check out the source code](./lib/specdiff/plugins/json.rb) to learn the plugin interface.
+### Direct usage
 
-## Development
+It is also possible to call into specdiff with arbitrary data.
+This is essentially what the integrations do for you.
+This is suitable if you are developing a library and intend to depend on
+specdiff for diff output.
 
-Check out the [glossary](./glossary.txt) to make sure you (and I) are using the
-same words for things ;)
+```rb
+# Generate a diff, using all plugins available.
+diff = Specdiff.diff(something, anything)
 
-Install the software versions specified in `.tool-versions`.
+diff.empty? # => true/false, if true you probably don't want to actually show the diff
+diff.to_s # => a String for showing to a developer who may or may not be scratching their head
 
-Run `bin/setup` to install dependencies. Then, run `bundle exec rake` to run the tests and linter and make sure they're green before starting to make your changes.
+# Generate an indented, pretty-printed string representation of a ruby hash.
+printed_hash = Specdiff.hashprint(my_big_nested_hash)
+printed_hash # => String
+
+# Inspect something, but with prettier output for certain classes
+# (Time/DateTime/BigDecimal). This is not indented. Usually defers to #inspect.
+specdiff_inspected = Specdiff.diff_inspect(something)
+specdiff_inspected # => String
+```
 
-Run `bundle exec rake -AD` for a full list of all the available tasks you may use for development purposes.
+Any methods or properties not documented here are considered private
+implementation details.
 
-You can also run `bin/console` for an interactive prompt that will allow you to experiment with the gem code loaded.
+## Plugins
 
-Remember to update the unreleased section of the [changelog](./CHANGELOG.md) before you submit your pull request.
+It is possible to create and load plugins into specdiff to customize Specdiff's
+behaviour. This was implemented in case you have special needs (e.g. diffing
+things other than text, hashes, arrays and json).
 
-## How it works/"Architecture"
+### JSON
 
-High level description of the heuristic specdiff implements
+The built-in json plugin is optional, and loaded like so:
 
-  1. receive 2 pieces of data: `a` and `b`
-  2. determine types for `a` and `b`
-      1. test against plugin types
-      2. test against built in types
-      3. fall back to the `:unknown` type
-  3. determine which differ is appropriate for the types
-      1. test against plugin differs
-      2. test against built in differs
-      3. fall back to the null differ (`NotFound`)
-  7. run the selected differ with a and b
-  8. package it into a `::Specdiff::Diff` which records the detected types
+```rb
+Specdiff.load!(:json)
+```
 
-  \<time passes>
+The JSON plugin attempts to parse strings into json using `JSON.parse`. If
+successful, it considers that string a json, and will use the parse result as if
+it had been passed directly to specdiff in the first place.
 
-  6. at some point later when `#to_s` is invoked, stringify the diff using the differ's `#stringify`
+### Defining your own plugins
 
-## Releasing
+While other plugins are loaded by simply passing them to `::load!`:
 
-### Release procedure
+```rb
+class MySpecdiffPlugin
+  # Read the source code to figure out how plugins work. Sorry.
+end
 
-  - [ ] unit tests are passing (`$ bundle exec rake test`)
-  - [ ] linter is happy (`$ bundle exec rake lint`)
-  - [ ] `examples/` look good
-  - [ ] update the version number in `version.rb`
-  - [ ] make sure the `examples/` `Gemfile.lock` files are updated (run bundle install)
-  - [ ] make sure `Gemfile.lock` is updated (run bundle install)
-  - [ ] move unreleased changes to the next version in the [changelog](./CHANGELOG.md)
-  - [ ] commit in the form "vX.X.X" and push
-  - [ ] make sure the pipeline is green
-  - [ ] `$ bundle exec rake release`
+Specdiff.load!(MySpecdiffPlugin)
+```
 
-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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+This was intended to allow implementing (potentially janky and inefficient)
+plugins to help diff XML, but in practice the text differ was good enough for
+diffing indented XML.
 
 ## Contributing
 
+Read [DEVELOPMENT.md](./DEVELOPMENT.md) for current development practices.
+
 Bug reports and pull requests are welcome on GitHub at https://github.com/odinhb/specdiff.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## TODO
-
-This documents potential improvements/issues I know about or have thought about.
-
-- [ ] test the webmock monkey-patch. currently there is an empty webmock_spec.rb (should we do this using rspec?) and the examples/ directory contains a few webmock examples (which are a good idea to run before releasing) but it would be nice to have the pipeline fail if it doesn't work for whatever reason
-- [ ] finalize plugin interface (are the methods named intuitively? should we split type detector definitions and differ definitions?)
-- [ ] document how to define a plugin properly (instead of just linking to the source code)
-- [ ] is the stringification of hashdiff's output really better than pretty print? or just more wordy? (the colors are definitely nice)

data/glossary.txt

@@ -44,3 +44,7 @@ side
 compare
   the procedure that implements the main function of specdiff including
   accounting for any plugin types and differs
+
+integration
+  refers to the provided monkey-patches and conscious relationship between
+  specdiff and another gem or piece of software it was intended to work with.

data/lib/specdiff/compare.rb

@@ -80,9 +80,9 @@ private
     elsif a.type == :text && b.type == :text
       Specdiff::Differ::Text
     elsif a.type == :hash && b.type == :hash
-      Specdiff::Differ::Hashdiff
+      Specdiff::Differ::Hash
     elsif a.type == :array && b.type == :array
-      Specdiff::Differ::Hashdiff
+      Specdiff::Differ::Hash
     else
       Specdiff::Differ::NotFound
     end

data/lib/specdiff/diff.rb

@@ -19,12 +19,15 @@
   end
 
   def inspect
-    if empty?
-      "<Specdiff::Diff (empty)>"
-    elsif raw.respond_to?(:bytesize)
-      "<Specdiff::Diff w/ #{raw&.bytesize || 0} bytes of #raw diff>"
-    else
-      "<Specdiff::Diff #{raw.inspect}>"
-    end
+    raw_diff = if empty?
+                 "empty"
+               elsif differ == ::Specdiff::Differ::Text
+                 bytes = raw&.bytesize || 0
+                 "#{bytes} bytes of #raw diff"
+               else
+                 "#{raw.inspect}"
+               end
+
+    "<Specdiff::Diff (#{a.type}/#{b.type}) (#{differ}) (#{raw_diff})>"
   end
 end

data/lib/specdiff/differ/{hashdiff.rb → hash.rb}

@@ -1,19 +1,27 @@
 require "hashdiff"
 
-class Specdiff::Differ::Hashdiff
+class Specdiff::Differ::Hash
   extend ::Specdiff::Colorize
 
-  VALUE_CHANGE_PERCENTAGE_THRESHOLD = 0.2
-  TOTAL_CHANGES_FOR_GROUPING_THRESHOLD = 9
+  # The percentage of changes that must (potentially) be a key rename in a hash
+  # for text diffing to kick in. Expressed as a fraction of 1.
+  KEY_CHANGE_PERCENTAGE_THRESHOLD = 0.8
 
-  NEWLINE = "\n"
+  # The number of changes that must be detected by hashdiff before we print some
+  # extra newlines to better group extra/missing/new_values visually.
+  TOTAL_CHANGES_FOR_GROUPING_THRESHOLD = 9
 
   def self.diff(a, b)
     # array_path: true returns the path as an array, which differentiates
     # between symbol keys and string keys in hashes, while the string
     # representation does not.
+
     # hmm it really seems like use_lcs: true gives much less human-readable
     # (human-comprehensible) output when arrays are involved.
+
+    # use_lcs: true may also cause Hashdiff to use a lot of memory when BIG
+    # arrays are involved: https://github.com/liufengyun/hashdiff/issues/49
+    # so we might as well avoid that problem altogether.
     hashdiff_diff = ::Hashdiff.diff(
       a.value, b.value,
       array_path: true,
@@ -24,54 +32,60 @@ class Specdiff::Differ::Hashdiff
 
     change_percentage = _calculate_change_percentage(hashdiff_diff)
 
-    if change_percentage >= VALUE_CHANGE_PERCENTAGE_THRESHOLD
+    if change_percentage <= KEY_CHANGE_PERCENTAGE_THRESHOLD
       hashdiff_diff
     else
       a_text = ::Specdiff.hashprint(a.value)
       b_text = ::Specdiff.hashprint(b.value)
 
-      diff = ::Specdiff.diff(a_text, b_text)
+      text_diff = ::Specdiff.diff(a_text, b_text)
 
-      if diff.empty?
+      if text_diff.empty?
         []
       else
-        diff.a.type = a.type
-        diff.b.type = b.type
-
-        diff
+        text_diff
       end
     end
   end
 
   def self._calculate_change_percentage(hashdiff_diff)
-    value_change_count = hashdiff_diff.count { |element| element[0] == "~" }
-    addition_count = hashdiff_diff.count { |element| element[0] == "+" }
-    deletion_count = hashdiff_diff.count { |element| element[0] == "-" }
+    extra_keys = hashdiff_diff.count { |element| element[0] == "+" }
+    missing_keys = hashdiff_diff.count { |element| element[0] == "-" }
+    new_values = hashdiff_diff.count { |element| element[0] == "~" }
     # puts "hashdiff_diff: #{hashdiff_diff.inspect}"
-    # puts "value_change_count: #{value_change_count.inspect}"
-    # puts "addition_count: #{addition_count.inspect}"
-    # puts "deletion_count: #{deletion_count.inspect}"
-
-    total_number_of_changes = [
-      value_change_count,
-      addition_count,
-      deletion_count,
-    ].sum
-
-    change_fraction = Rational(value_change_count, total_number_of_changes)
-    change_percentage = change_fraction.to_f
-    # puts "change_fraction: #{change_fraction.inspect}"
-    # puts "change_percentage: #{change_percentage.inspect}"
-
-    change_percentage
+    # puts "extra_keys: #{extra_keys.inspect}"
+    # puts "missing_keys: #{missing_keys.inspect}"
+    # puts "new_values: #{new_values.inspect}"
+
+    potential_changed_keys = [extra_keys, missing_keys].min
+    adjusted_extra_keys = extra_keys - potential_changed_keys
+    adjusted_missing_keys = missing_keys - potential_changed_keys
+    # puts "potential_changed_keys: #{potential_changed_keys.inspect}"
+    # puts "adjusted_extra_keys: #{adjusted_extra_keys.inspect}"
+    # puts "adjusted_missing_keys: #{adjusted_missing_keys.inspect}"
+
+    non_changed_keys = adjusted_extra_keys + adjusted_missing_keys + new_values
+    total_changes = non_changed_keys + potential_changed_keys
+    # puts "non_changed_keys: #{non_changed_keys.inspect}"
+    # puts "total_changes: #{total_changes.inspect}"
+
+    key_change_fraction = Rational(potential_changed_keys, total_changes)
+    key_change_percentage = key_change_fraction.to_f
+    # puts "key_change_fraction: #{key_change_fraction.inspect}"
+    # puts "key_change_percentage: #{key_change_percentage.inspect}"
+
+    key_change_percentage
   end
 
   def self.empty?(diff)
     diff.raw.empty?
   end
 
+  NEWLINE = "\n"
+
   def self.stringify(diff)
     result = +""
+    return result if diff.empty?
 
     total_changes = diff.raw.size
     group_with_newlines = total_changes >= TOTAL_CHANGES_FOR_GROUPING_THRESHOLD
@@ -92,6 +106,9 @@ class Specdiff::Differ::Hashdiff
     additions = changes_grouped_by_type["+"] || []
     value_changes = changes_grouped_by_type["~"] || []
 
+    result << "@@ +#{additions.size}/-#{deletions.size}/~#{value_changes.size} @@"
+    result << NEWLINE
+
     deletions.each do |change|
       value = change[2]
       path = _stringify_path(change[1])
@@ -108,7 +125,7 @@ class Specdiff::Differ::Hashdiff
       value = change[2]
       path = _stringify_path(change[1])
 
-      result << "    new key: #{path} (#{::Specdiff.diff_inspect(value)})"
+      result << "  extra key: #{path} (#{::Specdiff.diff_inspect(value)})"
       result << NEWLINE
     end
 
@@ -123,17 +140,19 @@ class Specdiff::Differ::Hashdiff
 
       from_inspected = ::Specdiff.diff_inspect(from)
       to_inspected = ::Specdiff.diff_inspect(to)
-      result << "changed key: #{path} (#{from_inspected} -> #{to_inspected})"
+      result << "  new value: #{path} (#{from_inspected} -> #{to_inspected})"
       result << NEWLINE
     end
 
     colorize_by_line(result) do |line|
       if line.start_with?("missing key:")
         red(line)
-      elsif line.start_with?(/\s+new key:/)
+      elsif line.start_with?("  extra key:")
         green(line)
-      elsif line.start_with?("changed key:")
+      elsif line.start_with?("  new value:")
         yellow(line)
+      elsif line.start_with?("@@")
+        cyan(line)
       else
         reset_color(line)
       end

data/lib/specdiff/differ.rb

@@ -4,4 +4,4 @@ end
 # require only the builtin differs, plugins are optionally loaded later
 require_relative "differ/not_found"
 require_relative "differ/text"
-require_relative "differ/hashdiff"
+require_relative "differ/hash"