super_diff 0.9.0 → 0.11.0

data/spec/integration/rspec/match_matcher_spec.rb

@@ -6,70 +6,71 @@ RSpec.describe "Integration with RSpec's #match 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 = { city: "Burbank" }
             expected = a_hash_including(city: "Hill Valley")
-            actual   = { city: "Burbank" }
             expect(actual).to match(expected)
           TEST
-          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(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ city: "Burbank" }|
+                    plain " to match "
+                    expected %|#<a hash including (city: "Hill Valley")>|
+                    plain "."
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  expected_line %|-   city: "Hill Valley"|
+                  actual_line %|+   city: "Burbank"|
+                  plain_line "  }"
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ city: "Burbank" }|
-                plain    %| to match |
-                expected %|#<a hash including (city: "Hill Valley")>|
-                plain    %|.|
-              end
-            },
-            diff: proc {
-              plain_line    %|  {|
-              expected_line %|-   city: "Hill Valley"|
-              actual_line   %|+   city: "Burbank"|
-              plain_line    %|  }|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = { city: "Burbank" }
             expected = a_hash_including(city: "Burbank")
-            actual   = { city: "Burbank" }
             expect(actual).not_to match(expected)
           TEST
-          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(actual).not_to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ city: "Burbank" }|
+                    plain " not to match "
+                    expected %|#<a hash including (city: "Burbank")>|
+                    plain "."
+                  end
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ city: "Burbank" }|
-                plain    %| not to match |
-                expected %|#<a hash including (city: "Burbank")>|
-                plain    %|.|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -78,113 +79,107 @@ RSpec.describe "Integration with RSpec's #match 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 = a_hash_including(
-              city: "Hill Valley",
-              zip: "90382"
-            )
-            actual   = {
+            actual = {
               line_1: "123 Main St.",
               city: "Burbank",
               state: "CA",
               zip: "90210"
             }
+            expected = a_hash_including(
+              city: "Hill Valley",
+              zip: "90382"
+            )
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|#<a hash including (city: "Hill Valley", zip: "90382")>|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %|    line_1: "123 Main St.",|
+                  expected_line %|-   city: "Hill Valley",|
+                  actual_line %|+   city: "Burbank",|
+                  plain_line %|    state: "CA",|
+                  expected_line %|-   zip: "90382"|
+                  actual_line %|+   zip: "90210"|
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|#<a hash including (city: "Hill Valley", zip: "90382")>|
-              end
-            },
-            diff: proc {
-              plain_line    %|  {|
-              plain_line    %|    line_1: "123 Main St.",|
-              expected_line %|-   city: "Hill Valley",|
-              actual_line   %|+   city: "Burbank",|
-              plain_line    %|    state: "CA",|
-              expected_line %|-   zip: "90382"|
-              actual_line   %|+   zip: "90210"|
-              plain_line    %|  }|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = a_hash_including(
-              city: "Burbank",
-              zip: "90210"
-            )
-            actual   = {
+            actual = {
               line_1: "123 Main St.",
               city: "Burbank",
               state: "CA",
               zip: "90210"
             }
+            expected = a_hash_including(
+              city: "Burbank",
+              zip: "90210"
+            )
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|{ line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|{ line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" }|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|#<a hash including (city: "Burbank", zip: "90210")>|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|#<a hash including (city: "Burbank", zip: "90210")>|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
   end
 
   context "when the expected value includes a hash-including-<something>" do
-    context "and the corresponding actual   value is a hash" do
+    context "and the corresponding actual value is a hash" 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 = {
-              name: "Marty McFly",
-              address: a_hash_including(
-                city: "Hill Valley",
-                zip: "90382"
-              )
-            }
-            actual   = {
+            actual = {
               name: "Marty McFly",
               address: {
                 line_1: "123 Main St.",
@@ -193,59 +188,60 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
                 zip: "90210"
               }
             }
+            expected = {
+              name: "Marty McFly",
+              address: a_hash_including(
+                city: "Hill Valley",
+                zip: "90382"
+              )
+            }
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ name: "Marty McFly", address: { line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" } }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ name: "Marty McFly", address: { line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" } }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|{ name: "Marty McFly", address: #<a hash including (city: "Hill Valley", zip: "90382")> }|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %|    name: "Marty McFly",|
+                  plain_line "    address: {"
+                  plain_line %|      line_1: "123 Main St.",|
+                  expected_line %|-     city: "Hill Valley",|
+                  actual_line %|+     city: "Burbank",|
+                  plain_line %|      state: "CA",|
+                  expected_line %|-     zip: "90382"|
+                  actual_line %|+     zip: "90210"|
+                  plain_line "    }"
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|{ name: "Marty McFly", address: #<a hash including (city: "Hill Valley", zip: "90382")> }|
-              end
-            },
-            diff: proc {
-              plain_line    %|  {|
-              plain_line    %|    name: "Marty McFly",|
-              plain_line    %|    address: {|
-              plain_line    %|      line_1: "123 Main St.",|
-              expected_line %|-     city: "Hill Valley",|
-              actual_line   %|+     city: "Burbank",|
-              plain_line    %|      state: "CA",|
-              expected_line %|-     zip: "90382"|
-              actual_line   %|+     zip: "90210"|
-              plain_line    %|    }|
-              plain_line    %|  }|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = {
-              name: "Marty McFly",
-              address: a_hash_including(
-                city: "Burbank",
-                zip: "90210"
-              )
-            }
-            actual   = {
+            actual = {
               name: "Marty McFly",
               address: {
                 line_1: "123 Main St.",
@@ -254,41 +250,52 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
                 zip: "90210"
               }
             }
+            expected = {
+              name: "Marty McFly",
+              address: a_hash_including(
+                city: "Burbank",
+                zip: "90210"
+              )
+            }
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|{ name: "Marty McFly", address: { line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" } }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|{ name: "Marty McFly", address: { line_1: "123 Main St.", city: "Burbank", state: "CA", zip: "90210" } }|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|{ name: "Marty McFly", address: #<a hash including (city: "Burbank", zip: "90210")> }|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|{ name: "Marty McFly", address: #<a hash including (city: "Burbank", zip: "90210")> }|
-              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
 
-    context "and the corresponding actual   value is not a hash" do
+    context "and the corresponding actual value is not a hash" do
       it "produces the correct failure message" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = {
+              name: "Marty McFly",
+              address: nil
+            }
             expected = {
               name: "Marty McFly",
               address: a_hash_including(
@@ -296,46 +303,43 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
                 zip: "90382"
               )
             }
-            actual   = {
-              name: "Marty McFly",
-              address: nil
-            }
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ name: "Marty McFly", address: nil }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ name: "Marty McFly", address: nil }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|{ name: "Marty McFly", address: #<a hash including (city: "Hill Valley", zip: "90382")> }|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %!    name: "Marty McFly",!
+                  expected_line "-   address: #<a hash including ("
+                  expected_line %!-     city: "Hill Valley",!
+                  expected_line %!-     zip: "90382"!
+                  expected_line "-   )>"
+                  actual_line "+   address: nil"
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|{ name: "Marty McFly", address: #<a hash including (city: "Hill Valley", zip: "90382")> }|
-              end
-            },
-            diff: proc {
-              plain_line    %!  {!
-              plain_line    %!    name: "Marty McFly",!
-              expected_line %!-   address: #<a hash including (!
-              expected_line %!-     city: "Hill Valley",!
-              expected_line %!-     zip: "90382"!
-              expected_line %!-   )>!
-              actual_line   %!+   address: nil!
-              plain_line    %!  }!
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -347,38 +351,38 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     it "produces the correct failure message" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = { city: "Burbank" }
           expected = hash_including(city: "Hill Valley")
-          actual   = { city: "Burbank" }
           expect(actual).to match(expected)
         TEST
-        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(actual).to match(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|{ city: "Burbank" }|
-              plain    %| to match |
-              expected %|#<a hash including (city: "Hill Valley")>|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            plain_line    %|  {|
-            expected_line %|-   city: "Hill Valley"|
-            actual_line   %|+   city: "Burbank"|
-            plain_line    %|  }|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to match(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|{ city: "Burbank" }|
+                  plain " to match "
+                  expected %|#<a hash including (city: "Hill Valley")>|
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  {"
+                expected_line %|-   city: "Hill Valley"|
+                actual_line %|+   city: "Burbank"|
+                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
@@ -388,71 +392,72 @@ RSpec.describe "Integration with RSpec's #match 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 = ["b"]
             expected = a_collection_including("a")
-            actual   = ["b"]
             expect(actual).to match(expected)
           TEST
-          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(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|["b"]|
+                    plain " to match "
+                    expected %|#<a collection including ("a")>|
+                    plain "."
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  ["
+                  plain_line %|    "b"|
+                  # expected_line %|-   "a",|   # FIXME
+                  expected_line %|-   "a"|
+                  plain_line "  ]"
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|["b"]|
-                plain    %| to match |
-                expected %|#<a collection including ("a")>|
-                plain    %|.|
-              end
-            },
-            diff: proc {
-              plain_line    %|  [|
-              plain_line    %|    "b"|
-              # expected_line %|-   "a",|   # FIXME
-              expected_line %|-   "a"|
-              plain_line    %|  ]|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = ["b"]
             expected = a_collection_including("b")
-            actual   = ["b"]
             expect(actual).not_to match(expected)
           TEST
-          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(actual).not_to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|["b"]|
+                    plain " not to match "
+                    expected %|#<a collection including ("b")>|
+                    plain "."
+                  end
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|["b"]|
-                plain    %| not to match |
-                expected %|#<a collection including ("b")>|
-                plain    %|.|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -461,229 +466,232 @@ RSpec.describe "Integration with RSpec's #match 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 = ["milk", "toast", "eggs", "cheese", "English muffins"]
             expected = a_collection_including("milk", "bread")
-            actual   = ["milk", "toast", "eggs", "cheese", "English muffins"]
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|["milk", "toast", "eggs", "cheese", "English muffins"]|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|["milk", "toast", "eggs", "cheese", "English muffins"]|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|#<a collection including ("milk", "bread")>|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  ["
+                  plain_line %|    "milk",|
+                  plain_line %|    "toast",|
+                  plain_line %|    "eggs",|
+                  plain_line %|    "cheese",|
+                  # plain_line    %|    "English muffins",|  # FIXME
+                  plain_line %|    "English muffins"|
+                  expected_line %|-   "bread"|
+                  plain_line "  ]"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|#<a collection including ("milk", "bread")>|
-              end
-            },
-            diff: proc {
-              plain_line    %|  [|
-              plain_line    %|    "milk",|
-              plain_line    %|    "toast",|
-              plain_line    %|    "eggs",|
-              plain_line    %|    "cheese",|
-              # plain_line    %|    "English muffins",|  # FIXME
-              plain_line    %|    "English muffins"|
-              expected_line %|-   "bread"|
-              plain_line    %|  ]|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = ["milk", "toast", "eggs", "cheese", "English muffins"]
             expected = a_collection_including("milk", "toast")
-            actual   = ["milk", "toast", "eggs", "cheese", "English muffins"]
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|["milk", "toast", "eggs", "cheese", "English muffins"]|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|["milk", "toast", "eggs", "cheese", "English muffins"]|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|#<a collection including ("milk", "toast")>|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|#<a collection including ("milk", "toast")>|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
   end
 
   context "when the expected value includes a collection-including-<something>" do
-    context "and the corresponding actual   value is an array" do
+    context "and the corresponding actual value is an array" 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 = {
               name: "shopping list",
-              contents: a_collection_including("milk", "bread")
+              contents: ["milk", "toast", "eggs"]
             }
-            actual   = {
+            expected = {
               name: "shopping list",
-              contents: ["milk", "toast", "eggs"]
+              contents: a_collection_including("milk", "bread")
             }
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|{ name: "shopping list", contents: #<a collection including ("milk", "bread")> }|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %|    name: "shopping list",|
+                  plain_line "    contents: ["
+                  plain_line %|      "milk",|
+                  plain_line %|      "toast",|
+                  # plain_line    %|      "eggs",|     # FIXME
+                  plain_line %|      "eggs"|
+                  expected_line %|-     "bread"|
+                  plain_line "    ]"
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|{ name: "shopping list", contents: #<a collection including ("milk", "bread")> }|
-              end
-            },
-            diff: proc {
-              plain_line    %|  {|
-              plain_line    %|    name: "shopping list",|
-              plain_line    %|    contents: [|
-              plain_line    %|      "milk",|
-              plain_line    %|      "toast",|
-              # plain_line    %|      "eggs",|     # FIXME
-              plain_line    %|      "eggs"|
-              expected_line %|-     "bread"|
-              plain_line    %|    ]|
-              plain_line    %|  }|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = {
+            actual = {
               name: "shopping list",
-              contents: a_collection_including("milk", "toast")
+              contents: ["milk", "toast", "eggs"]
             }
-            actual   = {
+            expected = {
               name: "shopping list",
-              contents: ["milk", "toast", "eggs"]
+              contents: a_collection_including("milk", "toast")
             }
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|{ name: "shopping list", contents: #<a collection including ("milk", "toast")> }|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|{ name: "shopping list", contents: #<a collection including ("milk", "toast")> }|
-              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
 
-    context "when the corresponding actual   value is not an array" do
+    context "when the corresponding actual value is not an array" do
       it "produces the correct failure message" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = {
+            actual = {
               name: "shopping list",
-              contents: a_collection_including("milk", "bread")
+              contents: nil
             }
-            actual   = {
+            expected = {
               name: "shopping list",
-              contents: nil
+              contents: a_collection_including("milk", "bread")
             }
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ name: "shopping list", contents: nil }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ name: "shopping list", contents: nil }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|{ name: "shopping list", contents: #<a collection including ("milk", "bread")> }|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %!    name: "shopping list",!
+                  expected_line "-   contents: #<a collection including ("
+                  expected_line %!-     "milk",!
+                  expected_line %!-     "bread"!
+                  expected_line "-   )>"
+                  actual_line "+   contents: nil"
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|{ name: "shopping list", contents: #<a collection including ("milk", "bread")> }|
-              end
-            },
-            diff: proc {
-              plain_line    %!  {!
-              plain_line    %!    name: "shopping list",!
-              expected_line %!-   contents: #<a collection including (!
-              expected_line %!-     "milk",!
-              expected_line %!-     "bread"!
-              expected_line %!-   )>!
-              actual_line   %!+   contents: nil!
-              plain_line    %!  }!
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -693,39 +701,39 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
     it "produces the correct failure message" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
+          actual = ["b"]
           expected = array_including("a")
-          actual   = ["b"]
           expect(actual).to match(expected)
         TEST
-        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(actual).to match(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|["b"]|
-              plain    %| to match |
-              expected %|#<a collection including ("a")>|
-              plain    %|.|
-            end
-          },
-          diff: proc {
-            plain_line    %|  [|
-            plain_line    %|    "b"|
-            # expected_line %|-   "a",|   # FIXME
-            expected_line %|-   "a"|
-            plain_line    %|  ]|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to match(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|["b"]|
+                  plain " to match "
+                  expected %|#<a collection including ("a")>|
+                  plain "."
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  ["
+                plain_line %|    "b"|
+                # expected_line %|-   "a",|   # FIXME
+                expected_line %|-   "a"|
+                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
@@ -735,71 +743,72 @@ RSpec.describe "Integration with RSpec's #match 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 = A.new("a")
             expected = an_object_having_attributes(name: "b")
-            actual   = A.new("a")
             expect(actual).to match(expected)
           TEST
-          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(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|#<A name: "a">|
+                    plain " to match "
+                    expected %|#<an object having attributes (name: "b")>|
+                    plain "."
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  #<A {"
+                  # expected_line %|-   name: "b",|  # FIXME
+                  expected_line %|-   name: "b"|
+                  actual_line %|+   name: "a"|
+                  plain_line "  }>"
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<A name: "a">|
-                plain    %| to match |
-                expected %|#<an object having attributes (name: "b")>|
-                plain    %|.|
-              end
-            },
-            diff: proc {
-              plain_line    %|  #<A {|
-              # expected_line %|-   name: "b",|  # FIXME
-              expected_line %|-   name: "b"|
-              actual_line   %|+   name: "a"|
-              plain_line    %|  }>|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = A.new("b")
             expected = an_object_having_attributes(name: "b")
-            actual   = A.new("b")
             expect(actual).not_to match(expected)
           TEST
-          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(actual).not_to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|#<A name: "b">|
+                    plain " not to match "
+                    expected %|#<an object having attributes (name: "b")>|
+                    plain "."
+                  end
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<A name: "b">|
-                plain    %| not to match |
-                expected %|#<an object having attributes (name: "b")>|
-                plain    %|.|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -808,6 +817,13 @@ RSpec.describe "Integration with RSpec's #match 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 = SuperDiff::Test::ShippingAddress.new(
+              line_1: "456 Ponderosa Ct.",
+              line_2: nil,
+              city: "Hill Valley",
+              state: "CA",
+              zip: "90382"
+            )
             expected = an_object_having_attributes(
               line_1: "123 Main St.",
               city: "Oakland",
@@ -815,100 +831,94 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
               state: "CA",
               something_else: "blah"
             )
-            actual   = SuperDiff::Test::ShippingAddress.new(
-              line_1: "456 Ponderosa Ct.",
-              line_2: nil,
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382"
-            )
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382">|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|#<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382">|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|#<an object having attributes (line_1: "123 Main St.", city: "Oakland", zip: "91234", state: "CA", something_else: "blah")>|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  #<SuperDiff::Test::ShippingAddress {"
+                  expected_line %|-   line_1: "123 Main St.",|
+                  actual_line %|+   line_1: "456 Ponderosa Ct.",|
+                  plain_line "    line_2: nil,"
+                  expected_line %|-   city: "Oakland",|
+                  actual_line %|+   city: "Hill Valley",|
+                  plain_line %|    state: "CA",|
+                  # expected_line %|-   zip: "91234",|  # FIXME
+                  # actual_line   %|+   zip: "90382",|  # FIXME
+                  expected_line %|-   zip: "91234"|
+                  actual_line %|+   zip: "90382"|
+                  # expected_line %|-   something_else: "blah"|  # TODO
+                  expected_line %|-   something_else: "blah",|
+                  plain_line "  }>"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|#<an object having attributes (line_1: "123 Main St.", city: "Oakland", zip: "91234", state: "CA", something_else: "blah")>|
-              end
-            },
-            diff: proc {
-              plain_line    %|  #<SuperDiff::Test::ShippingAddress {|
-              expected_line %|-   line_1: "123 Main St.",|
-              actual_line   %|+   line_1: "456 Ponderosa Ct.",|
-              plain_line    %|    line_2: nil,|
-              expected_line %|-   city: "Oakland",|
-              actual_line   %|+   city: "Hill Valley",|
-              plain_line    %|    state: "CA",|
-              # expected_line %|-   zip: "91234",|  # FIXME
-              # actual_line   %|+   zip: "90382",|  # FIXME
-              expected_line %|-   zip: "91234"|
-              actual_line   %|+   zip: "90382"|
-              # expected_line %|-   something_else: "blah"|  # TODO
-              expected_line %|-   something_else: "blah",|
-              plain_line    %|  }>|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = an_object_having_attributes(
-              line_1: "123 Main St.",
-              city: "Oakland",
-              zip: "91234"
-            )
-            actual   = SuperDiff::Test::ShippingAddress.new(
+            actual = SuperDiff::Test::ShippingAddress.new(
               line_1: "123 Main St.",
               line_2: nil,
               city: "Oakland",
               zip: "91234",
               state: "CA"
             )
+            expected = an_object_having_attributes(
+              line_1: "123 Main St.",
+              city: "Oakland",
+              zip: "91234"
+            )
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|#<SuperDiff::Test::ShippingAddress line_1: "123 Main St.", line_2: nil, city: "Oakland", state: "CA", zip: "91234">|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|#<SuperDiff::Test::ShippingAddress line_1: "123 Main St.", line_2: nil, city: "Oakland", state: "CA", zip: "91234">|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|#<an object having attributes (line_1: "123 Main St.", city: "Oakland", zip: "91234")>|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|#<an object having attributes (line_1: "123 Main St.", city: "Oakland", zip: "91234")>|
-              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
@@ -918,6 +928,16 @@ RSpec.describe "Integration with RSpec's #match 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 = {
+            name: "Marty McFly",
+            shipping_address: SuperDiff::Test::ShippingAddress.new(
+              line_1: "456 Ponderosa Ct.",
+              line_2: nil,
+              city: "Hill Valley",
+              state: "CA",
+              zip: "90382"
+            )
+          }
           expected = {
             name: "Marty McFly",
             shipping_address: an_object_having_attributes(
@@ -928,112 +948,101 @@ RSpec.describe "Integration with RSpec's #match matcher", type: :integration do
               something_else: "blah"
             )
           }
-          actual   = {
-            name: "Marty McFly",
-            shipping_address: SuperDiff::Test::ShippingAddress.new(
-              line_1: "456 Ponderosa Ct.",
-              line_2: nil,
-              city: "Hill Valley",
-              state: "CA",
-              zip: "90382"
-            )
-          }
           expect(actual).to match(expected)
         TEST
-        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(actual).to match(expected)|,
-          expectation: proc {
-            line do
-              plain    %|Expected |
-              actual   %|{ name: "Marty McFly", shipping_address: #<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382"> }|
-            end
-
-            line do
-              plain    %|to match |
-              expected %|{ name: "Marty McFly", shipping_address: #<an object having attributes (line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234", something_else: "blah")> }|
-            end
-          },
-          diff: proc {
-            plain_line    %|  {|
-            plain_line    %|    name: "Marty McFly",|
-            plain_line    %|    shipping_address: #<SuperDiff::Test::ShippingAddress {|
-            expected_line %|-     line_1: "123 Main St.",|
-            actual_line   %|+     line_1: "456 Ponderosa Ct.",|
-            plain_line    %|      line_2: nil,|
-            expected_line %|-     city: "Oakland",|
-            actual_line   %|+     city: "Hill Valley",|
-            plain_line    %|      state: "CA",|
-            # expected_line %|-     zip: "91234",|  # FIXME
-            expected_line %|-     zip: "91234"|
-            actual_line   %|+     zip: "90382"|
-            # expected_line %|-     something_else: "blah"|  # TODO
-            expected_line %|-     something_else: "blah",|
-            plain_line    %|    }>|
-            plain_line    %|  }|
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).to match(expected)",
+            expectation:
+              proc do
+                line do
+                  plain "Expected "
+                  actual %|{ name: "Marty McFly", shipping_address: #<SuperDiff::Test::ShippingAddress line_1: "456 Ponderosa Ct.", line_2: nil, city: "Hill Valley", state: "CA", zip: "90382"> }|
+                end
+
+                line do
+                  plain "to match "
+                  expected %|{ name: "Marty McFly", shipping_address: #<an object having attributes (line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234", something_else: "blah")> }|
+                end
+              end,
+            diff:
+              proc do
+                plain_line "  {"
+                plain_line %|    name: "Marty McFly",|
+                plain_line "    shipping_address: #<SuperDiff::Test::ShippingAddress {"
+                expected_line %|-     line_1: "123 Main St.",|
+                actual_line %|+     line_1: "456 Ponderosa Ct.",|
+                plain_line "      line_2: nil,"
+                expected_line %|-     city: "Oakland",|
+                actual_line %|+     city: "Hill Valley",|
+                plain_line %|      state: "CA",|
+                # expected_line %|-     zip: "91234",|  # FIXME
+                expected_line %|-     zip: "91234"|
+                actual_line %|+     zip: "90382"|
+                # expected_line %|-     something_else: "blah"|  # TODO
+                expected_line %|-     something_else: "blah",|
+                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
 
     it "produces the correct failure message when used the negative" do
       as_both_colored_and_uncolored do |color_enabled|
         snippet = <<~TEST.strip
-          expected = {
+          actual = {
             name: "Marty McFly",
-            shipping_address: an_object_having_attributes(
+            shipping_address: SuperDiff::Test::ShippingAddress.new(
               line_1: "123 Main St.",
+              line_2: nil,
               city: "Oakland",
               state: "CA",
-              zip: "91234"
+              zip: "91234",
             )
           }
-          actual   = {
+          expected = {
             name: "Marty McFly",
-            shipping_address: SuperDiff::Test::ShippingAddress.new(
+            shipping_address: an_object_having_attributes(
               line_1: "123 Main St.",
-              line_2: nil,
               city: "Oakland",
               state: "CA",
-              zip: "91234",
+              zip: "91234"
             )
           }
           expect(actual).not_to match(expected)
         TEST
-        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(actual).not_to match(expected)|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|    Expected |
-              actual   %|{ name: "Marty McFly", shipping_address: #<SuperDiff::Test::ShippingAddress line_1: "123 Main St.", line_2: nil, city: "Oakland", state: "CA", zip: "91234"> }|
-            end
-
-            line do
-              plain    %|not to match |
-              expected %|{ name: "Marty McFly", shipping_address: #<an object having attributes (line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234")> }|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet: "expect(actual).not_to match(expected)",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "    Expected "
+                  actual %|{ name: "Marty McFly", shipping_address: #<SuperDiff::Test::ShippingAddress line_1: "123 Main St.", line_2: nil, city: "Oakland", state: "CA", zip: "91234"> }|
+                end
+
+                line do
+                  plain "not to match "
+                  expected %|{ name: "Marty McFly", shipping_address: #<an object having attributes (line_1: "123 Main St.", city: "Oakland", state: "CA", zip: "91234")> }|
+                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
@@ -1043,71 +1052,72 @@ RSpec.describe "Integration with RSpec's #match 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 = ["b"]
             expected = a_collection_containing_exactly("a")
-            actual   = ["b"]
             expect(actual).to match(expected)
           TEST
-          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(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|["b"]|
+                    plain " to match "
+                    expected %|#<a collection containing exactly ("a")>|
+                    plain "."
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  ["
+                  actual_line %|+   "b",|
+                  # expected_line %|-   "a"|  # TODO
+                  expected_line %|-   "a",|
+                  plain_line "  ]"
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|["b"]|
-                plain    %| to match |
-                expected %|#<a collection containing exactly ("a")>|
-                plain    %|.|
-              end
-            },
-            diff: proc {
-              plain_line    %|  [|
-              actual_line   %|+   "b",|
-              # expected_line %|-   "a"|  # TODO
-              expected_line %|-   "a",|
-              plain_line    %|  ]|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = ["b"]
             expected = a_collection_containing_exactly("b")
-            actual   = ["b"]
             expect(actual).not_to match(expected)
           TEST
-          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(actual).not_to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|["b"]|
+                    plain " not to match "
+                    expected %|#<a collection containing exactly ("b")>|
+                    plain "."
+                  end
+                end
+            )
 
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|["b"]|
-                plain    %| not to match |
-                expected %|#<a collection containing exactly ("b")>|
-                plain    %|.|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -1116,229 +1126,232 @@ RSpec.describe "Integration with RSpec's #match 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 = ["milk", "toast", "eggs", "cheese", "English muffins"]
             expected = a_collection_containing_exactly("milk", "bread")
-            actual   = ["milk", "toast", "eggs", "cheese", "English muffins"]
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|["milk", "toast", "eggs", "cheese", "English muffins"]|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|["milk", "toast", "eggs", "cheese", "English muffins"]|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|#<a collection containing exactly ("milk", "bread")>|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  ["
+                  plain_line %|    "milk",|
+                  actual_line %|+   "toast",|
+                  actual_line %|+   "eggs",|
+                  actual_line %|+   "cheese",|
+                  actual_line %|+   "English muffins",|
+                  # expected_line %|-   "bread"|  # TODO
+                  expected_line %|-   "bread",|
+                  plain_line "  ]"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|#<a collection containing exactly ("milk", "bread")>|
-              end
-            },
-            diff: proc {
-              plain_line    %|  [|
-              plain_line    %|    "milk",|
-              actual_line   %|+   "toast",|
-              actual_line   %|+   "eggs",|
-              actual_line   %|+   "cheese",|
-              actual_line   %|+   "English muffins",|
-              # expected_line %|-   "bread"|  # TODO
-              expected_line %|-   "bread",|
-              plain_line    %|  ]|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
+            actual = ["milk", "toast", "eggs"]
             expected = a_collection_containing_exactly("milk", "eggs", "toast")
-            actual   = ["milk", "toast", "eggs"]
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|["milk", "toast", "eggs"]|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|["milk", "toast", "eggs"]|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|#<a collection containing exactly ("milk", "eggs", "toast")>|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|#<a collection containing exactly ("milk", "eggs", "toast")>|
-              end
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
   end
 
   context "when the expected value includes a collection-containing-exactly-<something>" do
-    context "and the corresponding actual   value is an array" do
+    context "and the corresponding actual value is an array" 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 = {
               name: "shopping list",
-              contents: a_collection_containing_exactly("milk", "bread")
+              contents: ["milk", "toast", "eggs"]
             }
-            actual   = {
+            expected = {
               name: "shopping list",
-              contents: ["milk", "toast", "eggs"]
+              contents: a_collection_containing_exactly("milk", "bread")
             }
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|{ name: "shopping list", contents: #<a collection containing exactly ("milk", "bread")> }|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %|    name: "shopping list",|
+                  plain_line "    contents: ["
+                  plain_line %|      "milk",|
+                  actual_line %|+     "toast",|
+                  actual_line %|+     "eggs",|
+                  # expected_line %|-     "bread"|  # TODO
+                  expected_line %|-     "bread",|
+                  plain_line "    ]"
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|{ name: "shopping list", contents: #<a collection containing exactly ("milk", "bread")> }|
-              end
-            },
-            diff: proc {
-              plain_line    %|  {|
-              plain_line    %|    name: "shopping list",|
-              plain_line    %|    contents: [|
-              plain_line    %|      "milk",|
-              actual_line   %|+     "toast",|
-              actual_line   %|+     "eggs",|
-              # expected_line %|-     "bread"|  # TODO
-              expected_line %|-     "bread",|
-              plain_line    %|    ]|
-              plain_line    %|  }|
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
       it "produces the correct failure message when used in the negative" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = {
+            actual = {
               name: "shopping list",
-              contents: a_collection_containing_exactly("milk", "eggs", "toast")
+              contents: ["milk", "toast", "eggs"]
             }
-            actual   = {
+            expected = {
               name: "shopping list",
-              contents: ["milk", "toast", "eggs"]
+              contents: a_collection_containing_exactly("milk", "eggs", "toast")
             }
             expect(actual).not_to match(expected)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(actual).not_to match(expected)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|    Expected |
-                actual   %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).not_to match(expected)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "    Expected "
+                    actual %|{ name: "shopping list", contents: ["milk", "toast", "eggs"] }|
+                  end
+
+                  line do
+                    plain "not to match "
+                    expected %|{ name: "shopping list", contents: #<a collection containing exactly ("milk", "eggs", "toast")> }|
+                  end
+                end
+            )
 
-              line do
-                plain    %|not to match |
-                expected %|{ name: "shopping list", contents: #<a collection containing exactly ("milk", "eggs", "toast")> }|
-              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
 
-    context "when the corresponding actual   value is not an array" do
+    context "when the corresponding actual value is not an array" do
       it "produces the correct failure message" do
         as_both_colored_and_uncolored do |color_enabled|
           snippet = <<~TEST.strip
-            expected = {
+            actual = {
               name: "shopping list",
-              contents: a_collection_containing_exactly("milk", "bread")
+              contents: nil
             }
-            actual   = {
+            expected = {
               name: "shopping list",
-              contents: nil
+              contents: a_collection_containing_exactly("milk", "bread")
             }
             expect(actual).to match(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 match(expected)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|{ name: "shopping list", contents: nil }|
-              end
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(actual).to match(expected)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual %|{ name: "shopping list", contents: nil }|
+                  end
+
+                  line do
+                    plain "to match "
+                    expected %|{ name: "shopping list", contents: #<a collection containing exactly ("milk", "bread")> }|
+                  end
+                end,
+              diff:
+                proc do
+                  plain_line "  {"
+                  plain_line %!    name: "shopping list",!
+                  expected_line "-   contents: #<a collection containing exactly ("
+                  expected_line %!-     "milk",!
+                  expected_line %!-     "bread"!
+                  expected_line "-   )>"
+                  actual_line "+   contents: nil"
+                  plain_line "  }"
+                end
+            )
 
-              line do
-                plain    %|to match |
-                expected %|{ name: "shopping list", contents: #<a collection containing exactly ("milk", "bread")> }|
-              end
-            },
-            diff: proc {
-              plain_line    %!  {!
-              plain_line    %!    name: "shopping list",!
-              expected_line %!-   contents: #<a collection containing exactly (!
-              expected_line %!-     "milk",!
-              expected_line %!-     "bread"!
-              expected_line %!-   )>!
-              actual_line   %!+   contents: nil!
-              plain_line    %!  }!
-            },
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end