super_diff 0.9.0 → 0.11.0

data/spec/integration/rspec/eq_matcher_spec.rb

@@ -4,51 +4,55 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
   context "when comparing two different integers" do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
-        snippet = %|expect(1).to eq(42)|
+        snippet = "expect(1).to eq(42)"
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: snippet,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|1|
-              plain    %| to eq |
-              expected %|42|
-              plain    %|.|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: snippet,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "1"
+                  plain " to eq "
+                  expected "42"
+                  plain "."
+                end
+              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
 
     it "produces the correct failure message when used in the negative" do
       as_both_colored_and_uncolored do |color_enabled|
-        snippet = %|expect(42).not_to eq(42)|
+        snippet = "expect(42).not_to eq(42)"
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: snippet,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|42|
-              plain    %| not to eq |
-              expected %|42|
-              plain    %|.|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: snippet,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "42"
+                  plain " not to eq "
+                  expected "42"
+                  plain "."
+                end
+              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
@@ -56,57 +60,55 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
   context "when comparing two different symbols" do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
-        snippet = %|expect(:bar).to eq(:foo)|
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
+        snippet = "expect(:bar).to eq(:foo)"
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: snippet,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|:bar|
-              plain    %| to eq |
-              expected %|:foo|
-              plain    %|.|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: snippet,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual ":bar"
+                  plain " to eq "
+                  expected ":foo"
+                  plain "."
+                end
+              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
 
     it "produces the correct failure message when used in the negative" do
       as_both_colored_and_uncolored do |color_enabled|
-        snippet = %|expect(:foo).not_to eq(:foo)|
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
+        snippet = "expect(:foo).not_to eq(:foo)"
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: snippet,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|:foo|
-              plain    %| not to eq |
-              expected %|:foo|
-              plain    %|.|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: snippet,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual ":foo"
+                  plain " not to eq "
+                  expected ":foo"
+                  plain "."
+                end
+              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
@@ -115,56 +117,54 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = %|expect("Jennifer").to eq("Marty")|
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect("Jennifer").to eq("Marty")|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|"Jennifer"|
-              plain    %| to eq |
-              expected %|"Marty"|
-              plain    %|.|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect("Jennifer").to eq("Marty")|,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|"Jennifer"|
+                  plain " to eq "
+                  expected %|"Marty"|
+                  plain "."
+                end
+              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
 
     it "produces the correct failure message when used in the negative" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = %|expect("Jennifer").not_to eq("Jennifer")|
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect("Jennifer").not_to eq("Jennifer")|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|"Jennifer"|
-              plain    %| not to eq |
-              expected %|"Jennifer"|
-              plain    %|.|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect("Jennifer").not_to eq("Jennifer")|,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|"Jennifer"|
+                  plain " not to eq "
+                  expected %|"Jennifer"|
+                  plain "."
+                end
+              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
@@ -173,48 +173,48 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~RUBY
-          expected = Time.utc(2011, 12, 13, 14, 15, 16)
-          actual   = Time.utc(2011, 12, 13, 14, 15, 16, 500_000)
-          expect(expected).to eq(actual)
+          actual = Time.utc(2011, 12, 13, 14, 15, 16)
+          expected = Time.utc(2011, 12, 13, 14, 15, 16, 500_000)
+          expect(actual).to eq(expected)
         RUBY
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(expected).to eq(actual)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|#<Time 2011-12-13 14:15:16 +00:00 (UTC)>|
-            end
-
-            line do
-              plain    %|   to eq |
-              expected %|#<Time 2011-12-13 14:15:16+(1/2) +00:00 (UTC)>|
-            end
-          },
-          diff: proc {
-            plain_line    "  #<Time {"
-            plain_line    "    year: 2011,"
-            plain_line    "    month: 12,"
-            plain_line    "    day: 13,"
-            plain_line    "    hour: 14,"
-            plain_line    "    min: 15,"
-            plain_line    "    sec: 16,"
-            expected_line "-   subsec: (1/2),"
-            actual_line   "+   subsec: 0,"
-            plain_line    "    zone: \"UTC\","
-            plain_line    "    utc_offset: 0"
-            plain_line    "  }>"
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "#<Time 2011-12-13 14:15:16 +00:00 (UTC)>"
+                end
+
+                line do
+                  plain "   to eq "
+                  expected "#<Time 2011-12-13 14:15:16+(1/2) +00:00 (UTC)>"
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  #<Time {"
+                plain_line "    year: 2011,"
+                plain_line "    month: 12,"
+                plain_line "    day: 13,"
+                plain_line "    hour: 14,"
+                plain_line "    min: 15,"
+                plain_line "    sec: 16,"
+                expected_line "-   subsec: (1/2),"
+                actual_line "+   subsec: 0,"
+                plain_line "    zone: \"UTC\","
+                plain_line "    utc_offset: 0"
+                plain_line "  }>"
+              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
 
@@ -224,31 +224,102 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
           time = Time.utc(2011, 12, 13, 14, 15, 16)
           expect(time).not_to eq(time)
         RUBY
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
+
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(time).not_to eq(time)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain " Expected "
+                  actual "#<Time 2011-12-13 14:15:16 +00:00 (UTC)>"
+                end
+
+                line do
+                  plain "not to eq "
+                  expected "#<Time 2011-12-13 14:15:16 +00:00 (UTC)>"
+                end
+              end
+          )
+
+        expect(program).to produce_output_when_run(expected_output).in_color(
+          color_enabled
         )
+      end
+    end
+  end
+
+  context "when comparing two different Date instances" do
+    it "produces the correct failure message when used in the positive" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~RUBY
+          actual = Date.new(2023, 10, 14)
+          expected = Date.new(2023, 10, 31)
+          expect(actual).to eq(expected)
+        RUBY
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(time).not_to eq(time)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %| Expected |
-              actual   %|#<Time 2011-12-13 14:15:16 +00:00 (UTC)>|
-            end
-
-            line do
-              plain    %|not to eq |
-              expected %|#<Time 2011-12-13 14:15:16 +00:00 (UTC)>|
-            end
-          },
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "#<Date 2023-10-14>"
+                  plain " to eq "
+                  expected "#<Date 2023-10-31>"
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  #<Date {"
+                plain_line "    year: 2023,"
+                plain_line "    month: 10,"
+                expected_line "-   day: 31"
+                actual_line "+   day: 14"
+                plain_line "  }>"
+              end
+          )
+
+        expect(program).to produce_output_when_run(expected_output).in_color(
+          color_enabled
         )
+      end
+    end
 
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled)
+    it "produces the correct failure message when used in the negative" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~RUBY
+          date = Date.new(2023, 10, 14)
+          expect(date).not_to eq(date)
+        RUBY
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
+
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(date).not_to eq(date)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "#<Date 2023-10-14>"
+                  plain " not to eq "
+                  expected "#<Date 2023-10-14>"
+                  plain "."
+                end
+              end
+          )
+
+        expect(program).to produce_output_when_run(expected_output).in_color(
+          color_enabled
+        )
       end
     end
   end
@@ -257,34 +328,37 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = "This is a line\\nAnd that's another line\\n"
           expected = "Something entirely different"
-          actual   = "This is a line\\nAnd that's another line\\n"
           expect(actual).to eq(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 eq(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|"This is a line\\nAnd that's another line\\n"|
-              plain    %| to eq |
-              expected %|"Something entirely different"|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            expected_line %|- Something entirely different|
-            actual_line   %|+ This is a line\\n|
-            actual_line   %|+ And that's another line\\n|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|"This is a line\\nAnd that's another line\\n"|
+                  plain " to eq "
+                  expected %|"Something entirely different"|
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                expected_line "- Something entirely different"
+                actual_line %|+ This is a line\\n|
+                actual_line %|+ And that's another line\\n|
+              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
@@ -293,34 +367,37 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = "Something entirely different"
           expected = "This is a line\\nAnd that's another line\\n"
-          actual   = "Something entirely different"
           expect(actual).to eq(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 eq(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|"Something entirely different"|
-              plain    %| to eq |
-              expected %|"This is a line\\nAnd that's another line\\n"|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            expected_line %|- This is a line\\n|
-            expected_line %|- And that's another line\\n|
-            actual_line   %|+ Something entirely different|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|"Something entirely different"|
+                  plain " to eq "
+                  expected %|"This is a line\\nAnd that's another line\\n"|
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                expected_line %|- This is a line\\n|
+                expected_line %|- And that's another line\\n|
+                actual_line "+ Something entirely different"
+              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
@@ -329,37 +406,40 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = "This is a line\\nSomething completely different\\nAnd there's a line too\\n"
           expected = "This is a line\\nAnd that's a line\\nAnd there's a line too\\n"
-          actual   = "This is a line\\nSomething completely different\\nAnd there's a line too\\n"
           expect(actual).to eq(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 eq(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|"This is a line\\nSomething completely different\\nAnd there's a line too\\n"|
-            end
-
-            line do
-              plain    %|   to eq |
-              expected %|"This is a line\\nAnd that's a line\\nAnd there's a line too\\n"|
-            end
-          },
-          diff: proc {
-            plain_line    %|  This is a line\\n|
-            expected_line %|- And that's a line\\n|
-            actual_line   %|+ Something completely different\\n|
-            plain_line    %|  And there's a line too\\n|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|"This is a line\\nSomething completely different\\nAnd there's a line too\\n"|
+                end
+
+                line do
+                  plain "   to eq "
+                  expected %|"This is a line\\nAnd that's a line\\nAnd there's a line too\\n"|
+                end
+              end,
+            diff:
+              proc do
+                plain_line %|  This is a line\\n|
+                expected_line %|- And that's a line\\n|
+                actual_line %|+ Something completely different\\n|
+                plain_line %|  And there's a line too\\n|
+              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
 
@@ -371,26 +451,28 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
         TEST
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(string).not_to eq(string)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %| Expected |
-              actual   %|"This is a line\\nAnd that's a line\\nAnd there's a line too\\n"|
-            end
-
-            line do
-              plain    %|not to eq |
-              expected %|"This is a line\\nAnd that's a line\\nAnd there's a line too\\n"|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(string).not_to eq(string)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain " Expected "
+                  actual %|"This is a line\\nAnd that's a line\\nAnd there's a line too\\n"|
+                end
+
+                line do
+                  plain "not to eq "
+                  expected %|"This is a line\\nAnd that's a line\\nAnd there's a line too\\n"|
+                end
+              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
@@ -399,20 +481,7 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST
-          expected = [
-            [
-              :h1,
-              [:span, [:text, "Hello world"]],
-              {
-                class: "header",
-                data: {
-                  "sticky" => true,
-                  person: SuperDiff::Test::Person.new(name: "Marty", age: 60)
-                }
-              }
-            ]
-          ]
-          actual   = [
+          actual = [
             [
               :h2,
               [:span, [:text, "Goodbye world"]],
@@ -428,60 +497,76 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
             ],
             :br
           ]
+          expected = [
+            [
+              :h1,
+              [:span, [:text, "Hello world"]],
+              {
+                class: "header",
+                data: {
+                  "sticky" => true,
+                  person: SuperDiff::Test::Person.new(name: "Marty", age: 60)
+                }
+              }
+            ]
+          ]
           expect(actual).to eq(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 eq(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|[[:h2, [:span, [:text, "Goodbye world"]], { id: "hero", class: "header", data: { "sticky" => false, :role => "deprecated", :person => #<SuperDiff::Test::Person name: "Doc", age: 60> } }], :br]|
-            end
-
-            line do
-              plain    %|   to eq |
-              expected %|[[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true, :person => #<SuperDiff::Test::Person name: "Marty", age: 60> } }]]|
-            end
-          },
-          diff: proc {
-            plain_line    %|  [|
-            plain_line    %|    [|
-            expected_line %|-     :h1,|
-            actual_line   %|+     :h2,|
-            plain_line    %|      [|
-            plain_line    %|        :span,|
-            plain_line    %|        [|
-            plain_line    %|          :text,|
-            expected_line %|-         "Hello world"|
-            actual_line   %|+         "Goodbye world"|
-            plain_line    %|        ]|
-            plain_line    %|      ],|
-            plain_line    %|      {|
-            actual_line   %|+       id: "hero",|
-            plain_line    %|        class: "header",|
-            plain_line    %|        data: {|
-            expected_line %|-         "sticky" => true,|
-            actual_line   %|+         "sticky" => false,|
-            actual_line   %|+         :role => "deprecated",|
-            plain_line    %|          :person => #<SuperDiff::Test::Person {|
-            expected_line %|-           name: "Marty",|
-            actual_line   %|+           name: "Doc",|
-            plain_line    %|            age: 60|
-            plain_line    %|          }>|
-            plain_line    %|        }|
-            plain_line    %|      }|
-            plain_line    %|    ],|
-            actual_line   %|+   :br|
-            plain_line    %|  ]|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|[[:h2, [:span, [:text, "Goodbye world"]], { id: "hero", class: "header", data: { "sticky" => false, :role => "deprecated", :person => #<SuperDiff::Test::Person name: "Doc", age: 60> } }], :br]|
+                end
+
+                line do
+                  plain "   to eq "
+                  expected %|[[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true, :person => #<SuperDiff::Test::Person name: "Marty", age: 60> } }]]|
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  ["
+                plain_line "    ["
+                expected_line "-     :h1,"
+                actual_line "+     :h2,"
+                plain_line "      ["
+                plain_line "        :span,"
+                plain_line "        ["
+                plain_line "          :text,"
+                expected_line %|-         "Hello world"|
+                actual_line %|+         "Goodbye world"|
+                plain_line "        ]"
+                plain_line "      ],"
+                plain_line "      {"
+                actual_line %|+       id: "hero",|
+                plain_line %|        class: "header",|
+                plain_line "        data: {"
+                expected_line %|-         "sticky" => true,|
+                actual_line %|+         "sticky" => false,|
+                actual_line %|+         :role => "deprecated",|
+                plain_line "          :person => #<SuperDiff::Test::Person {"
+                expected_line %|-           name: "Marty",|
+                actual_line %|+           name: "Doc",|
+                plain_line "            age: 60"
+                plain_line "          }>"
+                plain_line "        }"
+                plain_line "      }"
+                plain_line "    ],"
+                actual_line "+   :br"
+                plain_line "  ]"
+              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
 
@@ -505,26 +590,28 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
         TEST
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(value).not_to eq(value)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %| Expected |
-              actual   %|[[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true, :person => #<SuperDiff::Test::Person name: "Marty", age: 60> } }]]|
-            end
-
-            line do
-              plain    %|not to eq |
-              expected %|[[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true, :person => #<SuperDiff::Test::Person name: "Marty", age: 60> } }]]|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(value).not_to eq(value)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain " Expected "
+                  actual %|[[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true, :person => #<SuperDiff::Test::Person name: "Marty", age: 60> } }]]|
+                end
+
+                line do
+                  plain "not to eq "
+                  expected %|[[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true, :person => #<SuperDiff::Test::Person name: "Marty", age: 60> } }]]|
+                end
+              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
@@ -533,11 +620,11 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
-          expected = {
+          actual = {
             customer: {
-              person: SuperDiff::Test::Person.new(name: "Marty McFly", age: 17),
+              person: SuperDiff::Test::Person.new(name: "Marty McFly, Jr.", age: 17),
               shipping_address: {
-                line_1: "123 Main St.",
+                line_1: "456 Ponderosa Ct.",
                 city: "Hill Valley",
                 state: "CA",
                 zip: "90382"
@@ -549,14 +636,14 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
                 cost: 100_000,
                 options: ["red", "blue", "green"]
               },
-              { name: "Chevy 4x4" }
+              { name: "Mattel Hoverboard" }
             ]
           }
-          actual   = {
+          expected = {
             customer: {
-              person: SuperDiff::Test::Person.new(name: "Marty McFly, Jr.", age: 17),
+              person: SuperDiff::Test::Person.new(name: "Marty McFly", age: 17),
               shipping_address: {
-                line_1: "456 Ponderosa Ct.",
+                line_1: "123 Main St.",
                 city: "Hill Valley",
                 state: "CA",
                 zip: "90382"
@@ -568,65 +655,68 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
                 cost: 100_000,
                 options: ["red", "blue", "green"]
               },
-              { name: "Mattel Hoverboard" }
+              { name: "Chevy 4x4" }
             ]
           }
           expect(actual).to eq(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 eq(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly, Jr.", age: 17>, 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
-
-            line do
-              plain    %|   to eq |
-              expected %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly", age: 17>, 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" }] }|
-            end
-          },
-          diff: proc {
-            plain_line    %|  {|
-            plain_line    %|    customer: {|
-            plain_line    %|      person: #<SuperDiff::Test::Person {|
-            expected_line %|-       name: "Marty McFly",|
-            actual_line   %|+       name: "Marty McFly, Jr.",|
-            plain_line    %|        age: 17|
-            plain_line    %|      }>,|
-            plain_line    %|      shipping_address: {|
-            expected_line %|-       line_1: "123 Main St.",|
-            actual_line   %|+       line_1: "456 Ponderosa Ct.",|
-            plain_line    %|        city: "Hill Valley",|
-            plain_line    %|        state: "CA",|
-            plain_line    %|        zip: "90382"|
-            plain_line    %|      }|
-            plain_line    %|    },|
-            plain_line    %|    items: [|
-            plain_line    %|      {|
-            plain_line    %|        name: "Fender Stratocaster",|
-            plain_line    %|        cost: 100000,|
-            plain_line    %|        options: [|
-            plain_line    %|          "red",|
-            plain_line    %|          "blue",|
-            plain_line    %|          "green"|
-            plain_line    %|        ]|
-            plain_line    %|      },|
-            plain_line    %|      {|
-            expected_line %|-       name: "Chevy 4x4"|
-            actual_line   %|+       name: "Mattel Hoverboard"|
-            plain_line    %|      }|
-            plain_line    %|    ]|
-            plain_line    %|  }|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly, Jr.", age: 17>, 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
+
+                line do
+                  plain "   to eq "
+                  expected %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly", age: 17>, 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" }] }|
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  {"
+                plain_line "    customer: {"
+                plain_line "      person: #<SuperDiff::Test::Person {"
+                expected_line %|-       name: "Marty McFly",|
+                actual_line %|+       name: "Marty McFly, Jr.",|
+                plain_line "        age: 17"
+                plain_line "      }>,"
+                plain_line "      shipping_address: {"
+                expected_line %|-       line_1: "123 Main St.",|
+                actual_line %|+       line_1: "456 Ponderosa Ct.",|
+                plain_line %|        city: "Hill Valley",|
+                plain_line %|        state: "CA",|
+                plain_line %|        zip: "90382"|
+                plain_line "      }"
+                plain_line "    },"
+                plain_line "    items: ["
+                plain_line "      {"
+                plain_line %|        name: "Fender Stratocaster",|
+                plain_line "        cost: 100000,"
+                plain_line "        options: ["
+                plain_line %|          "red",|
+                plain_line %|          "blue",|
+                plain_line %|          "green"|
+                plain_line "        ]"
+                plain_line "      },"
+                plain_line "      {"
+                expected_line %|-       name: "Chevy 4x4"|
+                actual_line %|+       name: "Mattel Hoverboard"|
+                plain_line "      }"
+                plain_line "    ]"
+                plain_line "  }"
+              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
 
@@ -656,26 +746,28 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
         TEST
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(value).not_to eq(value)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %| Expected |
-              actual   %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly", age: 17>, 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" }] }|
-            end
-
-            line do
-              plain    %|not to eq |
-              expected %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly", age: 17>, 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" }] }|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(value).not_to eq(value)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain " Expected "
+                  actual %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly", age: 17>, 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" }] }|
+                end
+
+                line do
+                  plain "not to eq "
+                  expected %|{ customer: { person: #<SuperDiff::Test::Person name: "Marty McFly", age: 17>, 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" }] }|
+                end
+              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
@@ -684,39 +776,41 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
-          expected = SuperDiff::Test::Person.new(
-            name: "Marty",
-            age: 31,
-          )
-          actual   = SuperDiff::Test::Customer.new(
+          actual = SuperDiff::Test::Customer.new(
             name: "Doc",
             shipping_address: :some_shipping_address,
             phone: "1234567890",
           )
+          expected = SuperDiff::Test::Person.new(
+            name: "Marty",
+            age: 31,
+          )
           expect(actual).to eq(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 eq(expected)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|#<SuperDiff::Test::Customer name: "Doc", shipping_address: :some_shipping_address, phone: "1234567890">|
-            end
-
-            line do
-              plain    %|   to eq |
-              expected %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|#<SuperDiff::Test::Customer name: "Doc", shipping_address: :some_shipping_address, phone: "1234567890">|
+                end
+
+                line do
+                  plain "   to eq "
+                  expected %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
+                end
+              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
 
@@ -731,26 +825,28 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
         TEST
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(value).not_to eq(value)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %| Expected |
-              actual   %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
-            end
-
-            line do
-              plain    %|not to eq |
-              expected %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(value).not_to eq(value)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain " Expected "
+                  actual %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
+                end
+
+                line do
+                  plain "not to eq "
+                  expected %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
+                end
+              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
@@ -759,11 +855,7 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "produces the correct failure message when used in the positive" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
-          expected = SuperDiff::Test::Item.new(
-            name: "camera",
-            quantity: 3,
-          )
-          actual   = SuperDiff::Test::Player.new(
+          actual = SuperDiff::Test::Player.new(
             handle: "mcmire",
             character: "Jon",
             inventory: ["sword"],
@@ -771,31 +863,36 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
             health: 4,
             ultimate: true,
           )
+          expected = SuperDiff::Test::Item.new(
+            name: "camera",
+            quantity: 3,
+          )
           expect(actual).to eq(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 eq(expected)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|#<SuperDiff::Test::Player @character="Jon", @handle="mcmire", @health=4, @inventory=["sword"], @shields=11.4, @ultimate=true>|
-            end
-
-            line do
-              plain    %|   to eq |
-              expected %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|#<SuperDiff::Test::Player @character="Jon", @handle="mcmire", @health=4, @inventory=["sword"], @shields=11.4, @ultimate=true>|
+                end
+
+                line do
+                  plain "   to eq "
+                  expected %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
+                end
+              end
+          )
 
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled).
-          removing_object_ids
+        expect(program).to produce_output_when_run(expected_output).in_color(
+          color_enabled
+        ).removing_object_ids
       end
     end
 
@@ -810,27 +907,28 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
         TEST
         program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(value).not_to eq(value)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %| Expected |
-              actual   %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
-            end
-
-            line do
-              plain    %|not to eq |
-              expected %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(value).not_to eq(value)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain " Expected "
+                  actual %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
+                end
+
+                line do
+                  plain "not to eq "
+                  expected %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
+                end
+              end
+          )
 
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled).
-          removing_object_ids
+        expect(program).to produce_output_when_run(expected_output).in_color(
+          color_enabled
+        ).removing_object_ids
       end
     end
   end
@@ -839,36 +937,39 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "formats the array correctly in the diff" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = { foo: [] }
           expected = { foo: nil }
-          actual   = { foo: [] }
           expect(actual).to eq(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 eq(expected)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|{ foo: [] }|
-              plain    %| to eq |
-              expected %|{ foo: nil }|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            plain_line    %|  {|
-            expected_line %|-   foo: nil|
-            actual_line   %|+   foo: []|
-            plain_line    %|  }|
-          }
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "{ foo: [] }"
+                  plain " to eq "
+                  expected "{ foo: nil }"
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  {"
+                expected_line "-   foo: nil"
+                actual_line "+   foo: []"
+                plain_line "  }"
+              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
@@ -877,36 +978,39 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "formats the hash correctly in the diff" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = { foo: {} }
           expected = { foo: nil }
-          actual   = { foo: {} }
           expect(actual).to eq(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 eq(expected)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|{ foo: {} }|
-              plain    %| to eq |
-              expected %|{ foo: nil }|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            plain_line    %|  {|
-            expected_line %|-   foo: nil|
-            actual_line   %|+   foo: {}|
-            plain_line    %|  }|
-          }
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "{ foo: {} }"
+                  plain " to eq "
+                  expected "{ foo: nil }"
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  {"
+                expected_line "-   foo: nil"
+                actual_line "+   foo: {}"
+                plain_line "  }"
+              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
@@ -915,37 +1019,39 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
     it "formats the object correctly in the diff" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = { foo: SuperDiff::Test::EmptyClass.new }
           expected = { foo: nil }
-          actual   = { foo: SuperDiff::Test::EmptyClass.new }
           expect(actual).to eq(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 eq(expected)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|{ foo: #<SuperDiff::Test::EmptyClass> }|
-              plain    %| to eq |
-              expected %|{ foo: nil }|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            plain_line    %|  {|
-            expected_line %|-   foo: nil|
-            actual_line   %|+   foo: #<SuperDiff::Test::EmptyClass>|
-            plain_line    %|  }|
-          }
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to eq(expected)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual "{ foo: #<SuperDiff::Test::EmptyClass> }"
+                  plain " to eq "
+                  expected "{ foo: nil }"
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  {"
+                expected_line "-   foo: nil"
+                actual_line "+   foo: #<SuperDiff::Test::EmptyClass>"
+                plain_line "  }"
+              end
+          )
 
-        expect(program).
-          to produce_output_when_run(expected_output).
-          in_color(color_enabled).
-          removing_object_ids
+        expect(program).to produce_output_when_run(expected_output).in_color(
+          color_enabled
+        ).removing_object_ids
       end
     end
   end
@@ -953,4 +1059,8 @@ RSpec.describe "Integration with RSpec's #eq matcher", type: :integration do
   it_behaves_like "a matcher that supports elided diffs" do
     let(:matcher) { :eq }
   end
+
+  it_behaves_like "a matcher that supports a toggleable key" do
+    let(:matcher) { :eq }
+  end
 end