super_diff 0.1.0 → 0.2.0

data/spec/support/shared_examples/hash_with_indifferent_access.rb

@@ -0,0 +1,233 @@
+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)
+        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)
+        end
+      end
+    end
+  end
+
+  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)
+        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)
+        end
+      end
+    end
+  end
+end

data/spec/unit/equality_matcher_spec.rb

@@ -27,8 +27,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: 42)
-              green_line %(  Actual: 1)
+              alpha_line %(Expected: 42)
+              beta_line  %(  Actual: 1)
             end
           }
         STR
@@ -54,8 +54,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: :foo)
-              green_line %(  Actual: :bar)
+              alpha_line %(Expected: :foo)
+              beta_line  %(  Actual: :bar)
             end
           }
         STR
@@ -84,8 +84,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: "Marty")
-              green_line %(  Actual: "Jennifer")
+              alpha_line %(Expected: "Marty")
+              beta_line  %(  Actual: "Jennifer")
             end
           }
         STR
@@ -106,8 +106,52 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: "Marty")
-              green_line %(  Actual: "Marty McFly")
+              alpha_line %(Expected: "Marty")
+              beta_line  %(  Actual: "Marty McFly")
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given a single-line string and a multi-line string" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: "Something entirely different",
+          actual: "This is a line\nAnd that's another line\n",
+        )
+
+        expected_output = <<~STR.strip
+          Differing strings.
+
+          #{
+            colored do
+              alpha_line %(Expected: "Something entirely different")
+              beta_line  %(  Actual: "This is a line\\nAnd that's another line\\n")
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given a multi-line string and a single-line string" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: "This is a line\nAnd that's another line\n",
+          actual: "Something entirely different",
+        )
+
+        expected_output = <<~STR.strip
+          Differing strings.
+
+          #{
+            colored do
+              alpha_line %(Expected: "This is a line\\nAnd that's another line\\n")
+              beta_line  %(  Actual: "Something entirely different")
             end
           }
         STR
@@ -128,8 +172,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: "This is a line⏎And that's a line⏎And there's a line too")
-              green_line %(  Actual: "This is a line⏎Something completely different⏎And there's a line too")
+              alpha_line %(Expected: "This is a line\\nAnd that's a line\\nAnd there's a line too")
+              beta_line  %(  Actual: "This is a line\\nSomething completely different\\nAnd there's a line too")
             end
           }
 
@@ -137,9 +181,9 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              plain_line %(  This is a line⏎)
-              red_line   %(- And that's a line⏎)
-              green_line %(+ Something completely different⏎)
+              plain_line %(  This is a line\\n)
+              alpha_line %(- And that's a line\\n)
+              beta_line  %(+ Something completely different\\n)
               plain_line %(  And there's a line too)
             end
           }
@@ -161,8 +205,74 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: "This is a line⏎And that's a line⏎")
-              green_line %(  Actual: "Something completely different⏎And something else too⏎")
+              alpha_line %(Expected: "This is a line\\nAnd that's a line\\n")
+              beta_line  %(  Actual: "Something completely different\\nAnd something else too\\n")
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              alpha_line %(- This is a line\\n)
+              alpha_line %(- And that's a line\\n)
+              beta_line  %(+ Something completely different\\n)
+              beta_line  %(+ And something else too\\n)
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given multi-line strings that contain color codes" do
+      it "escapes the color codes" do
+        colors = [
+          SuperDiff::Csi::FourBitColor.new(:blue, layer: :foreground),
+          SuperDiff::Csi::EightBitColor.new(
+            red: 3,
+            green: 8,
+            blue: 4,
+            layer: :foreground,
+          ),
+          SuperDiff::Csi::TwentyFourBitColor.new(
+            red: 47,
+            green: 164,
+            blue: 59,
+            layer: :foreground,
+          ),
+        ]
+
+        expected =
+          colored("This is a line", colors[0]) + "\n" +
+          colored("And that's a line", colors[1]) + "\n" +
+          colored("And there's a line too", colors[2]) + "\n"
+
+        actual =
+          colored("This is a line", colors[0])  + "\n" +
+          colored("Something completely different", colors[1]) + "\n" +
+          colored("And there's a line too", colors[2]) + "\n"
+
+        actual_output = described_class.call(
+          expected: expected,
+          actual: actual,
+        )
+
+        expected_output = <<~STR.strip
+          Differing strings.
+
+          #{
+            colored do
+              alpha_line do
+                text "Expected: "
+                text %("\\e[34mThis is a line\\e[0m\\n\\e[38;5;176mAnd that's a line\\e[0m\\n\\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n")
+              end
+
+              beta_line do
+                text "  Actual: "
+                text %("\\e[34mThis is a line\\e[0m\\n\\e[38;5;176mSomething completely different\\e[0m\\n\\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n")
+              end
             end
           }
 
@@ -170,10 +280,10 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(- This is a line⏎)
-              red_line   %(- And that's a line⏎)
-              green_line %(+ Something completely different⏎)
-              green_line %(+ And something else too⏎)
+              plain_line %(  \\e[34mThis is a line\\e[0m\\n)
+              alpha_line %(- \\e[38;5;176mAnd that's a line\\e[0m\\n)
+              beta_line  %(+ \\e[38;5;176mSomething completely different\\e[0m\\n)
+              plain_line %(  \\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n)
             end
           }
         STR
@@ -205,8 +315,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [1, 2, 3, 4])
-              green_line %(  Actual: [1, 2, 99, 4])
+              alpha_line %(Expected: [1, 2, 3, 4])
+              beta_line  %(  Actual: [1, 2, 99, 4])
             end
           }
 
@@ -217,8 +327,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(  [)
               plain_line %(    1,)
               plain_line %(    2,)
-              red_line   %(-   3,)
-              green_line %(+   99,)
+              alpha_line %(-   3,)
+              beta_line  %(+   99,)
               plain_line %(    4)
               plain_line %(  ])
             end
@@ -241,8 +351,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [:one, :fish, :two, :fish])
-              green_line %(  Actual: [:one, :FISH, :two, :fish])
+              alpha_line %(Expected: [:one, :fish, :two, :fish])
+              beta_line  %(  Actual: [:one, :FISH, :two, :fish])
             end
           }
 
@@ -252,8 +362,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  [)
               plain_line %(    :one,)
-              red_line   %(-   :fish,)
-              green_line %(+   :FISH,)
+              alpha_line %(-   :fish,)
+              beta_line  %(+   :FISH,)
               plain_line %(    :two,)
               plain_line %(    :fish)
               plain_line %(  ])
@@ -277,8 +387,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: ["sausage", "egg", "cheese"])
-              green_line %(  Actual: ["bacon", "egg", "cheese"])
+              alpha_line %(Expected: ["sausage", "egg", "cheese"])
+              beta_line  %(  Actual: ["bacon", "egg", "cheese"])
             end
           }
 
@@ -287,8 +397,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
           #{
             colored do
               plain_line %(  [)
-              red_line   %(-   "sausage",)
-              green_line %(+   "bacon",)
+              alpha_line %(-   "sausage",)
+              beta_line  %(+   "bacon",)
               plain_line %(    "egg",)
               plain_line %(    "cheese")
               plain_line %(  ])
@@ -304,18 +414,12 @@ RSpec.describe SuperDiff::EqualityMatcher do
       it "returns a message along with the diff" do
         actual_output = described_class.call(
           expected: [
-            SuperDiff::Test::Person.new(name: "Marty"),
-            SuperDiff::Test::Person.new(name: "Jennifer"),
+            SuperDiff::Test::Person.new(name: "Marty", age: 18),
+            SuperDiff::Test::Person.new(name: "Jennifer", age: 17),
           ],
           actual: [
-            SuperDiff::Test::Person.new(name: "Marty"),
-            SuperDiff::Test::Person.new(name: "Doc"),
-          ],
-          extra_operational_sequencer_classes: [
-            SuperDiff::Test::PersonOperationalSequencer,
-          ],
-          extra_diff_formatter_classes: [
-            SuperDiff::Test::PersonDiffFormatter,
+            SuperDiff::Test::Person.new(name: "Marty", age: 18),
+            SuperDiff::Test::Person.new(name: "Doc", age: 50),
           ],
         )
 
@@ -324,8 +428,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [#<SuperDiff::Test::Person name: "Marty">, #<SuperDiff::Test::Person name: "Jennifer">])
-              green_line %(  Actual: [#<SuperDiff::Test::Person name: "Marty">, #<SuperDiff::Test::Person name: "Doc">])
+              alpha_line %(Expected: [#<SuperDiff::Test::Person name: "Marty", age: 18>, #<SuperDiff::Test::Person name: "Jennifer", age: 17>])
+              beta_line  %(  Actual: [#<SuperDiff::Test::Person name: "Marty", age: 18>, #<SuperDiff::Test::Person name: "Doc", age: 50>])
             end
           }
 
@@ -335,11 +439,14 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  [)
               plain_line %(    #<SuperDiff::Test::Person {)
-              plain_line %(      name: "Marty")
+              plain_line %(      name: "Marty",)
+              plain_line %(      age: 18)
               plain_line %(    }>,)
               plain_line %(    #<SuperDiff::Test::Person {)
-              red_line   %(-     name: "Jennifer")
-              green_line %(+     name: "Doc")
+              alpha_line %(-     name: "Jennifer",)
+              beta_line  %(+     name: "Doc",)
+              alpha_line %(-     age: 17)
+              beta_line  %(+     age: 50)
               plain_line %(    }>)
               plain_line %(  ])
             end
@@ -362,8 +469,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: ["bread"])
-              green_line %(  Actual: ["bread", "eggs", "milk"])
+              alpha_line %(Expected: ["bread"])
+              beta_line  %(  Actual: ["bread", "eggs", "milk"])
             end
           }
 
@@ -373,8 +480,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  [)
               plain_line %(    "bread",)
-              green_line %(+   "eggs",)
-              green_line %(+   "milk")
+              beta_line  %(+   "eggs",)
+              beta_line  %(+   "milk")
               plain_line %(  ])
             end
           }
@@ -396,8 +503,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: ["bread", "eggs", "milk"])
-              green_line %(  Actual: ["bread"])
+              alpha_line %(Expected: ["bread", "eggs", "milk"])
+              beta_line  %(  Actual: ["bread"])
             end
           }
 
@@ -407,8 +514,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  [)
               plain_line %(    "bread")
-              red_line   %(-   "eggs",)
-              red_line   %(-   "milk")
+              alpha_line %(-   "eggs",)
+              alpha_line %(-   "milk")
               plain_line %(  ])
             end
           }
@@ -430,8 +537,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: ["milk"])
-              green_line %(  Actual: ["bread", "eggs", "milk"])
+              alpha_line %(Expected: ["milk"])
+              beta_line  %(  Actual: ["bread", "eggs", "milk"])
             end
           }
 
@@ -440,8 +547,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
           #{
             colored do
               plain_line %(  [)
-              green_line %(+   "bread",)
-              green_line %(+   "eggs",)
+              beta_line  %(+   "bread",)
+              beta_line  %(+   "eggs",)
               plain_line %(    "milk")
               plain_line %(  ])
             end
@@ -464,8 +571,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: ["bread", "eggs", "milk"])
-              green_line %(  Actual: ["milk"])
+              alpha_line %(Expected: ["bread", "eggs", "milk"])
+              beta_line  %(  Actual: ["milk"])
             end
           }
 
@@ -474,8 +581,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
           #{
             colored do
               plain_line %(  [)
-              red_line   %(-   "bread",)
-              red_line   %(-   "eggs",)
+              alpha_line %(-   "bread",)
+              alpha_line %(-   "eggs",)
               plain_line %(    "milk")
               plain_line %(  ])
             end
@@ -498,8 +605,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [1, 2, [:a, :b, :c], 4])
-              green_line %(  Actual: [1, 2, [:a, :x, :c], 4])
+              alpha_line %(Expected: [1, 2, [:a, :b, :c], 4])
+              beta_line  %(  Actual: [1, 2, [:a, :x, :c], 4])
             end
           }
 
@@ -512,8 +619,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(    2,)
               plain_line %(    [)
               plain_line %(      :a,)
-              red_line   %(-     :b,)
-              green_line %(+     :x,)
+              alpha_line %(-     :b,)
+              beta_line  %(+     :x,)
               plain_line %(      :c)
               plain_line %(    ],)
               plain_line %(    4)
@@ -538,8 +645,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [1, 2, { foo: "bar", baz: "qux" }, 4])
-              green_line %(  Actual: [1, 2, { foo: "bar", baz: "qox" }, 4])
+              alpha_line %(Expected: [1, 2, { foo: "bar", baz: "qux" }, 4])
+              beta_line  %(  Actual: [1, 2, { foo: "bar", baz: "qox" }, 4])
             end
           }
 
@@ -552,8 +659,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(    2,)
               plain_line %(    {)
               plain_line %(      foo: "bar",)
-              red_line   %(-     baz: "qux")
-              green_line %(+     baz: "qox")
+              alpha_line %(-     baz: "qux")
+              beta_line  %(+     baz: "qox")
               plain_line %(    },)
               plain_line %(    4)
               plain_line %(  ])
@@ -568,14 +675,13 @@ RSpec.describe SuperDiff::EqualityMatcher do
     context "given two arrays containing custom objects with differing attributes" do
       it "returns a message along with the diff" do
         actual_output = described_class.call(
-          expected: [1, 2, SuperDiff::Test::Person.new(name: "Marty"), 4],
-          actual: [1, 2, SuperDiff::Test::Person.new(name: "Doc"), 4],
-          extra_operational_sequencer_classes: [
-            SuperDiff::Test::PersonOperationalSequencer,
-          ],
-          extra_diff_formatter_classes: [
-            SuperDiff::Test::PersonDiffFormatter,
+          expected: [
+            1,
+            2,
+            SuperDiff::Test::Person.new(name: "Marty", age: 18),
+            4,
           ],
+          actual: [1, 2, SuperDiff::Test::Person.new(name: "Doc", age: 50), 4],
         )
 
         expected_output = <<~STR.strip
@@ -583,8 +689,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [1, 2, #<SuperDiff::Test::Person name: "Marty">, 4])
-              green_line %(  Actual: [1, 2, #<SuperDiff::Test::Person name: "Doc">, 4])
+              alpha_line %(Expected: [1, 2, #<SuperDiff::Test::Person name: "Marty", age: 18>, 4])
+              beta_line  %(  Actual: [1, 2, #<SuperDiff::Test::Person name: "Doc", age: 50>, 4])
             end
           }
 
@@ -596,8 +702,10 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(    1,)
               plain_line %(    2,)
               plain_line %(    #<SuperDiff::Test::Person {)
-              red_line   %(-     name: "Marty")
-              green_line %(+     name: "Doc")
+              alpha_line %(-     name: "Marty",)
+              beta_line  %(+     name: "Doc",)
+              alpha_line %(-     age: 18)
+              beta_line  %(+     age: 50)
               plain_line %(    }>,)
               plain_line %(    4)
               plain_line %(  ])
@@ -641,8 +749,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: [[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true } }]])
-              green_line %(  Actual: [[:h2, [:span, [:text, "Goodbye world"]], { id: "hero", class: "header", data: { "sticky" => false, role: "deprecated" } }], :br])
+              alpha_line %(Expected: [[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true } }]])
+              beta_line  %(  Actual: [[:h2, [:span, [:text, "Goodbye world"]], { id: "hero", class: "header", data: { "sticky" => false, :role => "deprecated" } }], :br])
             end
           }
 
@@ -652,27 +760,27 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  [)
               plain_line %(    [)
-              red_line   %(-     :h1,)
-              green_line %(+     :h2,)
+              alpha_line %(-     :h1,)
+              beta_line  %(+     :h2,)
               plain_line %(      [)
               plain_line %(        :span,)
               plain_line %(        [)
               plain_line %(          :text,)
-              red_line   %(-         "Hello world")
-              green_line %(+         "Goodbye world")
+              alpha_line %(-         "Hello world")
+              beta_line  %(+         "Goodbye world")
               plain_line %(        ])
               plain_line %(      ],)
               plain_line %(      {)
+              beta_line  %(+       id: "hero",)
               plain_line %(        class: "header",)
               plain_line %(        data: {)
-              red_line   %(-         "sticky" => true)
-              green_line %(+         "sticky" => false,)
-              green_line %(+         role: "deprecated")
-              plain_line %(        },)
-              green_line %(+       id: "hero")
+              alpha_line %(-         "sticky" => true)
+              beta_line  %(+         "sticky" => false,)
+              beta_line  %(+         role: "deprecated")
+              plain_line %(        })
               plain_line %(      })
               plain_line %(    ],)
-              green_line %(+   :br)
+              beta_line  %(+   :br)
               plain_line %(  ])
             end
           }
@@ -705,8 +813,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { tall: 12, grande: 19, venti: 20 })
-              green_line %(  Actual: { tall: 12, grande: 16, venti: 20 })
+              alpha_line %(Expected: { tall: 12, grande: 19, venti: 20 })
+              beta_line  %(  Actual: { tall: 12, grande: 16, venti: 20 })
             end
           }
 
@@ -716,8 +824,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    tall: 12,)
-              red_line   %(-   grande: 19,)
-              green_line %(+   grande: 16,)
+              alpha_line %(-   grande: 19,)
+              beta_line  %(+   grande: 16,)
               plain_line %(    venti: 20)
               plain_line %(  })
             end
@@ -740,8 +848,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { "tall" => 12, "grande" => 19, "venti" => 20 })
-              green_line %(  Actual: { "tall" => 12, "grande" => 16, "venti" => 20 })
+              alpha_line %(Expected: { "tall" => 12, "grande" => 19, "venti" => 20 })
+              beta_line  %(  Actual: { "tall" => 12, "grande" => 16, "venti" => 20 })
             end
           }
 
@@ -751,8 +859,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    "tall" => 12,)
-              red_line   %(-   "grande" => 19,)
-              green_line %(+   "grande" => 16,)
+              alpha_line %(-   "grande" => 19,)
+              beta_line  %(+   "grande" => 16,)
               plain_line %(    "venti" => 20)
               plain_line %(  })
             end
@@ -775,8 +883,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { tall: :small, grande: :grand, venti: :large })
-              green_line %(  Actual: { tall: :small, grande: :medium, venti: :large })
+              alpha_line %(Expected: { tall: :small, grande: :grand, venti: :large })
+              beta_line  %(  Actual: { tall: :small, grande: :medium, venti: :large })
             end
           }
 
@@ -786,8 +894,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    tall: :small,)
-              red_line   %(-   grande: :grand,)
-              green_line %(+   grande: :medium,)
+              alpha_line %(-   grande: :grand,)
+              beta_line  %(+   grande: :medium,)
               plain_line %(    venti: :large)
               plain_line %(  })
             end
@@ -810,8 +918,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { tall: "small", grande: "grand", venti: "large" })
-              green_line %(  Actual: { tall: "small", grande: "medium", venti: "large" })
+              alpha_line %(Expected: { tall: "small", grande: "grand", venti: "large" })
+              beta_line  %(  Actual: { tall: "small", grande: "medium", venti: "large" })
             end
           }
 
@@ -821,8 +929,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    tall: "small",)
-              red_line   %(-   grande: "grand",)
-              green_line %(+   grande: "medium",)
+              alpha_line %(-   grande: "grand",)
+              beta_line  %(+   grande: "medium",)
               plain_line %(    venti: "large")
               plain_line %(  })
             end
@@ -837,19 +945,13 @@ RSpec.describe SuperDiff::EqualityMatcher do
       it "returns a message along with the diff" do
         actual_output = described_class.call(
           expected: {
-            steve: SuperDiff::Test::Person.new(name: "Jobs"),
-            susan: SuperDiff::Test::Person.new(name: "Kare"),
+            steve: SuperDiff::Test::Person.new(name: "Jobs", age: 30),
+            susan: SuperDiff::Test::Person.new(name: "Kare", age: 27),
           },
           actual: {
-            steve: SuperDiff::Test::Person.new(name: "Wozniak"),
-            susan: SuperDiff::Test::Person.new(name: "Kare"),
+            steve: SuperDiff::Test::Person.new(name: "Wozniak", age: 33),
+            susan: SuperDiff::Test::Person.new(name: "Kare", age: 27),
           },
-          extra_operational_sequencer_classes: [
-            SuperDiff::Test::PersonOperationalSequencer,
-          ],
-          extra_diff_formatter_classes: [
-            SuperDiff::Test::PersonDiffFormatter,
-          ],
         )
 
         expected_output = <<~STR.strip
@@ -857,8 +959,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { steve: #<SuperDiff::Test::Person name: "Jobs">, susan: #<SuperDiff::Test::Person name: "Kare"> })
-              green_line %(  Actual: { steve: #<SuperDiff::Test::Person name: "Wozniak">, susan: #<SuperDiff::Test::Person name: "Kare"> })
+              alpha_line %(Expected: { steve: #<SuperDiff::Test::Person name: "Jobs", age: 30>, susan: #<SuperDiff::Test::Person name: "Kare", age: 27> })
+              beta_line  %(  Actual: { steve: #<SuperDiff::Test::Person name: "Wozniak", age: 33>, susan: #<SuperDiff::Test::Person name: "Kare", age: 27> })
             end
           }
 
@@ -868,11 +970,14 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    steve: #<SuperDiff::Test::Person {)
-              red_line   %(-     name: "Jobs")
-              green_line %(+     name: "Wozniak")
+              alpha_line %(-     name: "Jobs",)
+              beta_line  %(+     name: "Wozniak",)
+              alpha_line %(-     age: 30)
+              beta_line  %(+     age: 33)
               plain_line %(    }>,)
               plain_line %(    susan: #<SuperDiff::Test::Person {)
-              plain_line %(      name: "Kare")
+              plain_line %(      name: "Kare",)
+              plain_line %(      age: 27)
               plain_line %(    }>)
               plain_line %(  })
             end
@@ -895,8 +1000,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { latte: 4.5 })
-              green_line %(  Actual: { latte: 4.5, mocha: 3.5, cortado: 3 })
+              alpha_line %(Expected: { latte: 4.5 })
+              beta_line  %(  Actual: { latte: 4.5, mocha: 3.5, cortado: 3 })
             end
           }
 
@@ -906,8 +1011,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    latte: 4.5,)
-              green_line %(+   mocha: 3.5,)
-              green_line %(+   cortado: 3)
+              beta_line  %(+   mocha: 3.5,)
+              beta_line  %(+   cortado: 3)
               plain_line %(  })
             end
           }
@@ -929,8 +1034,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { latte: 4.5, mocha: 3.5, cortado: 3 })
-              green_line %(  Actual: { latte: 4.5 })
+              alpha_line %(Expected: { latte: 4.5, mocha: 3.5, cortado: 3 })
+              beta_line  %(  Actual: { latte: 4.5 })
             end
           }
 
@@ -940,8 +1045,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    latte: 4.5)
-              red_line   %(-   mocha: 3.5,)
-              red_line   %(-   cortado: 3)
+              alpha_line %(-   mocha: 3.5,)
+              alpha_line %(-   cortado: 3)
               plain_line %(  })
             end
           }
@@ -971,8 +1076,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { name: "Elliot", interests: ["music", "football", "programming"], age: 30 })
-              green_line %(  Actual: { name: "Elliot", interests: ["music", "travel", "programming"], age: 30 })
+              alpha_line %(Expected: { name: "Elliot", interests: ["music", "football", "programming"], age: 30 })
+              beta_line  %(  Actual: { name: "Elliot", interests: ["music", "travel", "programming"], age: 30 })
             end
           }
 
@@ -984,8 +1089,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(    name: "Elliot",)
               plain_line %(    interests: [)
               plain_line %(      "music",)
-              red_line   %(-     "football",)
-              green_line %(+     "travel",)
+              alpha_line %(-     "football",)
+              beta_line  %(+     "travel",)
               plain_line %(      "programming")
               plain_line %(    ],)
               plain_line %(    age: 30)
@@ -1026,8 +1131,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Buns, ribs, and bacon", "YMMV" => "Your mileage may vary" }, check_grammar: false })
-              green_line %(  Actual: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Be right back", "YMMV" => "Your mileage may vary" }, check_grammar: false })
+              alpha_line %(Expected: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Buns, ribs, and bacon", "YMMV" => "Your mileage may vary" }, check_grammar: false })
+              beta_line  %(  Actual: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Be right back", "YMMV" => "Your mileage may vary" }, check_grammar: false })
             end
           }
 
@@ -1039,8 +1144,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(    check_spelling: true,)
               plain_line %(    substitutions: {)
               plain_line %(      "YOLO" => "You only live once",)
-              red_line   %(-     "BRB" => "Buns, ribs, and bacon",)
-              green_line %(+     "BRB" => "Be right back",)
+              alpha_line %(-     "BRB" => "Buns, ribs, and bacon",)
+              beta_line  %(+     "BRB" => "Be right back",)
               plain_line %(      "YMMV" => "Your mileage may vary")
               plain_line %(    },)
               plain_line %(    check_grammar: false)
@@ -1058,20 +1163,14 @@ RSpec.describe SuperDiff::EqualityMatcher do
         actual_output = described_class.call(
           expected: {
             order_id: 1234,
-            person: SuperDiff::Test::Person.new(name: "Marty"),
+            person: SuperDiff::Test::Person.new(name: "Marty", age: 18),
             amount: 350_00,
           },
           actual: {
             order_id: 1234,
-            person: SuperDiff::Test::Person.new(name: "Doc"),
+            person: SuperDiff::Test::Person.new(name: "Doc", age: 50),
             amount: 350_00,
           },
-          extra_operational_sequencer_classes: [
-            SuperDiff::Test::PersonOperationalSequencer,
-          ],
-          extra_diff_formatter_classes: [
-            SuperDiff::Test::PersonDiffFormatter,
-          ],
         )
 
         expected_output = <<~STR.strip
@@ -1079,8 +1178,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Marty">, amount: 35000 })
-              green_line %(  Actual: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Doc">, amount: 35000 })
+              alpha_line %(Expected: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Marty", age: 18>, amount: 35000 })
+              beta_line  %(  Actual: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Doc", age: 50>, amount: 35000 })
             end
           }
 
@@ -1091,8 +1190,10 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(  {)
               plain_line %(    order_id: 1234,)
               plain_line %(    person: #<SuperDiff::Test::Person {)
-              red_line   %(-     name: "Marty")
-              green_line %(+     name: "Doc")
+              alpha_line %(-     name: "Marty",)
+              beta_line  %(+     name: "Doc",)
+              alpha_line %(-     age: 18)
+              beta_line  %(+     age: 50)
               plain_line %(    }>,)
               plain_line %(    amount: 35000)
               plain_line %(  })
@@ -1152,8 +1253,8 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: { customer: { name: "Marty McFly", shipping_address: { line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Chevy 4x4" }] })
-              green_line %(  Actual: { customer: { name: "Marty McFly, Jr.", shipping_address: { line_1: "456 Ponderosa Ct.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Mattel Hoverboard" }] })
+              alpha_line %(Expected: { customer: { name: "Marty McFly", shipping_address: { line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Chevy 4x4" }] })
+              beta_line  %(  Actual: { customer: { name: "Marty McFly, Jr.", shipping_address: { line_1: "456 Ponderosa Ct.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Mattel Hoverboard" }] })
             end
           }
 
@@ -1163,11 +1264,11 @@ RSpec.describe SuperDiff::EqualityMatcher do
             colored do
               plain_line %(  {)
               plain_line %(    customer: {)
-              red_line   %(-     name: "Marty McFly",)
-              green_line %(+     name: "Marty McFly, Jr.",)
+              alpha_line %(-     name: "Marty McFly",)
+              beta_line  %(+     name: "Marty McFly, Jr.",)
               plain_line %(      shipping_address: {)
-              red_line   %(-       line_1: "123 Main St.",)
-              green_line %(+       line_1: "456 Ponderosa Ct.",)
+              alpha_line %(-       line_1: "123 Main St.",)
+              beta_line  %(+       line_1: "456 Ponderosa Ct.",)
               plain_line %(        city: "Hill Valley",)
               plain_line %(        state: "CA",)
               plain_line %(        zip: "90382")
@@ -1177,11 +1278,15 @@ RSpec.describe SuperDiff::EqualityMatcher do
               plain_line %(      {)
               plain_line %(        name: "Fender Stratocaster",)
               plain_line %(        cost: 100000,)
-              plain_line %(        options: ["red", "blue", "green"])
+              plain_line %(        options: [)
+              plain_line %(          "red",)
+              plain_line %(          "blue",)
+              plain_line %(          "green")
+              plain_line %(        ])
               plain_line %(      },)
               plain_line %(      {)
-              red_line   %(-       name: "Chevy 4x4")
-              green_line %(+       name: "Mattel Hoverboard")
+              alpha_line %(-       name: "Chevy 4x4")
+              beta_line  %(+       name: "Mattel Hoverboard")
               plain_line %(      })
               plain_line %(    ])
               plain_line %(  })
@@ -1193,10 +1298,10 @@ RSpec.describe SuperDiff::EqualityMatcher do
       end
     end
 
-    context "given two objects which == each other" do
+    context "given two custom objects which == each other" do
       it "returns an empty string" do
-        expected = SuperDiff::Test::Person.new(name: "Marty")
-        actual = SuperDiff::Test::Person.new(name: "Marty")
+        expected = SuperDiff::Test::Person.new(name: "Marty", age: 18)
+        actual = SuperDiff::Test::Person.new(name: "Marty", age: 18)
 
         output = described_class.call(expected: expected, actual: actual)
 
@@ -1204,10 +1309,121 @@ RSpec.describe SuperDiff::EqualityMatcher do
       end
     end
 
-    context "given two objects which do not == each other" do
+    context "given two different versions of the same custom class" do
       it "returns a message along with a comparison" do
-        expected = SuperDiff::Test::Person.new(name: "Marty")
-        actual = SuperDiff::Test::Person.new(name: "Doc")
+        expected = SuperDiff::Test::Person.new(name: "Marty", age: 18)
+        actual = SuperDiff::Test::Person.new(name: "Doc", age: 50)
+
+        actual_output = described_class.call(
+          expected: expected,
+          actual: actual,
+        )
+
+        expected_output = <<~STR.strip
+          Differing objects.
+
+          #{
+            colored do
+              alpha_line %(Expected: #<SuperDiff::Test::Person name: "Marty", age: 18>)
+              beta_line  %(  Actual: #<SuperDiff::Test::Person name: "Doc", age: 50>)
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              plain_line %(  #<SuperDiff::Test::Person {)
+              alpha_line %(-   name: "Marty",)
+              beta_line  %(+   name: "Doc",)
+              alpha_line %(-   age: 18)
+              beta_line  %(+   age: 50)
+              plain_line %(  }>)
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two different versions of the same non-custom class" do
+      it "returns a message along with the diff" do
+        expected = SuperDiff::Test::Player.new(
+          handle: "martymcfly",
+          character: "mirage",
+          inventory: ["flatline", "purple body shield"],
+          shields: 0.6,
+          health: 0.3,
+          ultimate: 0.8,
+        )
+        actual = SuperDiff::Test::Player.new(
+          handle: "docbrown",
+          character: "lifeline",
+          inventory: ["wingman", "mastiff"],
+          shields: 0.6,
+          health: 0.3,
+          ultimate: 0.8,
+        )
+
+        actual_output = described_class.call(expected: expected, actual: actual)
+
+        expected_output = <<~STR.strip
+          Differing objects.
+
+          #{
+            if SuperDiff::Test.jruby?
+              # Source: <https://github.com/jruby/jruby/blob/master/core/src/main/java/org/jruby/RubyBasicObject.java>
+              colored do
+                alpha_line %(Expected: #<SuperDiff::Test::Player:#{"0x%x" % expected.hash} @inventory=["flatline", "purple body shield"], @character="mirage", @handle="martymcfly", @ultimate=0.8, @shields=0.6, @health=0.3>)
+                beta_line  %(  Actual: #<SuperDiff::Test::Player:#{"0x%x" % actual.hash} @inventory=["wingman", "mastiff"], @character="lifeline", @handle="docbrown", @ultimate=0.8, @shields=0.6, @health=0.3>)
+              end
+            else
+              colored do
+                alpha_line %(Expected: #<SuperDiff::Test::Player:#{"0x%016x" % (expected.object_id * 2)} @handle="martymcfly", @character="mirage", @inventory=["flatline", "purple body shield"], @shields=0.6, @health=0.3, @ultimate=0.8>)
+                beta_line  %(  Actual: #<SuperDiff::Test::Player:#{"0x%016x" % (actual.object_id * 2)} @handle="docbrown", @character="lifeline", @inventory=["wingman", "mastiff"], @shields=0.6, @health=0.3, @ultimate=0.8>)
+              end
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              plain_line %(  #<SuperDiff::Test::Player {)
+              alpha_line %(-   @character="mirage",)
+              beta_line  %(+   @character="lifeline",)
+              alpha_line %(-   @handle="martymcfly",)
+              beta_line  %(+   @handle="docbrown",)
+              plain_line %(    @health=0.3,)
+              plain_line %(    @inventory=[)
+              alpha_line %(-     "flatline",)
+              beta_line  %(+     "wingman",)
+              alpha_line %(-     "purple body shield")
+              beta_line  %(+     "mastiff")
+              plain_line %(    ],)
+              plain_line %(    @shields=0.6,)
+              plain_line %(    @ultimate=0.8)
+              plain_line %(  }>)
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two completely different kinds of custom objects" do
+      it "returns a message along with the diff" do
+        expected = SuperDiff::Test::Person.new(
+          name: "Marty",
+          age: 31,
+        )
+        actual = SuperDiff::Test::Customer.new(
+          name: "Doc",
+          shipping_address: :some_shipping_address,
+          phone: "1234567890",
+        )
 
         actual_output = described_class.call(expected: expected, actual: actual)
 
@@ -1216,8 +1432,200 @@ RSpec.describe SuperDiff::EqualityMatcher do
 
           #{
             colored do
-              red_line   %(Expected: #<SuperDiff::Test::Person name: "Marty">)
-              green_line %(  Actual: #<SuperDiff::Test::Person name: "Doc">)
+              alpha_line %(Expected: #<SuperDiff::Test::Person name: "Marty", age: 31>)
+              beta_line  %(  Actual: #<SuperDiff::Test::Customer name: "Doc", shipping_address: :some_shipping_address, phone: "1234567890">)
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two completely different kinds of non-custom objects" do
+      it "returns a message along with the diff" do
+        expected = SuperDiff::Test::Item.new(
+          name: "camera",
+          quantity: 3,
+        )
+        actual = SuperDiff::Test::Player.new(
+          handle: "mcmire",
+          character: "Jon",
+          inventory: ["sword"],
+          shields: 11.4,
+          health: 4,
+          ultimate: true,
+        )
+
+        actual_output = described_class.call(expected: expected, actual: actual)
+
+        expected_output = <<~STR.strip
+          Differing objects.
+
+          #{
+            if SuperDiff::Test.jruby?
+              # Source: <https://github.com/jruby/jruby/blob/master/core/src/main/java/org/jruby/RubyBasicObject.java>
+              colored do
+                alpha_line %(Expected: #<SuperDiff::Test::Item:#{"0x%x" % expected.hash} @name="camera", @quantity=3>)
+                beta_line  %(  Actual: #<SuperDiff::Test::Player:#{"0x%x" % actual.hash} @inventory=["sword"], @character="Jon", @handle="mcmire", @ultimate=true, @shields=11.4, @health=4>)
+              end
+            else
+              colored do
+                alpha_line %(Expected: #<SuperDiff::Test::Item:#{"0x%016x" % (expected.object_id * 2)} @name="camera", @quantity=3>)
+                beta_line  %(  Actual: #<SuperDiff::Test::Player:#{"0x%016x" % (actual.object_id * 2)} @handle="mcmire", @character="Jon", @inventory=["sword"], @shields=11.4, @health=4, @ultimate=true>)
+              end
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "when the expected value is a data structure that refers to itself somewhere inside of it" do
+      it "replaces the reference with ∙∙∙" do
+        expected = ["a", "b", "c"]
+        expected.insert(1, expected)
+        actual = ["a", "x", "b", "c"]
+
+        actual_output = described_class.call(expected: expected, actual: actual)
+
+        expected_output = <<~STR.strip
+          Differing arrays.
+
+          #{
+            colored do
+              alpha_line %(Expected: ["a", ∙∙∙, "b", "c"])
+              beta_line  %(  Actual: ["a", "x", "b", "c"])
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              plain_line %(  [)
+              plain_line %(    "a",)
+              alpha_line %(-   ∙∙∙,)
+              beta_line  %(+   "x",)
+              plain_line %(    "b",)
+              plain_line %(    "c")
+              plain_line %(  ])
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "when the actual value is a data structure that refers to itself somewhere inside of it" do
+      it "replaces the reference with ∙∙∙" do
+        expected = ["a", "x", "b", "c"]
+        actual = ["a", "b", "c"]
+        actual.insert(1, actual)
+
+        actual_output = described_class.call(expected: expected, actual: actual)
+
+        expected_output = <<~STR.strip
+          Differing arrays.
+
+          #{
+            colored do
+              alpha_line %(Expected: ["a", "x", "b", "c"])
+              beta_line  %(  Actual: ["a", ∙∙∙, "b", "c"])
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              plain_line %(  [)
+              plain_line %(    "a",)
+              alpha_line %(-   "x",)
+              beta_line  %(+   ∙∙∙,)
+              plain_line %(    "b",)
+              plain_line %(    "c")
+              plain_line %(  ])
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "when the data structure being different is present inside a secondary layer" do
+      it "replaces the reference with ∙∙∙" do
+        expected = { foo: ["a", "x", "b", "c"] }
+        actual = { foo: ["a", "b", "c"] }
+        actual[:foo].insert(1, actual)
+
+        actual_output = described_class.call(expected: expected, actual: actual)
+
+        expected_output = <<~STR.strip
+          Differing hashes.
+
+          #{
+            colored do
+              alpha_line %(Expected: { foo: ["a", "x", "b", "c"] })
+              beta_line  %(  Actual: { foo: ["a", ∙∙∙, "b", "c"] })
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              plain_line %(  {)
+              plain_line %(    foo: [)
+              plain_line %(      "a",)
+              alpha_line %(-     "x",)
+              beta_line  %(+     ∙∙∙,)
+              plain_line %(      "b",)
+              plain_line %(      "c")
+              plain_line %(    ])
+              plain_line %(  })
+            end
+          }
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "when a secondary layer of a data structure refers to itself" do
+      it "replaces the reference with ∙∙∙" do
+        expected = { foo: ["a", "x", "b", "c"] }
+        actual = { foo: ["a", "b", "c"] }
+        actual[:foo].insert(1, actual[:foo])
+
+        actual_output = described_class.call(expected: expected, actual: actual)
+
+        expected_output = <<~STR.strip
+          Differing hashes.
+
+          #{
+            colored do
+              alpha_line %(Expected: { foo: ["a", "x", "b", "c"] })
+              beta_line  %(  Actual: { foo: ["a", ∙∙∙, "b", "c"] })
+            end
+          }
+
+          Diff:
+
+          #{
+            colored do
+              plain_line %(  {)
+              plain_line %(    foo: [)
+              plain_line %(      "a",)
+              alpha_line %(-     "x",)
+              beta_line  %(+     ∙∙∙,)
+              plain_line %(      "b",)
+              plain_line %(      "c")
+              plain_line %(    ])
+              plain_line %(  })
             end
           }
         STR
@@ -1227,7 +1635,7 @@ RSpec.describe SuperDiff::EqualityMatcher do
     end
   end
 
-  def colored(&block)
-    SuperDiff::Tests::Colorizer.call(&block).chomp
+  def colored(*args, **opts, &block)
+    SuperDiff::Helpers.style(*args, **opts, &block).to_s.chomp
   end
 end