super_diff 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8efa30260e2d32c10ea6571d37a393756b216c1ba2c991d28a4124a0822c7e6f
-  data.tar.gz: a98a146c39eda8aeb3735869ffadacb279c26b76f2bf3f4b2ebc212fd6e8dbe1
+  metadata.gz: 7325f6b92497f0f81a67431c8e6581fc165b3f3dff4f01b2d18bcfabaab648ec
+  data.tar.gz: c358e94ecaab9d20b22cb7f3d60315057b6cdf1e415a902d1ae402529344beb4
 SHA512:
-  metadata.gz: a0fdf3017f5a38865bb8cfbb15dfacf3a070f42c23883a6821b39a4b2bb00da3c9beb1e65c417b5094693ab14de18edf9934f23c7f242849cc2dfb950ee60649
-  data.tar.gz: 6484896862126281d2f051d7ef17b760426083bfba3f9ba7f93936f331dca3cee187cbd8e75e46e6a9f86cbcd17d38e47fd9c2096a7ffdb6dc4290bed763c92f
+  metadata.gz: f32b832ab5647a3f6a73319e4a95e5b0ee3e346046c0b1ac4046169a439d9474d6f1ac37c791a9851f66070f82941d1a3520fdf477a57c828bf4945edab1994b
+  data.tar.gz: 042406c46094b4c0d9b5b1c88870e899672851b9a03f31cfec702d2119e5a73db6f23209e206a0b9b450336d288c2c62c1dfe62cb58f1701ad24498dd7540098

data/README.md

@@ -7,32 +7,33 @@
 [hound-badge]: https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg
 [hound]: https://houndci.com
 
-SuperDiff is a gem that hooks into RSpec to intelligently display the
-differences between two data structures of any type.
+SuperDiff is a gem that hooks into RSpec
+to intelligently display the differences between two data structures of any type.
 
-📢 **[See what's changed in the latest version (0.3.0)][changelog].**
+📢 **[See what's changed in the latest version (0.4.1)][changelog].**
 
 [changelog]: CHANGELOG.md
 
 ## Introduction
 
-The primary motivation behind this gem is to vastly improve upon RSpec's
-built-in diffing capabilities.
+The primary motivation behind this gem
+is to vastly improve upon RSpec's built-in diffing capabilities.
 
-Sometimes, whenever you use a matcher such as `eq`, `match`, `include`, or
-`have_attributes`, you will get a diff of the two data structures you are trying
-to match against. This is great if all you want to do is compare multi-line
-strings. But if you want to compare other, more "real world" kinds of values —
-nested data structures (arrays, hashes, and full-scale objects), such as what
-you might work with when developing API endpoints or testing methods that make
-database calls and return a set of model objects — then you are out of luck.
-Since [RSpec merely runs your `expected` and `actual` values through Ruby's
-PrettyPrinter library][rspec-differ-fail] and then performs a diff of these
-strings, the output it produces leaves much to be desired.
+Sometimes, whenever you use a matcher such as `eq`, `match`, `include`, or `have_attributes`,
+you will get a diff of the two data structures you are trying to match against.
+This is great if all you want to do is compare multi-line strings.
+But if you want to compare other, more "real world" kinds of values,
+such as what you might work with when developing API endpoints
+or testing methods that make database calls and return a set of model objects,
+then you are out of luck.
+Since [RSpec merely runs your `expected` and `actual` values through Ruby's PrettyPrinter library][rspec-differ-fail]
+and then performs a diff of these strings,
+the output it produces leaves much to be desired.
 
 [rspec-differ-fail]: https://github.com/rspec/rspec-support/blob/c69a231d7369dd165ad7ce4742e1a2e21e3462b5/lib/rspec/support/differ.rb#L178
 
-For instance, let's say you wanted to compare these two hashes:
+For instance,
+let's say you wanted to compare these two hashes:
 
 ``` ruby
 actual = {
@@ -86,36 +87,60 @@ You would get output that looks like this:
 
 ![Before super_diff](doc/before.png)
 
-What this library does is to provide a diff engine that knows how to figure out
-the differences between any two data structures and display them in a sensible
-way. So, using the example above, you'd get this instead:
+What this library does
+is to provide a diff engine
+that knows how to figure out the differences between any two data structures
+and display them in a sensible way.
+So, using the example above,
+you'd get this instead:
 
 ![After super_diff](doc/after.png)
 
 ## Installation
 
-Want to try out this gem for yourself? As with most development-related gems,
-there are a couple ways depending on your type of project:
+There are a few different ways to install `super_diff`
+depending on your type of project.
 
 ### Rails apps
 
-If you're developing a Rails app, add the following to your Gemfile:
+If you're developing a Rails app,
+add the following to your Gemfile:
 
 ``` ruby
-gem "super_diff"
+group :test do
+  gem "super_diff"
+end
 ```
 
-After running `bundle install`, add the following to your `rails_helper`:
+After running `bundle install`,
+add the following to your `rails_helper`:
 
 ``` ruby
 require "super_diff/rspec-rails"
 ```
 
-You're done!
+### Projects using some part of Rails (e.g. ActiveModel)
 
-### Libraries
+If you're developing an app using Hanami or Sinatra,
+or merely using a part of Rails such as ActiveModel,
+add the following to your Gemfile where appropriate:
 
-If you're developing a library, add the following to your gemspec:
+``` ruby
+gem "super_diff"
+```
+
+After running `bundle install`,
+add the following to your `spec_helper`:
+
+``` ruby
+require "super_diff/rspec"
+require "super_diff/active_support"
+```
+
+### Gems
+
+If you're developing a gem,
+add the following to your gemspec:
 
 ``` ruby
 spec.add_development_dependency "super_diff"
@@ -127,14 +152,16 @@ Now add the following to your `spec_helper`:
 require "super_diff/rspec"
 ```
 
-You're done!
-
 ## Configuration
 
-As capable as this library is, it doesn't know how to deal with every kind of
-object out there. You might find it necessary to instruct the gem on how to diff
-your object. To do this, you can use a configuration block. Simply add this to
-your test helper file (`rails_helper` or `spec_helper`):
+As capable as this library is,
+it doesn't know how to deal with every kind of object out there.
+If you have a custom class,
+and instances of your class aren't appearing in diffs like you like,
+you might find it necessary to instruct the gem on how to handle them.
+In that case
+you would add something like this to your test helper file
+(`rails_helper` or `spec_helper`):
 
 ``` ruby
 SuperDiff::RSpec.configure do |config|
@@ -144,55 +171,45 @@ SuperDiff::RSpec.configure do |config|
 end
 ```
 
-*(More info here in the future on adding a custom differ, operational sequencer,
-and diff formatter. Also explanations on what these are.)*
+*(More info here in the future on adding a custom differ, operational sequencer, and diff formatter.
+Also explanations on what these are.)*
 
-## Contributing
-
-If you encounter a bug or have an idea for how this could be better, feel free
-to [create an issue](https://github.com/mcmire/super_diff/issues).
-
-If you'd like to submit a PR instead, here's how to get started. First, fork
-this repo. Then, when you've cloned your fork, run:
-
-```
-bin/setup
-```
+## Support
 
-This will install various dependencies. After this, you can run all of the
-tests:
+My goal for this library is to improve your development experience.
+If this is not the case,
+and you encounter a bug or have a suggestion,
+feel free to [create an issue][issues-list].
+I'll try to respond to it as soon as I can!
 
-```
-bundle exec rake
-```
-
-If you update one of the tests, you can run it like so:
+[issues-list]: https://github.com/mcmire/super_diff/issues
 
-```
-bin/rspec spec/integration/...
-bin/rspec spec/unit/...
-```
+## Contributing
 
-Finally, submit your PR and I'll take a look at it when I get a chance.
+Any contributions to improve this library are welcome!
+Please see the [contributing](./CONTRIBUTING.md) document for more on how to do that.
 
 ## Compatibility
 
-`super_diff` is [tested][travis] to work with Ruby >= 2.4.x, RSpec 3.x, and
-Rails >= 5.x.
+`super_diff` is [tested][travis] to work with
+Ruby >= 2.4.x,
+RSpec 3.x,
+and Rails >= 5.x.
 
 [travis]: http://travis-ci.org/mcmire/super_diff
 
 ## Inspiration/Thanks
 
-In developing this gem I made use of or was heavily inspired by these libraries:
+In developing this gem
+I made use of or was heavily inspired by these libraries:
 
-* [Diff::LCS][diff-lcs], the library I started with in the [original version of
-  this gem][original-version] (made in 2011!)
-* The pretty-printing algorithms and API within [PrettyPrinter][pretty-printer]
-  and [AwesomePrint][awesome-print], from which I borrowed ideas to develop
-  the [inspectors][inspection-tree].
+* [Diff::LCS][diff-lcs],
+  the library I started with in the [original version of this gem][original-version]
+  (made in 2011!)
+* The pretty-printing algorithms and API within [PrettyPrinter][pretty-printer] and [AwesomePrint][awesome-print],
+  from which I borrowed ideas to develop the [inspectors][inspection-tree].
 
-Thank you so much!
+Thank you to the authors of these libraries!
 
 [original-version]: https://github.com/mcmire/super_diff/tree/old-master
 [diff-lcs]: https://github.com/halostatue/diff-lcs
@@ -200,6 +217,7 @@ Thank you so much!
 [awesome-print]: https://github.com/awesome-print/awesome_print
 [inspection-tree]: https://github.com/mcmire/super_diff/blob/master/lib/super_diff/object_inspection/inspection_tree.rb
 
-## Copyright/License
+## Author/License
 
-© 2018-2019 Elliot Winkler, released under the [MIT license](LICENSE).
+`super_diff` was created and is maintained by Elliot Winkler.
+It is released under the [MIT license](LICENSE).

data/lib/super_diff/rspec/monkey_patches.rb

@@ -91,10 +91,12 @@ module RSpec
           @skip_shared_group_trace = options.fetch(:skip_shared_group_trace, false)
           # Patch to convert options[:failure_lines] to groups
           if options.include?(:failure_lines)
-            @failure_line_groups = {
-              lines: options[:failure_lines],
-              already_colorized: false
-            }
+            @failure_line_groups = [
+              {
+                lines: options[:failure_lines],
+                already_colorized: false
+              }
+            ]
           end
         end
 

data/lib/super_diff/version.rb

@@ -1,3 +1,3 @@
 module SuperDiff
-  VERSION = "0.4.0".freeze
+  VERSION = "0.4.1".freeze
 end

data/spec/examples.txt

@@ -0,0 +1,5 @@
+example_id                                                 | status | run_time       |
+---------------------------------------------------------- | ------ | -------------- |
+./spec/integration/rspec/unhandled_errors_spec.rb[1:1:1:1] | passed | 1.28 seconds   |
+./spec/integration/rspec/unhandled_errors_spec.rb[1:1:2:1] | passed | 1.31 seconds   |
+./spec/integration/rspec/unhandled_errors_spec.rb[1:2:1]   | failed | 0.7241 seconds |

data/spec/integration/rspec/unhandled_errors_spec.rb

@@ -66,4 +66,25 @@ RSpec.describe "Integration with RSpec and unhandled errors", type: :integration
       end
     end
   end
+
+  context "when multiple exception occur" do
+    it "highlights the first line in red, and then leaves the rest of the message alone" do
+      as_both_colored_and_uncolored do |color_enabled|
+        program = <<~PROGRAM.strip
+          #{set_up_with("super_diff/rspec", color_enabled: color_enabled)}
+          RSpec.describe "test" do
+            after(:each) do
+              raise "Some kind of after error or whatever\\n\\nThis is another line"
+            end
+            it "passes" do
+              raise "Some kind of error or whatever\\n\\nThis is another line"
+            end
+          end
+        PROGRAM
+
+        expect(program).
+          to produce_output_when_run('Some kind of after error or whatever')
+      end
+    end
+  end
 end

data/spec/support/shared_examples/hash_with_indifferent_access.rb

@@ -1,115 +1,373 @@
 shared_examples_for "integration with HashWithIndifferentAccess" do
   describe "and RSpec's #eq matcher" do
     context "when the actual value is a HashWithIndifferentAccess" do
-      it "produces the correct output" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = {
-              line_1: "123 Main St.",
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382",
-            }
-            actual = HashWithIndifferentAccess.new({
-              line_1: "456 Ponderosa Ct.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234",
-            })
-            expect(actual).to eq(expected)
-          TEST
-          program = make_rspec_rails_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: "expect(actual).to eq(expected)",
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
-              end
-
-              line do
-                plain "   to eq "
-                alpha %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
-              end
-            },
-            diff: proc {
-              plain_line %|  #<HashWithIndifferentAccess {|
-              alpha_line %|-   "line_1" => "123 Main St.",|
-              beta_line %|+   "line_1" => "456 Ponderosa Ct.",|
-              alpha_line %|-   "city" => "Hill Valley",|
-              beta_line %|+   "city" => "Oakland",|
-              plain_line %|    "state" => "CA",|
-              alpha_line %|-   "zip" => "90382"|
-              beta_line %|+   "zip" => "91234"|
-              plain_line %|  }>|
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+      context "and both hashes are one-dimensional" do
+        context "and the expected hash contains symbol keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382",
+                }
+                actual = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                expect(actual).to eq(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to eq(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+
+                  line do
+                    plain "   to eq "
+                    alpha %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "123 Main St.",|
+                  beta_line  %|+   "line_1" => "456 Ponderosa Ct.",|
+                  alpha_line %|-   "city" => "Hill Valley",|
+                  beta_line  %|+   "city" => "Oakland",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "90382"|
+                  beta_line  %|+   "zip" => "91234"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the expected hash contains string keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = {
+                  "line_1" => "123 Main St.",
+                  "city" => "Hill Valley",
+                  "state" => "CA",
+                  "zip" => "90382",
+                }
+                actual = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                expect(actual).to eq(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to eq(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+
+                  line do
+                    plain "   to eq "
+                    alpha %|{ "line_1" => "123 Main St.", "city" => "Hill Valley", "state" => "CA", "zip" => "90382" }|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "123 Main St.",|
+                  beta_line  %|+   "line_1" => "456 Ponderosa Ct.",|
+                  alpha_line %|-   "city" => "Hill Valley",|
+                  beta_line  %|+   "city" => "Oakland",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "90382"|
+                  beta_line  %|+   "zip" => "91234"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
         end
       end
     end
 
     context "when the expected value is a HashWithIndifferentAccess" do
-      it "produces the correct output" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = HashWithIndifferentAccess.new({
-              line_1: "456 Ponderosa Ct.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234",
-            })
-            actual = {
-              line_1: "123 Main St.",
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382",
-            }
-            expect(actual).to eq(expected)
-          TEST
-          program = make_rspec_rails_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: "expect(actual).to eq(expected)",
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
-              end
-
-              line do
-                plain "   to eq "
-                alpha %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
-              end
-            },
-            diff: proc {
-              plain_line %|  #<HashWithIndifferentAccess {|
-              alpha_line %|-   "line_1" => "456 Ponderosa Ct.",|
-              beta_line %|+   "line_1" => "123 Main St.",|
-              alpha_line %|-   "city" => "Oakland",|
-              beta_line %|+   "city" => "Hill Valley",|
-              plain_line %|    "state" => "CA",|
-              alpha_line %|-   "zip" => "91234"|
-              beta_line %|+   "zip" => "90382"|
-              plain_line %|  }>|
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+      context "and both hashes are one-dimensional" do
+        context "and the actual hash contains symbol keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                actual = {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382",
+                }
+                expect(actual).to eq(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to eq(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
+                  end
+
+                  line do
+                    plain "   to eq "
+                    alpha %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "456 Ponderosa Ct.",|
+                  beta_line  %|+   "line_1" => "123 Main St.",|
+                  alpha_line %|-   "city" => "Oakland",|
+                  beta_line  %|+   "city" => "Hill Valley",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "91234"|
+                  beta_line  %|+   "zip" => "90382"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the actual hash contains string keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                actual = {
+                  "line_1" => "123 Main St.",
+                  "city" => "Hill Valley",
+                  "state" => "CA",
+                  "zip" => "90382",
+                }
+                expect(actual).to eq(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to eq(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ "line_1" => "123 Main St.", "city" => "Hill Valley", "state" => "CA", "zip" => "90382" }|
+                  end
+
+                  line do
+                    plain "   to eq "
+                    alpha %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "456 Ponderosa Ct.",|
+                  beta_line  %|+   "line_1" => "123 Main St.",|
+                  alpha_line %|-   "city" => "Oakland",|
+                  beta_line  %|+   "city" => "Hill Valley",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "91234"|
+                  beta_line  %|+   "zip" => "90382"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+
+      context "and both hashes are multi-dimensional" do
+        context "and the actual hash contains symbol keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
+                actual = {
+                  shipments: [
+                    {
+                      estimated_delivery: {
+                        from: '2019-05-06',
+                        to: '2019-05-09'
+                      }
+                    }
+                  ]
+                }
+                expect(actual).to eq(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to eq(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ shipments: [{ estimated_delivery: { from: "2019-05-06", to: "2019-05-09" } }] }|
+                  end
+
+                  line do
+                    plain "   to eq "
+                    alpha %|#<HashWithIndifferentAccess { "shipments" => [#<HashWithIndifferentAccess { "estimated_delivery" => #<HashWithIndifferentAccess { "from" => "2019-05-06", "to" => "2019-05-06" }> }>] }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  plain_line %|    "shipments" => [|
+                  plain_line %|      {|
+                  plain_line %|        "estimated_delivery" => {|
+                  plain_line %|          "from" => "2019-05-06",|
+                  alpha_line %|-         "to" => "2019-05-06"|
+                  beta_line  %|+         "to" => "2019-05-09"|
+                  plain_line %|        }|
+                  plain_line %|      }|
+                  plain_line %|    ]|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the actual hash contains string keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
+                actual = {
+                  'shipments' => [
+                    {
+                      'estimated_delivery' => {
+                        'from' => '2019-05-06',
+                        'to' => '2019-05-09'
+                      }
+                    }
+                  ]
+                }
+                expect(actual).to eq(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to eq(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ "shipments" => [{ "estimated_delivery" => { "from" => "2019-05-06", "to" => "2019-05-09" } }] }|
+                  end
+
+                  line do
+                    plain "   to eq "
+                    alpha %|#<HashWithIndifferentAccess { "shipments" => [#<HashWithIndifferentAccess { "estimated_delivery" => #<HashWithIndifferentAccess { "from" => "2019-05-06", "to" => "2019-05-06" }> }>] }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  plain_line %|    "shipments" => [|
+                  plain_line %|      {|
+                  plain_line %|        "estimated_delivery" => {|
+                  plain_line %|          "from" => "2019-05-06",|
+                  alpha_line %|-         "to" => "2019-05-06"|
+                  beta_line  %|+         "to" => "2019-05-09"|
+                  plain_line %|        }|
+                  plain_line %|      }|
+                  plain_line %|    ]|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
         end
       end
     end
@@ -117,115 +375,373 @@ shared_examples_for "integration with HashWithIndifferentAccess" do
 
   describe "and RSpec's #match matcher" do
     context "when the actual value is a HashWithIndifferentAccess" do
-      it "produces the correct output" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = {
-              line_1: "123 Main St.",
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382",
-            }
-            actual = HashWithIndifferentAccess.new({
-              line_1: "456 Ponderosa Ct.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234",
-            })
-            expect(actual).to match(expected)
-          TEST
-          program = make_rspec_rails_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: "expect(actual).to match(expected)",
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
-              end
-
-              line do
-                plain "to match "
-                alpha %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
-              end
-            },
-            diff: proc {
-              plain_line %|  #<HashWithIndifferentAccess {|
-              alpha_line %|-   "line_1" => "123 Main St.",|
-              beta_line %|+   "line_1" => "456 Ponderosa Ct.",|
-              alpha_line %|-   "city" => "Hill Valley",|
-              beta_line %|+   "city" => "Oakland",|
-              plain_line %|    "state" => "CA",|
-              alpha_line %|-   "zip" => "90382"|
-              beta_line %|+   "zip" => "91234"|
-              plain_line %|  }>|
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+      context "and both hashes are one-dimensional" do
+        context "and the expected hash contains symbol keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382",
+                }
+                actual = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                expect(actual).to match(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to match(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+
+                  line do
+                    plain "to match "
+                    alpha %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "123 Main St.",|
+                  beta_line  %|+   "line_1" => "456 Ponderosa Ct.",|
+                  alpha_line %|-   "city" => "Hill Valley",|
+                  beta_line  %|+   "city" => "Oakland",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "90382"|
+                  beta_line  %|+   "zip" => "91234"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the expected hash contains string keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = {
+                  "line_1" => "123 Main St.",
+                  "city" => "Hill Valley",
+                  "state" => "CA",
+                  "zip" => "90382",
+                }
+                actual = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                expect(actual).to match(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to match(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+
+                  line do
+                    plain "to match "
+                    alpha %|{ "line_1" => "123 Main St.", "city" => "Hill Valley", "state" => "CA", "zip" => "90382" }|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "123 Main St.",|
+                  beta_line  %|+   "line_1" => "456 Ponderosa Ct.",|
+                  alpha_line %|-   "city" => "Hill Valley",|
+                  beta_line  %|+   "city" => "Oakland",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "90382"|
+                  beta_line  %|+   "zip" => "91234"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
         end
       end
     end
 
     context "when the expected value is a HashWithIndifferentAccess" do
-      it "produces the correct output" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = HashWithIndifferentAccess.new({
-              line_1: "456 Ponderosa Ct.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234",
-            })
-            actual = {
-              line_1: "123 Main St.",
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382",
-            }
-            expect(actual).to match(expected)
-          TEST
-          program = make_rspec_rails_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: "expect(actual).to match(expected)",
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
-              end
-
-              line do
-                plain "to match "
-                alpha %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
-              end
-            },
-            diff: proc {
-              plain_line %|  #<HashWithIndifferentAccess {|
-              alpha_line %|-   "line_1" => "456 Ponderosa Ct.",|
-              beta_line %|+   "line_1" => "123 Main St.",|
-              alpha_line %|-   "city" => "Oakland",|
-              beta_line %|+   "city" => "Hill Valley",|
-              plain_line %|    "state" => "CA",|
-              alpha_line %|-   "zip" => "91234"|
-              beta_line %|+   "zip" => "90382"|
-              plain_line %|  }>|
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+      context "and both hashes are one-dimensional" do
+        context "and the actual hash contains symbol keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                actual = {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382",
+                }
+                expect(actual).to match(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to match(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" }|
+                  end
+
+                  line do
+                    plain "to match "
+                    alpha %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "456 Ponderosa Ct.",|
+                  beta_line  %|+   "line_1" => "123 Main St.",|
+                  alpha_line %|-   "city" => "Oakland",|
+                  beta_line  %|+   "city" => "Hill Valley",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "91234"|
+                  beta_line  %|+   "zip" => "90382"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the actual hash contains string keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Oakland",
+                  state: "CA",
+                  zip: "91234",
+                })
+                actual = {
+                  "line_1" => "123 Main St.",
+                  "city" => "Hill Valley",
+                  "state" => "CA",
+                  "zip" => "90382",
+                }
+                expect(actual).to match(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to match(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ "line_1" => "123 Main St.", "city" => "Hill Valley", "state" => "CA", "zip" => "90382" }|
+                  end
+
+                  line do
+                    plain "to match "
+                    alpha %|#<HashWithIndifferentAccess { "line_1" => "456 Ponderosa Ct.", "city" => "Oakland", "state" => "CA", "zip" => "91234" }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  alpha_line %|-   "line_1" => "456 Ponderosa Ct.",|
+                  beta_line  %|+   "line_1" => "123 Main St.",|
+                  alpha_line %|-   "city" => "Oakland",|
+                  beta_line  %|+   "city" => "Hill Valley",|
+                  plain_line %|    "state" => "CA",|
+                  alpha_line %|-   "zip" => "91234"|
+                  beta_line  %|+   "zip" => "90382"|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+
+      context "and both hashes are multi-dimensional" do
+        context "and the actual hash contains symbol keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
+                actual = {
+                  shipments: [
+                    {
+                      estimated_delivery: {
+                        from: '2019-05-06',
+                        to: '2019-05-09'
+                      }
+                    }
+                  ]
+                }
+                expect(actual).to match(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to match(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ shipments: [{ estimated_delivery: { from: "2019-05-06", to: "2019-05-09" } }] }|
+                  end
+
+                  line do
+                    plain "to match "
+                    alpha %|#<HashWithIndifferentAccess { "shipments" => [#<HashWithIndifferentAccess { "estimated_delivery" => #<HashWithIndifferentAccess { "from" => "2019-05-06", "to" => "2019-05-06" }> }>] }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  plain_line %|    "shipments" => [|
+                  plain_line %|      {|
+                  plain_line %|        "estimated_delivery" => {|
+                  plain_line %|          "from" => "2019-05-06",|
+                  alpha_line %|-         "to" => "2019-05-06"|
+                  beta_line  %|+         "to" => "2019-05-09"|
+                  plain_line %|        }|
+                  plain_line %|      }|
+                  plain_line %|    ]|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the actual hash contains string keys" do
+          it "produces the correct output" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expected = HashWithIndifferentAccess.new({
+                  shipments: [
+                    HashWithIndifferentAccess.new({
+                      estimated_delivery: HashWithIndifferentAccess.new({
+                        from: '2019-05-06',
+                        to: '2019-05-06'
+                      })
+                    })
+                  ]
+                })
+                actual = {
+                  'shipments' => [
+                    {
+                      'estimated_delivery' => {
+                        'from' => '2019-05-06',
+                        'to' => '2019-05-09'
+                      }
+                    }
+                  ]
+                }
+                expect(actual).to match(expected)
+              TEST
+              program = make_rspec_rails_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: "expect(actual).to match(expected)",
+                expectation: proc {
+                  line do
+                    plain "Expected "
+                    beta %|{ "shipments" => [{ "estimated_delivery" => { "from" => "2019-05-06", "to" => "2019-05-09" } }] }|
+                  end
+
+                  line do
+                    plain "to match "
+                    alpha %|#<HashWithIndifferentAccess { "shipments" => [#<HashWithIndifferentAccess { "estimated_delivery" => #<HashWithIndifferentAccess { "from" => "2019-05-06", "to" => "2019-05-06" }> }>] }>|
+                  end
+                },
+                diff: proc {
+                  plain_line %|  #<HashWithIndifferentAccess {|
+                  plain_line %|    "shipments" => [|
+                  plain_line %|      {|
+                  plain_line %|        "estimated_delivery" => {|
+                  plain_line %|          "from" => "2019-05-06",|
+                  alpha_line %|-         "to" => "2019-05-06"|
+                  beta_line  %|+         "to" => "2019-05-09"|
+                  plain_line %|        }|
+                  plain_line %|      }|
+                  plain_line %|    ]|
+                  plain_line %|  }>|
+                },
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
         end
       end
     end