super_diff 0.4.0 → 0.5.2

data/lib/super_diff/rspec/object_inspection/inspectors/hash_including.rb

@@ -2,18 +2,28 @@ module SuperDiff
   module RSpec
     module ObjectInspection
       module Inspectors
-        HashIncluding = SuperDiff::ObjectInspection::InspectionTree.new do
-          add_text "#<a hash including ("
-
-          nested do |aliased_matcher|
-            insert_hash_inspection_of(
-              aliased_matcher.expecteds.first,
-              initial_break: nil,
-            )
+        class HashIncluding < SuperDiff::ObjectInspection::Inspectors::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_hash_including_something?(value)
           end
 
-          add_break
-          add_text ")>"
+          protected
+
+          def inspection_tree
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text "#<a hash including ("
+
+              nested do |aliased_matcher|
+                insert_hash_inspection_of(
+                  aliased_matcher.expecteds.first,
+                  initial_break: nil,
+                )
+              end
+
+              add_break
+              add_text ")>"
+            end
+          end
         end
       end
     end

data/lib/super_diff/rspec/object_inspection/inspectors/instance_of.rb

@@ -0,0 +1,23 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module Inspectors
+        class InstanceOf < SuperDiff::ObjectInspection::Inspectors::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.an_instance_of_something?(value)
+          end
+
+          protected
+
+          def inspection_tree
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text do |aliased_matcher|
+                "#<an instance of #{aliased_matcher.expected}>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspectors/kind_of.rb

@@ -0,0 +1,23 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module Inspectors
+        class KindOf < SuperDiff::ObjectInspection::Inspectors::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_kind_of_something?(value)
+          end
+
+          protected
+
+          def inspection_tree
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text do |aliased_matcher|
+                "#<a kind of #{aliased_matcher.expected}>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspectors/object_having_attributes.rb

@@ -2,20 +2,29 @@ module SuperDiff
   module RSpec
     module ObjectInspection
       module Inspectors
-        ObjectHavingAttributes =
-          SuperDiff::ObjectInspection::InspectionTree.new do
-            add_text "#<an object having attributes ("
+        class ObjectHavingAttributes < SuperDiff::ObjectInspection::Inspectors::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.an_object_having_some_attributes?(value)
+          end
 
-            nested do |aliased_matcher|
-              insert_hash_inspection_of(
-                aliased_matcher.expected,
-                initial_break: nil,
-              )
-            end
+          protected
+
+          def inspection_tree
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text "#<an object having attributes ("
 
-            add_break
-            add_text ")>"
+              nested do |aliased_matcher|
+                insert_hash_inspection_of(
+                  aliased_matcher.expected,
+                  initial_break: nil,
+                )
+              end
+
+              add_break
+              add_text ")>"
+            end
           end
+        end
       end
     end
   end

data/lib/super_diff/rspec/object_inspection/inspectors/primitive.rb

@@ -0,0 +1,13 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module Inspectors
+        class Primitive < SuperDiff::ObjectInspection::Inspectors::Primitive
+          def self.applies_to?(value)
+            super || value.is_a?(::RSpec::Mocks::Double)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspectors/value_within.rb

@@ -0,0 +1,29 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module Inspectors
+        class ValueWithin < SuperDiff::ObjectInspection::Inspectors::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_value_within_something?(value)
+          end
+
+          protected
+
+          def inspection_tree
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text "#<a value within "
+
+              add_inspection_of do |aliased_matcher|
+                aliased_matcher.base_matcher.instance_variable_get("@delta")
+              end
+
+              add_text " of "
+              add_inspection_of(&:expected)
+              add_text ">"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/operation_tree_builders.rb

@@ -0,0 +1,22 @@
+module SuperDiff
+  module RSpec
+    module OperationTreeBuilders
+      autoload(
+        :CollectionContainingExactly,
+        "super_diff/rspec/operation_tree_builders/collection_containing_exactly",
+      )
+      autoload(
+        :CollectionIncluding,
+        "super_diff/rspec/operation_tree_builders/collection_including",
+      )
+      autoload(
+        :HashIncluding,
+        "super_diff/rspec/operation_tree_builders/hash_including",
+      )
+      autoload(
+        :ObjectHavingAttributes,
+        "super_diff/rspec/operation_tree_builders/object_having_attributes",
+      )
+    end
+  end
+end

data/lib/super_diff/rspec/{operational_sequencers → operation_tree_builders}/collection_containing_exactly.rb

@@ -1,13 +1,13 @@
 module SuperDiff
   module RSpec
-    module OperationalSequencers
-      class CollectionContainingExactly < SuperDiff::OperationalSequencers::Base
+    module OperationTreeBuilders
+      class CollectionContainingExactly < SuperDiff::OperationTreeBuilders::Base
         def self.applies_to?(expected, actual)
           SuperDiff::RSpec.a_collection_containing_exactly_something?(expected) &&
             actual.is_a?(::Array)
         end
 
-        def initialize(actual:, **rest)
+        def initialize(actual:, **)
           super
           populate_pairings_maximizer_in_expected_with(actual)
         end
@@ -28,8 +28,8 @@ module SuperDiff
           operations
         end
 
-        def build_operation_sequencer
-          OperationSequences::Array.new([])
+        def build_operation_tree
+          OperationTrees::Array.new([])
         end
 
         private

data/lib/super_diff/rspec/{operational_sequencers → operation_tree_builders}/collection_including.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module RSpec
-    module OperationalSequencers
-      class CollectionIncluding < SuperDiff::OperationalSequencers::Array
+    module OperationTreeBuilders
+      class CollectionIncluding < SuperDiff::OperationTreeBuilders::Array
         def self.applies_to?(expected, actual)
           SuperDiff::RSpec.a_collection_including_something?(expected) &&
             actual.is_a?(::Array)

data/lib/super_diff/rspec/{operational_sequencers → operation_tree_builders}/hash_including.rb

@@ -1,16 +1,14 @@
 module SuperDiff
   module RSpec
-    module OperationalSequencers
-      class HashIncluding < SuperDiff::OperationalSequencers::Hash
+    module OperationTreeBuilders
+      class HashIncluding < SuperDiff::OperationTreeBuilders::Hash
         def self.applies_to?(expected, actual)
           SuperDiff::RSpec.a_hash_including_something?(expected) &&
             actual.is_a?(::Hash)
         end
 
         def initialize(expected:, **rest)
-          super
-
-          @expected = expected.expecteds.first
+          super(expected: expected.expecteds.first, **rest)
         end
 
         private
@@ -21,12 +19,6 @@ module SuperDiff
             expected[key] == actual[key]
           )
         end
-
-        def should_add_insert_operation?(key)
-          expected.include?(key) &&
-            actual.include?(key) &&
-            expected[key] != actual[key]
-        end
       end
     end
   end

data/lib/super_diff/rspec/{operational_sequencers → operation_tree_builders}/object_having_attributes.rb

@@ -1,19 +1,15 @@
 module SuperDiff
   module RSpec
-    module OperationalSequencers
-      class ObjectHavingAttributes < SuperDiff::OperationalSequencers::DefaultObject
+    module OperationTreeBuilders
+      class ObjectHavingAttributes < SuperDiff::OperationTreeBuilders::DefaultObject
         def self.applies_to?(expected, _actual)
           SuperDiff::RSpec.an_object_having_some_attributes?(expected)
         end
 
         protected
 
-        def build_operation_sequencer
-          if actual.respond_to?(:attributes_for_super_diff)
-            OperationSequences::CustomObject.new([], value_class: actual.class)
-          else
-            OperationSequences::DefaultObject.new([], value_class: actual.class)
-          end
+        def build_operation_tree
+          find_operation_tree_for(actual)
         end
 
         def attribute_names

data/lib/super_diff/version.rb

@@ -1,3 +1,3 @@
 module SuperDiff
-  VERSION = "0.4.0".freeze
+  VERSION = "0.5.2".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/have_attributes_matcher_spec.rb

@@ -1,255 +1,369 @@
 require "spec_helper"
 
 RSpec.describe "Integration with RSpec's #have_attributes matcher", type: :integration do
-  context "when given a small set of attributes" do
-    context "when all of the names are methods on the actual object" do
-      it "produces the correct output when used in the positive" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = { name: "b" }
-            actual = SuperDiff::Test::Person.new(name: "a", age: 9)
-            expect(actual).to have_attributes(expected)
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
+  context "when the actual value is an object" do
+    context "with a small set of attributes" do
+      context "when all of the names are methods on the actual object" do
+        it "produces the correct output when used in the positive" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expected = { name: "b" }
+              actual = SuperDiff::Test::Person.new(name: "a", age: 9)
+              expect(actual).to have_attributes(expected)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to have_attributes(expected)|,
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|#<SuperDiff::Test::Person name: "a", age: 9>|
-                plain " to have attributes "
-                alpha %|(name: "b")|
-                plain "."
-              end
-            },
-            diff: proc {
-              plain_line %|  #<SuperDiff::Test::Person {|
-              # alpha_line %|-   name: "b",|  # FIXME
-              alpha_line %|-   name: "b"|
-              beta_line  %|+   name: "a",|
-              plain_line %|    age: 9|
-              plain_line %|  }>|
-            },
-          )
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(actual).to have_attributes(expected)|,
+              expectation: proc {
+                line do
+                  plain "Expected "
+                  beta %|#<SuperDiff::Test::Person name: "a", age: 9>|
+                  plain " to have attributes "
+                  alpha %|(name: "b")|
+                  plain "."
+                end
+              },
+              diff: proc {
+                plain_line %|  #<SuperDiff::Test::Person {|
+                # alpha_line %|-   name: "b",|  # FIXME
+                alpha_line %|-   name: "b"|
+                beta_line  %|+   name: "a",|
+                plain_line %|    age: 9|
+                plain_line %|  }>|
+              },
+            )
 
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
         end
-      end
 
-      it "produces the correct output when used in the negative" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = { name: "a" }
-            actual = SuperDiff::Test::Person.new(name: "a", age: 9)
-            expect(actual).not_to have_attributes(expected)
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
+        it "produces the correct output when used in the negative" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expected = { name: "a" }
+              actual = SuperDiff::Test::Person.new(name: "a", age: 9)
+              expect(actual).not_to have_attributes(expected)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to have_attributes(expected)|,
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|#<SuperDiff::Test::Person name: "a", age: 9>|
-                plain " not to have attributes "
-                alpha %|(name: "a")|
-                plain "."
-              end
-            },
-          )
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(actual).not_to have_attributes(expected)|,
+              expectation: proc {
+                line do
+                  plain "Expected "
+                  beta %|#<SuperDiff::Test::Person name: "a", age: 9>|
+                  plain " not to have attributes "
+                  alpha %|(name: "a")|
+                  plain "."
+                end
+              },
+            )
 
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
         end
       end
-    end
 
-    context "when some of the names are not methods on the actual object" do
-      it "produces the correct output" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = { name: "b", foo: "bar" }
-            actual = SuperDiff::Test::Person.new(name: "a", age: 9)
-            expect(actual).to have_attributes(expected)
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
+      context "when some of the names are not methods on the actual object" do
+        it "produces the correct output" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expected = { name: "b", foo: "bar" }
+              actual = SuperDiff::Test::Person.new(name: "a", age: 9)
+              expect(actual).to have_attributes(expected)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to have_attributes(expected)|,
-            expectation: proc {
-              line do
-                plain "Expected "
-                beta %|#<SuperDiff::Test::Person name: "a", age: 9>|
-                plain " to respond to "
-                alpha %|:foo|
-                plain " with "
-                alpha %|0|
-                plain " arguments."
-              end
-            },
-            diff: proc {
-              plain_line %|  #<SuperDiff::Test::Person {|
-              plain_line %|    name: "a",|
-              # plain_line %|    age: 9,|  # FIXME
-              plain_line %|    age: 9|
-              # alpha_line %|-   foo: "bar",|  # FIXME
-              alpha_line %|-   foo: "bar"|
-              plain_line %|  }>|
-            },
-          )
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(actual).to have_attributes(expected)|,
+              expectation: proc {
+                line do
+                  plain "Expected "
+                  beta %|#<SuperDiff::Test::Person name: "a", age: 9>|
+                  plain " to respond to "
+                  alpha %|:foo|
+                  plain " with "
+                  alpha %|0|
+                  plain " arguments."
+                end
+              },
+              diff: proc {
+                plain_line %|  #<SuperDiff::Test::Person {|
+                plain_line %|    name: "a",|
+                # plain_line %|    age: 9,|  # FIXME
+                plain_line %|    age: 9|
+                # alpha_line %|-   foo: "bar",|  # FIXME
+                alpha_line %|-   foo: "bar"|
+                plain_line %|  }>|
+              },
+            )
 
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
         end
       end
     end
-  end
 
-  context "when given a large set of attributes" do
-    context "when all of the names are methods on the actual object" do
-      it "produces the correct output when used in the positive" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = {
-              line_1: "123 Main St.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234"
-            }
-            actual = SuperDiff::Test::ShippingAddress.new(
-              line_1: "456 Ponderosa Ct.",
-              line_2: nil,
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382"
+    context "with a large set of attributes" do
+      context "when all of the names are methods on the actual object" do
+        it "produces the correct output when used in the positive" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expected = {
+                line_1: "123 Main St.",
+                city: "Oakland",
+                state: "CA",
+                zip: "91234"
+              }
+              actual = SuperDiff::Test::ShippingAddress.new(
+                line_1: "456 Ponderosa Ct.",
+                line_2: nil,
+                city: "Hill Valley",
+                state: "CA",
+                zip: "90382"
+              )
+              expect(actual).to have_attributes(expected)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
             )
-            expect(actual).to have_attributes(expected)
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to have_attributes(expected)|,
-            expectation: proc {
-              line do
-                plain "          Expected "
-                beta %|#<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382">|
-              end
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(actual).to have_attributes(expected)|,
+              expectation: proc {
+                line do
+                  plain "          Expected "
+                  beta %|#<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382">|
+                end
 
-              line do
-                plain "to have attributes "
-                alpha %|(line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234")|
-              end
-            },
-            diff: proc {
-              plain_line %|  #<SuperDiff::Test::ShippingAddress {|
-              alpha_line %|-   line_1: "123 Main St.",|
-              beta_line  %|+   line_1: "456 Ponderosa Ct.",|
-              plain_line %|    line_2: nil,|
-              alpha_line %|-   city: "Oakland",|
-              beta_line  %|+   city: "Hill Valley",|
-              plain_line %|    state: "CA",|
-              # alpha_line %|-   zip: "91234",|  # FIXME
-              alpha_line %|-   zip: "91234"|
-              beta_line  %|+   zip: "90382"|
-              plain_line %|  }>|
-            },
-          )
+                line do
+                  plain "to have attributes "
+                  alpha %|(line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234")|
+                end
+              },
+              diff: proc {
+                plain_line %|  #<SuperDiff::Test::ShippingAddress {|
+                alpha_line %|-   line_1: "123 Main St.",|
+                beta_line  %|+   line_1: "456 Ponderosa Ct.",|
+                plain_line %|    line_2: nil,|
+                alpha_line %|-   city: "Oakland",|
+                beta_line  %|+   city: "Hill Valley",|
+                plain_line %|    state: "CA",|
+                # alpha_line %|-   zip: "91234",|  # FIXME
+                alpha_line %|-   zip: "91234"|
+                beta_line  %|+   zip: "90382"|
+                plain_line %|  }>|
+              },
+            )
 
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
+        end
+
+        it "produces the correct output when used in the negative" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expected = {
+                line_1: "123 Main St.",
+                city: "Oakland",
+                state: "CA",
+                zip: "91234"
+              }
+              actual = SuperDiff::Test::ShippingAddress.new(
+                line_1: "123 Main St.",
+                line_2: nil,
+                city: "Oakland",
+                state: "CA",
+                zip: "91234"
+              )
+              expect(actual).not_to have_attributes(expected)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
+
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(actual).not_to have_attributes(expected)|,
+              newline_before_expectation: true,
+              expectation: proc {
+                line do
+                  plain "              Expected "
+                  beta %|#<SuperDiff::Test::ShippingAddress line_1: "123 Main St.", line_2: nil, city: "Oakland", state: "CA", zip: "91234">|
+                end
+
+                line do
+                  plain "not to have attributes "
+                  alpha %|(line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234")|
+                end
+              },
+            )
+
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
         end
       end
 
-      it "produces the correct output when used in the negative" do
-        as_both_colored_and_uncolored do |color_enabled|
-          snippet = <<~TEST.strip
-            expected = {
-              line_1: "123 Main St.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234"
-            }
-            actual = SuperDiff::Test::ShippingAddress.new(
-              line_1: "123 Main St.",
-              line_2: nil,
-              city: "Oakland",
-              state: "CA",
-              zip: "91234"
+      context "when some of the names are not methods on the actual object" 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: "Oakland",
+                state: "CA",
+                zip: "91234",
+                foo: "bar",
+                baz: "qux"
+              }
+              actual = SuperDiff::Test::ShippingAddress.new(
+                line_1: "456 Ponderosa Ct.",
+                line_2: nil,
+                city: "Hill Valley",
+                state: "CA",
+                zip: "90382"
+              )
+              expect(actual).to have_attributes(expected)
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
             )
-            expect(actual).not_to have_attributes(expected)
-          TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to have_attributes(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain "              Expected "
-                beta %|#<SuperDiff::Test::ShippingAddress line_1: "123 Main St.", line_2: nil, city: "Oakland", state: "CA", zip: "91234">|
-              end
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(actual).to have_attributes(expected)|,
+              expectation: proc {
+                line do
+                  plain "     Expected "
+                  beta %|#<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382">|
+                end
 
-              line do
-                plain "not to have attributes "
-                alpha %|(line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234")|
-              end
-            },
-          )
+                line do
+                  plain "to respond to "
+                  alpha %|:foo|
+                  plain " and "
+                  alpha %|:baz|
+                  plain " with "
+                  alpha %|0|
+                  plain " arguments"
+                end
+              },
+              diff: proc {
+                plain_line %|  #<SuperDiff::Test::ShippingAddress {|
+                plain_line %|    line_1: "456 Ponderosa Ct.",|
+                plain_line %|    line_2: nil,|
+                plain_line %|    city: "Hill Valley",|
+                plain_line %|    state: "CA",|
+                # plain_line %|    zip: "90382",|  # FIXME
+                plain_line %|    zip: "90382"|
+                # alpha_line %|-   foo: "bar",|  # FIXME
+                alpha_line %|-   foo: "bar"|
+                alpha_line %|-   baz: "qux"|
+                plain_line %|  }>|
+              },
+            )
 
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
         end
       end
     end
+  end
+
+  context "when the actual value is actually a hash instead of an object" do
+    it "displays the diff as if we were comparing hashes" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~TEST.strip
+          expected = { name: "Elliot", age: 32 }
+          actual = {}
+          expect(actual).to have_attributes(expected)
+        TEST
+
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-    context "when some of the names are not methods on the actual object" do
-      it "produces the correct output" do
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(actual).to have_attributes(expected)|,
+          expectation: proc {
+            line do
+              plain "Expected "
+              beta %|{}|
+              plain " to respond to "
+              alpha %|:name|
+              plain " and "
+              alpha %|:age|
+              plain " with "
+              alpha %|0|
+              plain " arguments."
+            end
+          },
+          diff: proc {
+            plain_line %|  {|
+            alpha_line %|-   name: "Elliot",|
+            alpha_line %|-   age: 32|
+            plain_line %|  }|
+          },
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          in_color(color_enabled)
+      end
+    end
+
+    # TODO: Add as many fuzzy matchers as we can here
+    context "that contains fuzzy matcher objects instead of an object" do
+      it "displays the hash correctly" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
             expected = {
-              line_1: "123 Main St.",
-              city: "Oakland",
-              state: "CA",
-              zip: "91234",
-              foo: "bar",
-              baz: "qux"
+              name: "Elliot",
+              shipping_address: an_object_having_attributes(
+                line_1: a_kind_of(String),
+                line_2: nil,
+                city: an_instance_of(String),
+                state: "CA",
+                zip: "91234"
+              ),
+              order_ids: a_collection_including(1, 2),
+              data: a_hash_including(active: true),
+              created_at: a_value_within(1).of(Time.utc(2020, 4, 9))
             }
-            actual = SuperDiff::Test::ShippingAddress.new(
-              line_1: "456 Ponderosa Ct.",
-              line_2: nil,
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382"
-            )
+
+            actual = {}
+
             expect(actual).to have_attributes(expected)
           TEST
+
           program = make_plain_test_program(
             snippet,
             color_enabled: color_enabled,
@@ -261,31 +375,44 @@ RSpec.describe "Integration with RSpec's #have_attributes matcher", type: :integ
             expectation: proc {
               line do
                 plain "     Expected "
-                beta %|#<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382">|
+                beta %|{}|
               end
 
               line do
                 plain "to respond to "
-                alpha %|:foo|
+                alpha %|:name|
+                plain ", "
+                alpha %|:shipping_address|
+                plain ", "
+                alpha %|:order_ids|
+                plain ", "
+                alpha %|:data|
                 plain " and "
-                alpha %|:baz|
+                alpha %|:created_at|
                 plain " with "
                 alpha %|0|
                 plain " arguments"
               end
             },
             diff: proc {
-              plain_line %|  #<SuperDiff::Test::ShippingAddress {|
-              plain_line %|    line_1: "456 Ponderosa Ct.",|
-              plain_line %|    line_2: nil,|
-              plain_line %|    city: "Hill Valley",|
-              plain_line %|    state: "CA",|
-              # plain_line %|    zip: "90382",|  # FIXME
-              plain_line %|    zip: "90382"|
-              # alpha_line %|-   foo: "bar",|  # FIXME
-              alpha_line %|-   foo: "bar"|
-              alpha_line %|-   baz: "qux"|
-              plain_line %|  }>|
+              plain_line %|  {|
+              alpha_line %|-   name: "Elliot",|
+              alpha_line %|-   shipping_address: #<an object having attributes (|
+              alpha_line %|-     line_1: #<a kind of String>,|
+              alpha_line %|-     line_2: nil,|
+              alpha_line %|-     city: #<an instance of String>,|
+              alpha_line %|-     state: "CA",|
+              alpha_line %|-     zip: "91234"|
+              alpha_line %|-   )>,|
+              alpha_line %|-   order_ids: #<a collection including (|
+              alpha_line %|-     1,|
+              alpha_line %|-     2|
+              alpha_line %|-   )>,|
+              alpha_line %|-   data: #<a hash including (|
+              alpha_line %|-     active: true|
+              alpha_line %|-   )>,|
+              alpha_line %|-   created_at: #<a value within 1 of 2020-04-09 00:00:00.000 UTC +00:00 (Time)>|
+              plain_line %|  }|
             },
           )