super_diff 0.9.0 → 0.10.0

data/spec/integration/rspec/respond_to_matcher_spec.rb

@@ -1,62 +1,63 @@
 require "spec_helper"
 
 # TODO: Update coloring here
-RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integration do
+RSpec.describe "Integration with RSpec's #respond_to matcher",
+               type: :integration do
   context "without any qualifiers" do
     context "when a few number of methods are specified" do
       it "produces the correct failure message when used in the positive" do
         as_both_colored_and_uncolored do |color_enabled|
-          snippet = %|expect(double).to respond_to(:foo)|
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
+          snippet = "expect(double).to respond_to(:foo)"
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: snippet,
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<Double (anonymous)>"
+                    plain " to respond to "
+                    expected ":foo"
+                    plain "."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: snippet,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<Double (anonymous)>|
-                plain    %| to respond to |
-                expected %|:foo|
-                plain    %|.|
-              end
-            },
-          )
-
-          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(double).not_to respond_to(:inspect)|
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
+          snippet = "expect(double).not_to respond_to(:inspect)"
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: snippet,
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<Double (anonymous)>"
+                    plain " not to respond to "
+                    expected ":inspect"
+                    plain "."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: snippet,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<Double (anonymous)>|
-                plain    %| not to respond to |
-                expected %|:inspect|
-                plain    %|.|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
     end
@@ -67,43 +68,44 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz, :zing)
           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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz, :zing)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "     Expected "
+                    actual "#<Double :something_really_long>"
+                  end
+
+                  line do
+                    plain "to respond to "
+                    expected ":foo"
+                    plain ", "
+                    expected ":bar"
+                    plain ", "
+                    expected ":baz"
+                    plain ", "
+                    expected ":qux"
+                    plain ", "
+                    expected ":fizz"
+                    plain ", "
+                    expected ":buzz"
+                    plain " and "
+                    expected ":zing"
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz, :zing)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|     Expected |
-                actual   %|#<Double :something_really_long>|
-              end
-
-              line do
-                plain    %|to respond to |
-                expected %|:foo|
-                plain    %|, |
-                expected %|:bar|
-                plain    %|, |
-                expected %|:baz|
-                plain    %|, |
-                expected %|:qux|
-                plain    %|, |
-                expected %|:fizz|
-                plain    %|, |
-                expected %|:buzz|
-                plain    %| and |
-                expected %|:zing|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
@@ -117,34 +119,34 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|         Expected |
-                actual   %|#<B>|
-              end
-
-              line do
-                plain    %|not to respond to |
-                expected %|:some_really_long_method_and_stuff|
-                plain    %| and |
-                expected %|:another_method_or_whatever|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "         Expected "
+                    actual "#<B>"
+                  end
+
+                  line do
+                    plain "not to respond to "
+                    expected ":some_really_long_method_and_stuff"
+                    plain " and "
+                    expected ":another_method_or_whatever"
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -157,30 +159,30 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double).to respond_to(:foo).with(3).arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double).to respond_to(:foo).with(3).arguments|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<Double (anonymous)>|
-                plain    %| to respond to |
-                expected %|:foo|
-                plain    %| with |
-                expected %|3|
-                plain    %| arguments.|
-              end
-            },
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(double).to respond_to(:foo).with(3).arguments",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<Double (anonymous)>"
+                    plain " to respond to "
+                    expected ":foo"
+                    plain " with "
+                    expected "3"
+                    plain " arguments."
+                  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
 
@@ -193,31 +195,31 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:foo).with(3).arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:foo).with(3).arguments|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<B>|
-                plain    %| not to respond to |
-                expected %|:foo|
-                plain    %| with |
-                expected %|3|
-                plain    %| arguments.|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:foo).with(3).arguments",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<B>"
+                    plain " not to respond to "
+                    expected ":foo"
+                    plain " with "
+                    expected "3"
+                    plain " arguments."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -228,42 +230,43 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with(3).arguments
           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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with(3).arguments",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "     Expected "
+                    actual "#<Double :something_really_long>"
+                  end
+
+                  line do
+                    plain "to respond to "
+                    expected ":foo"
+                    plain ", "
+                    expected ":bar"
+                    plain ", "
+                    expected ":baz"
+                    plain ", "
+                    expected ":fizz"
+                    plain " and "
+                    expected ":buzz"
+                    plain " with "
+                    expected "3"
+                    plain " arguments"
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with(3).arguments|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|     Expected |
-                actual   %|#<Double :something_really_long>|
-              end
-
-              line do
-                plain    %|to respond to |
-                expected %|:foo|
-                plain    %|, |
-                expected %|:bar|
-                plain    %|, |
-                expected %|:baz|
-                plain    %|, |
-                expected %|:fizz|
-                plain    %| and |
-                expected %|:buzz|
-                plain    %| with |
-                expected %|3|
-                plain    %| arguments|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
@@ -277,37 +280,37 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with(3).arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with(3).arguments|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|         Expected |
-                actual   %|#<B>|
-              end
-
-              line do
-                plain    %|not to respond to |
-                expected %|:some_really_long_method_and_stuff|
-                plain    %| and |
-                expected %|:another_method_or_whatever|
-                plain    %| with |
-                expected %|3|
-                plain    %| arguments|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with(3).arguments",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "         Expected "
+                    actual "#<B>"
+                  end
+
+                  line do
+                    plain "not to respond to "
+                    expected ":some_really_long_method_and_stuff"
+                    plain " and "
+                    expected ":another_method_or_whatever"
+                    plain " with "
+                    expected "3"
+                    plain " arguments"
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -320,30 +323,30 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double).to respond_to(:foo).with_keywords(:bar)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double).to respond_to(:foo).with_keywords(:bar)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<Double (anonymous)>|
-                plain    %| to respond to |
-                expected %|:foo|
-                plain    %| with keyword |
-                expected %|:bar|
-                plain    %|.|
-              end
-            },
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet: "expect(double).to respond_to(:foo).with_keywords(:bar)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<Double (anonymous)>"
+                    plain " to respond to "
+                    expected ":foo"
+                    plain " with keyword "
+                    expected ":bar"
+                    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
 
@@ -356,31 +359,31 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:foo).with_keywords(:bar)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:foo).with_keywords(:bar)|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<B>|
-                plain    %| not to respond to |
-                expected %|:foo|
-                plain    %| with keyword |
-                expected %|:bar|
-                plain    %|.|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:foo).with_keywords(:bar)",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<B>"
+                    plain " not to respond to "
+                    expected ":foo"
+                    plain " with keyword "
+                    expected ":bar"
+                    plain "."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -391,43 +394,44 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with_keywords(:qux, :blargh)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with_keywords(:qux, :blargh)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|     Expected |
-                actual   %|#<Double :something_really_long>|
-              end
-
-              line do
-                plain    %|to respond to |
-                expected %|:foo|
-                plain    %|, |
-                expected %|:bar|
-                plain    %|, |
-                expected %|:baz|
-                plain    %|, |
-                expected %|:fizz|
-                plain    %| and |
-                expected %|:buzz|
-                plain    %| with keywords |
-                expected %|:qux|
-                plain    %| and |
-                expected %|:blargh|
-              end
-            },
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :fizz, :buzz).with_keywords(:qux, :blargh)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "     Expected "
+                    actual "#<Double :something_really_long>"
+                  end
+
+                  line do
+                    plain "to respond to "
+                    expected ":foo"
+                    plain ", "
+                    expected ":bar"
+                    plain ", "
+                    expected ":baz"
+                    plain ", "
+                    expected ":fizz"
+                    plain " and "
+                    expected ":buzz"
+                    plain " with keywords "
+                    expected ":qux"
+                    plain " and "
+                    expected ":blargh"
+                  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
 
@@ -441,38 +445,38 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_keywords(:foo, :bar)
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_keywords(:foo, :bar)|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|         Expected |
-                actual   %|#<B>|
-              end
-
-              line do
-                plain    %|not to respond to |
-                expected %|:some_really_long_method_and_stuff|
-                plain    %| and |
-                expected %|:another_method_or_whatever|
-                plain    %| with keywords |
-                expected %|:foo|
-                plain    %| and |
-                expected %|:bar|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_keywords(:foo, :bar)",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "         Expected "
+                    actual "#<B>"
+                  end
+
+                  line do
+                    plain "not to respond to "
+                    expected ":some_really_long_method_and_stuff"
+                    plain " and "
+                    expected ":another_method_or_whatever"
+                    plain " with keywords "
+                    expected ":foo"
+                    plain " and "
+                    expected ":bar"
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -485,30 +489,30 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double).to respond_to(:foo).with_any_keywords
           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(double).to respond_to(:foo).with_any_keywords",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<Double (anonymous)>"
+                    plain " to respond to "
+                    expected ":foo"
+                    plain " with "
+                    expected "any"
+                    plain " keywords."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double).to respond_to(:foo).with_any_keywords|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<Double (anonymous)>|
-                plain    %| to respond to |
-                expected %|:foo|
-                plain    %| with |
-                expected %|any|
-                plain    %| keywords.|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
@@ -521,31 +525,31 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:foo).with_any_keywords
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:foo).with_any_keywords|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<B>|
-                plain    %| not to respond to |
-                expected %|:foo|
-                plain    %| with |
-                expected %|any|
-                plain    %| keywords.|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:foo).with_any_keywords",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<B>"
+                    plain " not to respond to "
+                    expected ":foo"
+                    plain " with "
+                    expected "any"
+                    plain " keywords."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -556,44 +560,45 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz).with_any_keywords
           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(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz).with_any_keywords",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "     Expected "
+                    actual "#<Double :something_really_long>"
+                  end
+
+                  line do
+                    plain "to respond to "
+                    expected ":foo"
+                    plain ", "
+                    expected ":bar"
+                    plain ", "
+                    expected ":baz"
+                    plain ", "
+                    expected ":qux"
+                    plain ", "
+                    expected ":fizz"
+                    plain " and "
+                    expected ":buzz"
+                    plain " with "
+                    expected "any"
+                    plain " keywords "
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(expected_output).in_color(
+            color_enabled
           )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz, :qux, :fizz, :buzz).with_any_keywords|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|     Expected |
-                actual   %|#<Double :something_really_long>|
-              end
-
-              line do
-                plain    %|to respond to |
-                expected %|:foo|
-                plain    %|, |
-                expected %|:bar|
-                plain    %|, |
-                expected %|:baz|
-                plain    %|, |
-                expected %|:qux|
-                plain    %|, |
-                expected %|:fizz|
-                plain    %| and |
-                expected %|:buzz|
-                plain    %| with |
-                expected %|any|
-                plain    %| keywords |
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            in_color(color_enabled)
         end
       end
 
@@ -607,37 +612,37 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_any_keywords
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_any_keywords|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|         Expected |
-                actual   %|#<B>|
-              end
-
-              line do
-                plain    %|not to respond to |
-                expected %|:some_really_long_method_and_stuff|
-                plain    %| and |
-                expected %|:another_method_or_whatever|
-                plain    %| with |
-                expected %|any|
-                plain    %| keywords |
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_any_keywords",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "         Expected "
+                    actual "#<B>"
+                  end
+
+                  line do
+                    plain "not to respond to "
+                    expected ":some_really_long_method_and_stuff"
+                    plain " and "
+                    expected ":another_method_or_whatever"
+                    plain " with "
+                    expected "any"
+                    plain " keywords "
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -650,30 +655,31 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double).to respond_to(:foo).with_unlimited_arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double).to respond_to(:foo).with_unlimited_arguments|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<Double (anonymous)>|
-                plain    %| to respond to |
-                expected %|:foo|
-                plain    %| with |
-                expected %|unlimited|
-                plain    %| arguments.|
-              end
-            },
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(double).to respond_to(:foo).with_unlimited_arguments",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<Double (anonymous)>"
+                    plain " to respond to "
+                    expected ":foo"
+                    plain " with "
+                    expected "unlimited"
+                    plain " arguments."
+                  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
 
@@ -686,31 +692,31 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:foo).with_unlimited_arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:foo).with_unlimited_arguments|,
-            expectation: proc {
-              line do
-                plain    %|Expected |
-                actual   %|#<B>|
-                plain    %| not to respond to |
-                expected %|:foo|
-                plain    %| with |
-                expected %|unlimited|
-                plain    %| arguments.|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:foo).with_unlimited_arguments",
+              expectation:
+                proc do
+                  line do
+                    plain "Expected "
+                    actual "#<B>"
+                    plain " not to respond to "
+                    expected ":foo"
+                    plain " with "
+                    expected "unlimited"
+                    plain " arguments."
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -721,38 +727,39 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
           snippet = <<~TEST.strip
             expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_unlimited_arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_unlimited_arguments|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|     Expected |
-                actual   %|#<Double :something_really_long>|
-              end
-
-              line do
-                plain    %|to respond to |
-                expected %|:foo|
-                plain    %|, |
-                expected %|:bar|
-                plain    %| and |
-                expected %|:baz|
-                plain    %| with |
-                expected %|unlimited|
-                plain    %| arguments|
-              end
-            },
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_unlimited_arguments",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "     Expected "
+                    actual "#<Double :something_really_long>"
+                  end
+
+                  line do
+                    plain "to respond to "
+                    expected ":foo"
+                    plain ", "
+                    expected ":bar"
+                    plain " and "
+                    expected ":baz"
+                    plain " with "
+                    expected "unlimited"
+                    plain " arguments"
+                  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
 
@@ -766,37 +773,37 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
             expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_unlimited_arguments
           TEST
-          program = make_plain_test_program(
-            snippet,
-            color_enabled: color_enabled,
-          )
-
-          expected_output = build_expected_output(
-            color_enabled: color_enabled,
-            snippet: %|expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_unlimited_arguments|,
-            newline_before_expectation: true,
-            expectation: proc {
-              line do
-                plain    %|         Expected |
-                actual   %|#<B>|
-              end
-
-              line do
-                plain    %|not to respond to |
-                expected %|:some_really_long_method_and_stuff|
-                plain    %| and |
-                expected %|:another_method_or_whatever|
-                plain    %| with |
-                expected %|unlimited|
-                plain    %| arguments|
-              end
-            },
-          )
-
-          expect(program).
-            to produce_output_when_run(expected_output).
-            removing_object_ids.
-            in_color(color_enabled)
+          program =
+            make_plain_test_program(snippet, color_enabled: color_enabled)
+
+          expected_output =
+            build_expected_output(
+              color_enabled: color_enabled,
+              snippet:
+                "expect(B.new).not_to respond_to(:some_really_long_method_and_stuff, :another_method_or_whatever).with_unlimited_arguments",
+              newline_before_expectation: true,
+              expectation:
+                proc do
+                  line do
+                    plain "         Expected "
+                    actual "#<B>"
+                  end
+
+                  line do
+                    plain "not to respond to "
+                    expected ":some_really_long_method_and_stuff"
+                    plain " and "
+                    expected ":another_method_or_whatever"
+                    plain " with "
+                    expected "unlimited"
+                    plain " arguments"
+                  end
+                end
+            )
+
+          expect(program).to produce_output_when_run(
+            expected_output
+          ).removing_object_ids.in_color(color_enabled)
         end
       end
     end
@@ -808,40 +815,40 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
         snippet = <<~TEST.strip
           expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments
         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(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|     Expected |
-              actual   %|#<Double :something_really_long>|
-            end
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet:
+              "expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "     Expected "
+                  actual "#<Double :something_really_long>"
+                end
+
+                line do
+                  plain "to respond to "
+                  expected ":foo"
+                  plain ", "
+                  expected ":bar"
+                  plain " and "
+                  expected ":baz"
+                  plain " with "
+                  expected "any"
+                  plain " keywords and "
+                  expected "unlimited"
+                  plain " arguments"
+                end
+              end
+          )
 
-            line do
-              plain    %|to respond to |
-              expected %|:foo|
-              plain    %|, |
-              expected %|:bar|
-              plain    %| and |
-              expected %|:baz|
-              plain    %| with |
-              expected %|any|
-              plain    %| keywords and |
-              expected %|unlimited|
-              plain    %| arguments|
-            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
 
@@ -856,41 +863,40 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
           expect(B.new).not_to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments
         TEST
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
-
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(B.new).not_to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|         Expected |
-              actual   %|#<B>|
-            end
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-            line do
-              plain    %|not to respond to |
-              expected %|:foo|
-              plain    %|, |
-              expected %|:bar|
-              plain    %| and |
-              expected %|:baz|
-              plain    %| with |
-              expected %|any|
-              plain    %| keywords and |
-              expected %|unlimited|
-              plain    %| arguments|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet:
+              "expect(B.new).not_to respond_to(:foo, :bar, :baz).with_any_keywords.with_unlimited_arguments",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "         Expected "
+                  actual "#<B>"
+                end
+
+                line do
+                  plain "not to respond to "
+                  expected ":foo"
+                  plain ", "
+                  expected ":bar"
+                  plain " and "
+                  expected ":baz"
+                  plain " with "
+                  expected "any"
+                  plain " keywords and "
+                  expected "unlimited"
+                  plain " arguments"
+                end
+              end
+          )
 
-        expect(program).
-          to produce_output_when_run(expected_output).
-          removing_object_ids.
-          in_color(color_enabled)
+        expect(program).to produce_output_when_run(
+          expected_output
+        ).removing_object_ids.in_color(color_enabled)
       end
     end
   end
@@ -901,42 +907,42 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
         snippet = <<~TEST.strip
           expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments
         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(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|     Expected |
-              actual   %|#<Double :something_really_long>|
-            end
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet:
+              "expect(double(:something_really_long)).to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "     Expected "
+                  actual "#<Double :something_really_long>"
+                end
+
+                line do
+                  plain "to respond to "
+                  expected ":foo"
+                  plain ", "
+                  expected ":bar"
+                  plain " and "
+                  expected ":baz"
+                  plain " with keywords "
+                  expected ":qux"
+                  plain " and "
+                  expected ":blargh"
+                  plain " and "
+                  expected "unlimited"
+                  plain " arguments"
+                end
+              end
+          )
 
-            line do
-              plain    %|to respond to |
-              expected %|:foo|
-              plain    %|, |
-              expected %|:bar|
-              plain    %| and |
-              expected %|:baz|
-              plain    %| with keywords |
-              expected %|:qux|
-              plain    %| and |
-              expected %|:blargh|
-              plain    %| and |
-              expected %|unlimited|
-              plain    %| arguments|
-            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
 
@@ -951,43 +957,42 @@ RSpec.describe "Integration with RSpec's #respond_to matcher", type: :integratio
 
           expect(B.new).not_to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments
         TEST
-        program = make_plain_test_program(
-          snippet,
-          color_enabled: color_enabled,
-        )
-
-        expected_output = build_expected_output(
-          color_enabled: color_enabled,
-          snippet: %|expect(B.new).not_to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments|,
-          newline_before_expectation: true,
-          expectation: proc {
-            line do
-              plain    %|         Expected |
-              actual   %|#<B>|
-            end
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
 
-            line do
-              plain    %|not to respond to |
-              expected %|:foo|
-              plain    %|, |
-              expected %|:bar|
-              plain    %| and |
-              expected %|:baz|
-              plain    %| with keywords |
-              expected %|:qux|
-              plain    %| and |
-              expected %|:blargh|
-              plain    %| and |
-              expected %|unlimited|
-              plain    %| arguments|
-            end
-          },
-        )
+        expected_output =
+          build_expected_output(
+            color_enabled: color_enabled,
+            snippet:
+              "expect(B.new).not_to respond_to(:foo, :bar, :baz).with_keywords(:qux, :blargh).with_unlimited_arguments",
+            newline_before_expectation: true,
+            expectation:
+              proc do
+                line do
+                  plain "         Expected "
+                  actual "#<B>"
+                end
+
+                line do
+                  plain "not to respond to "
+                  expected ":foo"
+                  plain ", "
+                  expected ":bar"
+                  plain " and "
+                  expected ":baz"
+                  plain " with keywords "
+                  expected ":qux"
+                  plain " and "
+                  expected ":blargh"
+                  plain " and "
+                  expected "unlimited"
+                  plain " arguments"
+                end
+              end
+          )
 
-        expect(program).
-          to produce_output_when_run(expected_output).
-          removing_object_ids.
-          in_color(color_enabled)
+        expect(program).to produce_output_when_run(
+          expected_output
+        ).removing_object_ids.in_color(color_enabled)
       end
     end
   end