super_diff 0.9.0 → 0.10.0

data/spec/integration/rspec/be_predicate_matcher_spec.rb

@@ -1,77 +1,78 @@
 require "spec_helper"
 
-RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integration do
+RSpec.describe "Integration with RSpec's #be_<predicate> matcher",
+               type: :integration do
   # rubocop:disable Metrics/BlockLength
-  ["be", "be_a", "be_an"].each do |prefix|
-  # rubocop:enable Metrics/BlockLength
+  %w[be be_a be_an].each do |prefix|
+    # rubocop:enable Metrics/BlockLength
     context "using #{prefix}_<predicate>" do
       context "when the predicate method doesn't exist on the object" do
-        context "when the inspected version of the actual   value is short" do
+        context "when the inspected version of the actual value is short" do
           it "produces the correct failure message" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = %|expect(:foo).to #{prefix}_strong|
-              program = make_plain_test_program(
-                snippet,
-                color_enabled: color_enabled,
-              )
-
-              expected_output = build_expected_output(
-                color_enabled: color_enabled,
-                snippet: snippet,
-                expectation: proc {
-                  line do
-                    plain    %|Expected |
-                    actual   %|:foo|
-                    plain    %| to respond to |
-                    expected %|strong?|
-                    plain    %| or |
-                    expected %|strongs?|
-                    plain    %|.|
-                  end
-                },
-              )
+              program =
+                make_plain_test_program(snippet, color_enabled: color_enabled)
 
-              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 do
+                      line do
+                        plain "Expected "
+                        actual ":foo"
+                        plain " to respond to "
+                        expected "strong?"
+                        plain " or "
+                        expected "strongs?"
+                        plain "."
+                      end
+                    end
+                )
+
+              expect(program).to produce_output_when_run(
+                expected_output
+              ).in_color(color_enabled)
             end
           end
         end
 
-        context "when the inspected version of the actual   value is long" do
+        context "when the inspected version of the actual value is long" do
           it "produces the correct failure message" do
             as_both_colored_and_uncolored do |color_enabled|
               snippet = <<~TEST.strip
                 hash = { foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }
                 expect(hash).to #{prefix}_strong
               TEST
-              program = make_plain_test_program(
-                snippet,
-                color_enabled: color_enabled,
-              )
-
-              expected_output = build_expected_output(
-                color_enabled: color_enabled,
-                snippet: %|expect(hash).to #{prefix}_strong|,
-                newline_before_expectation: true,
-                expectation: proc {
-                  line do
-                    plain    %|     Expected |
-                    actual   %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
-                  end
+              program =
+                make_plain_test_program(snippet, color_enabled: color_enabled)
 
-                  line do
-                    plain    %|to respond to |
-                    expected %|strong?|
-                    plain    %| or |
-                    expected %|strongs?|
-                  end
-                },
-              )
+              expected_output =
+                build_expected_output(
+                  color_enabled: color_enabled,
+                  snippet: %|expect(hash).to #{prefix}_strong|,
+                  newline_before_expectation: true,
+                  expectation:
+                    proc do
+                      line do
+                        plain "     Expected "
+                        actual %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
+                      end
 
-              expect(program).
-                to produce_output_when_run(expected_output).
-                in_color(color_enabled)
+                      line do
+                        plain "to respond to "
+                        expected "strong?"
+                        plain " or "
+                        expected "strongs?"
+                      end
+                    end
+                )
+
+              expect(program).to produce_output_when_run(
+                expected_output
+              ).in_color(color_enabled)
             end
           end
         end
@@ -79,7 +80,7 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
       context "when the predicate method exists on the object" do
         context "but is private" do
-          context "when the inspected version of the actual   value is short" do
+          context "when the inspected version of the actual value is short" do
             it "produces the correct failure message" do
               as_both_colored_and_uncolored do |color_enabled|
                 snippet = <<~TEST.strip
@@ -89,36 +90,35 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                   expect(Foo.new).to #{prefix}_strong
                 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(Foo.new).to #{prefix}_strong|,
-                  expectation: proc {
-                    line do
-                      plain    %|Expected |
-                      actual   %|#<Foo>|
-                      plain    %| to have a public method |
-                      expected %|strong?|
-                      plain    %| or |
-                      expected %|strongs?|
-                      plain    %|.|
-                    end
-                  },
-                )
+                expected_output =
+                  build_expected_output(
+                    color_enabled: color_enabled,
+                    snippet: %|expect(Foo.new).to #{prefix}_strong|,
+                    expectation:
+                      proc do
+                        line do
+                          plain "Expected "
+                          actual "#<Foo>"
+                          plain " to have a public method "
+                          expected "strong?"
+                          plain " or "
+                          expected "strongs?"
+                          plain "."
+                        end
+                      end
+                  )
 
-                expect(program).
-                  to produce_output_when_run(expected_output).
-                  in_color(color_enabled).
-                  removing_object_ids
+                expect(program).to produce_output_when_run(
+                  expected_output
+                ).in_color(color_enabled).removing_object_ids
               end
             end
           end
 
-          context "when the inspected version of the actual   value is long" do
+          context "when the inspected version of the actual value is long" do
             it "produces the correct failure message" do
               as_both_colored_and_uncolored do |color_enabled|
                 snippet = <<~TEST.strip
@@ -130,34 +130,33 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                   expect(hash).to #{prefix}_strong
                 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(hash).to #{prefix}_strong|,
-                  newline_before_expectation: true,
-                  expectation: proc {
-                    line do
-                      plain    %|               Expected |
-                      actual   %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz" }|
-                    end
+                expected_output =
+                  build_expected_output(
+                    color_enabled: color_enabled,
+                    snippet: %|expect(hash).to #{prefix}_strong|,
+                    newline_before_expectation: true,
+                    expectation:
+                      proc do
+                        line do
+                          plain "               Expected "
+                          actual %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz" }|
+                        end
 
-                    line do
-                      plain    %|to have a public method |
-                      expected %|strong?|
-                      plain    %| or |
-                      expected %|strongs?|
-                    end
-                  },
-                )
+                        line do
+                          plain "to have a public method "
+                          expected "strong?"
+                          plain " or "
+                          expected "strongs?"
+                        end
+                      end
+                  )
 
-                expect(program).
-                  to produce_output_when_run(expected_output).
-                  in_color(color_enabled).
-                  removing_object_ids
+                expect(program).to produce_output_when_run(
+                  expected_output
+                ).in_color(color_enabled).removing_object_ids
               end
             end
           end
@@ -166,7 +165,7 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
         context "and is public" do
           context "and returns false" do
             context "but is called #true?" do
-              context "when the inspected version of the actual   value is short" do
+              context "when the inspected version of the actual value is short" do
                 it "produces the correct failure message" do
                   as_both_colored_and_uncolored do |color_enabled|
                     snippet = <<~TEST.strip
@@ -176,47 +175,49 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                       expect(Foo.new).to #{prefix}_true
                     TEST
-                    program = make_plain_test_program(
-                      snippet,
-                      color_enabled: color_enabled,
-                    )
-
-                    expected_output = build_expected_output(
-                      color_enabled: color_enabled,
-                      snippet: %|expect(Foo.new).to #{prefix}_true|,
-                      newline_before_expectation: true,
-                      expectation: proc {
-                        line do
-                          plain    %|Expected |
-                          actual   %|#<Foo>|
-                          plain    %| to return a truthy result for |
-                          expected %|true?|
-                          plain    %| or |
-                          expected %|trues?|
-                          plain    %|.|
-                        end
-
-                        newline
+                    program =
+                      make_plain_test_program(
+                        snippet,
+                        color_enabled: color_enabled
+                      )
 
-                        line do
-                          plain    %|(Perhaps you want to use |
-                          blue "be(true)"
-                          plain    %| or |
-                          blue "be_truthy"
-                          plain    %| instead?)|
-                        end
-                      },
-                    )
+                    expected_output =
+                      build_expected_output(
+                        color_enabled: color_enabled,
+                        snippet: %|expect(Foo.new).to #{prefix}_true|,
+                        newline_before_expectation: true,
+                        expectation:
+                          proc do
+                            line do
+                              plain "Expected "
+                              actual "#<Foo>"
+                              plain " to return a truthy result for "
+                              expected "true?"
+                              plain " or "
+                              expected "trues?"
+                              plain "."
+                            end
+
+                            newline
+
+                            line do
+                              plain "(Perhaps you want to use "
+                              blue "be(true)"
+                              plain " or "
+                              blue "be_truthy"
+                              plain " instead?)"
+                            end
+                          end
+                      )
 
-                    expect(program).
-                      to produce_output_when_run(expected_output).
-                      in_color(color_enabled).
-                      removing_object_ids
+                    expect(program).to produce_output_when_run(
+                      expected_output
+                    ).in_color(color_enabled).removing_object_ids
                   end
                 end
               end
 
-              context "when the inspected version of the actual   value is long" do
+              context "when the inspected version of the actual value is long" do
                 it "produces the correct failure message" do
                   as_both_colored_and_uncolored do |color_enabled|
                     snippet = <<~TEST.strip
@@ -233,44 +234,46 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                       expect(hash).to #{prefix}_true
                     TEST
-                    program = make_plain_test_program(
-                      snippet,
-                      color_enabled: color_enabled,
-                    )
-
-                    expected_output = build_expected_output(
-                      color_enabled: color_enabled,
-                      snippet: %|expect(hash).to #{prefix}_true|,
-                      newline_before_expectation: true,
-                      expectation: proc {
-                        line do
-                          plain    %|                     Expected |
-                          actual   %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz" }|
-                        end
-
-                        line do
-                          plain    %|to return a truthy result for |
-                          expected %|true?|
-                          plain    %| or |
-                          expected %|trues?|
-                        end
-
-                        newline
+                    program =
+                      make_plain_test_program(
+                        snippet,
+                        color_enabled: color_enabled
+                      )
 
-                        line do
-                          plain    %|(Perhaps you want to use |
-                          blue "be(true)"
-                          plain    %| or |
-                          blue "be_truthy"
-                          plain    %| instead?)|
-                        end
-                      },
-                    )
+                    expected_output =
+                      build_expected_output(
+                        color_enabled: color_enabled,
+                        snippet: %|expect(hash).to #{prefix}_true|,
+                        newline_before_expectation: true,
+                        expectation:
+                          proc do
+                            line do
+                              plain "                     Expected "
+                              actual %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz" }|
+                            end
+
+                            line do
+                              plain "to return a truthy result for "
+                              expected "true?"
+                              plain " or "
+                              expected "trues?"
+                            end
+
+                            newline
+
+                            line do
+                              plain "(Perhaps you want to use "
+                              blue "be(true)"
+                              plain " or "
+                              blue "be_truthy"
+                              plain " instead?)"
+                            end
+                          end
+                      )
 
-                    expect(program).
-                      to produce_output_when_run(expected_output).
-                      in_color(color_enabled).
-                      removing_object_ids
+                    expect(program).to produce_output_when_run(
+                      expected_output
+                    ).in_color(color_enabled).removing_object_ids
                   end
                 end
               end
@@ -286,39 +289,41 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                     expect(X.new).to #{prefix}_false
                   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(X.new).to #{prefix}_false|,
-                    newline_before_expectation: true,
-                    expectation: proc {
-                      line do
-                        plain    %|Expected |
-                        actual   %|#<X>|
-                        plain    %| to return a truthy result for |
-                        expected %|false?|
-                        plain    %| or |
-                        expected %|falses?|
-                        plain    %|.|
-                      end
-                    },
-                  )
+                  expected_output =
+                    build_expected_output(
+                      color_enabled: color_enabled,
+                      snippet: %|expect(X.new).to #{prefix}_false|,
+                      newline_before_expectation: true,
+                      expectation:
+                        proc do
+                          line do
+                            plain "Expected "
+                            actual "#<X>"
+                            plain " to return a truthy result for "
+                            expected "false?"
+                            plain " or "
+                            expected "falses?"
+                            plain "."
+                          end
+                        end
+                    )
 
-                  expect(program).
-                    to produce_output_when_run(expected_output).
-                    in_color(color_enabled).
-                    removing_object_ids
+                  expect(program).to produce_output_when_run(
+                    expected_output
+                  ).in_color(color_enabled).removing_object_ids
                 end
               end
             end
 
             context "and is called neither #true? nor #false?" do
               context "and is singular" do
-                context "when the inspected version of the actual   value is short" do
+                context "when the inspected version of the actual value is short" do
                   it "produces the correct failure message" do
                     as_both_colored_and_uncolored do |color_enabled|
                       snippet = <<~TEST.strip
@@ -328,36 +333,38 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                         expect(X.new).to #{prefix}_y
                       TEST
-                      program = make_plain_test_program(
-                        snippet,
-                        color_enabled: color_enabled,
-                      )
-
-                      expected_output = build_expected_output(
-                        color_enabled: color_enabled,
-                        snippet: %|expect(X.new).to #{prefix}_y|,
-                        expectation: proc {
-                          line do
-                            plain    %|Expected |
-                            actual   %|#<X>|
-                            plain    %| to return a truthy result for |
-                            expected %|y?|
-                            plain    %| or |
-                            expected %|ys?|
-                            plain    %|.|
-                          end
-                        },
-                      )
-
-                      expect(program).
-                        to produce_output_when_run(expected_output).
-                        in_color(color_enabled).
-                        removing_object_ids
+                      program =
+                        make_plain_test_program(
+                          snippet,
+                          color_enabled: color_enabled
+                        )
+
+                      expected_output =
+                        build_expected_output(
+                          color_enabled: color_enabled,
+                          snippet: %|expect(X.new).to #{prefix}_y|,
+                          expectation:
+                            proc do
+                              line do
+                                plain "Expected "
+                                actual "#<X>"
+                                plain " to return a truthy result for "
+                                expected "y?"
+                                plain " or "
+                                expected "ys?"
+                                plain "."
+                              end
+                            end
+                        )
+
+                      expect(program).to produce_output_when_run(
+                        expected_output
+                      ).in_color(color_enabled).removing_object_ids
                     end
                   end
                 end
 
-                context "when the inspected version of the actual   value is long" do
+                context "when the inspected version of the actual value is long" do
                   it "produces the correct failure message" do
                     as_both_colored_and_uncolored do |color_enabled|
                       snippet = <<~TEST.strip
@@ -375,41 +382,43 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                         expect(hash).to #{prefix}_y
                       TEST
-                      program = make_plain_test_program(
-                        snippet,
-                        color_enabled: color_enabled,
-                      )
-
-                      expected_output = build_expected_output(
-                        color_enabled: color_enabled,
-                        snippet: %|expect(hash).to #{prefix}_y|,
-                        newline_before_expectation: true,
-                        expectation: proc {
-                          line do
-                            plain    %|                     Expected |
-                            actual   %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
-                          end
-
-                          line do
-                            plain    %|to return a truthy result for |
-                            expected %|y?|
-                            plain    %| or |
-                            expected %|ys?|
-                          end
-                        },
-                      )
-
-                      expect(program).
-                        to produce_output_when_run(expected_output).
-                        in_color(color_enabled).
-                        removing_object_ids
+                      program =
+                        make_plain_test_program(
+                          snippet,
+                          color_enabled: color_enabled
+                        )
+
+                      expected_output =
+                        build_expected_output(
+                          color_enabled: color_enabled,
+                          snippet: %|expect(hash).to #{prefix}_y|,
+                          newline_before_expectation: true,
+                          expectation:
+                            proc do
+                              line do
+                                plain "                     Expected "
+                                actual %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
+                              end
+
+                              line do
+                                plain "to return a truthy result for "
+                                expected "y?"
+                                plain " or "
+                                expected "ys?"
+                              end
+                            end
+                        )
+
+                      expect(program).to produce_output_when_run(
+                        expected_output
+                      ).in_color(color_enabled).removing_object_ids
                     end
                   end
                 end
               end
 
               context "and is plural" do
-                context "when the inspected version of the actual   value is short" do
+                context "when the inspected version of the actual value is short" do
                   it "produces the correct failure message" do
                     as_both_colored_and_uncolored do |color_enabled|
                       snippet = <<~TEST.strip
@@ -419,36 +428,38 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                         expect(X.new).to #{prefix}_y
                       TEST
-                      program = make_plain_test_program(
-                        snippet,
-                        color_enabled: color_enabled,
-                      )
-
-                      expected_output = build_expected_output(
-                        color_enabled: color_enabled,
-                        snippet: %|expect(X.new).to #{prefix}_y|,
-                        expectation: proc {
-                          line do
-                            plain    %|Expected |
-                            actual   %|#<X>|
-                            plain    %| to return a truthy result for |
-                            expected %|y?|
-                            plain    %| or |
-                            expected %|ys?|
-                            plain    %|.|
-                          end
-                        },
-                      )
-
-                      expect(program).
-                        to produce_output_when_run(expected_output).
-                        in_color(color_enabled).
-                        removing_object_ids
+                      program =
+                        make_plain_test_program(
+                          snippet,
+                          color_enabled: color_enabled
+                        )
+
+                      expected_output =
+                        build_expected_output(
+                          color_enabled: color_enabled,
+                          snippet: %|expect(X.new).to #{prefix}_y|,
+                          expectation:
+                            proc do
+                              line do
+                                plain "Expected "
+                                actual "#<X>"
+                                plain " to return a truthy result for "
+                                expected "y?"
+                                plain " or "
+                                expected "ys?"
+                                plain "."
+                              end
+                            end
+                        )
+
+                      expect(program).to produce_output_when_run(
+                        expected_output
+                      ).in_color(color_enabled).removing_object_ids
                     end
                   end
                 end
 
-                context "when the inspected version of the actual   value is long" do
+                context "when the inspected version of the actual value is long" do
                   it "produces the correct failure message" do
                     as_both_colored_and_uncolored do |color_enabled|
                       snippet = <<~TEST.strip
@@ -466,34 +477,36 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                         expect(hash).to #{prefix}_y
                       TEST
-                      program = make_plain_test_program(
-                        snippet,
-                        color_enabled: color_enabled,
-                      )
-
-                      expected_output = build_expected_output(
-                        color_enabled: color_enabled,
-                        snippet: %|expect(hash).to #{prefix}_y|,
-                        newline_before_expectation: true,
-                        expectation: proc {
-                          line do
-                            plain    %|                     Expected |
-                            actual   %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
-                          end
-
-                          line do
-                            plain    %|to return a truthy result for |
-                            expected %|y?|
-                            plain    %| or |
-                            expected %|ys?|
-                          end
-                        },
-                      )
-
-                      expect(program).
-                        to produce_output_when_run(expected_output).
-                        in_color(color_enabled).
-                        removing_object_ids
+                      program =
+                        make_plain_test_program(
+                          snippet,
+                          color_enabled: color_enabled
+                        )
+
+                      expected_output =
+                        build_expected_output(
+                          color_enabled: color_enabled,
+                          snippet: %|expect(hash).to #{prefix}_y|,
+                          newline_before_expectation: true,
+                          expectation:
+                            proc do
+                              line do
+                                plain "                     Expected "
+                                actual %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
+                              end
+
+                              line do
+                                plain "to return a truthy result for "
+                                expected "y?"
+                                plain " or "
+                                expected "ys?"
+                              end
+                            end
+                        )
+
+                      expect(program).to produce_output_when_run(
+                        expected_output
+                      ).in_color(color_enabled).removing_object_ids
                     end
                   end
                 end
@@ -502,7 +515,7 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
           end
 
           context "and returns true" do
-            context "when the inspected version of the actual   value is short" do
+            context "when the inspected version of the actual value is short" do
               it "produces the correct failure message when used in the negative" do
                 as_both_colored_and_uncolored do |color_enabled|
                   snippet = <<~TEST.strip
@@ -512,36 +525,38 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                     expect(Foo.new).not_to #{prefix}_strong
                   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(Foo.new).not_to #{prefix}_strong|,
-                    expectation: proc {
-                      line do
-                        plain    %|Expected |
-                        actual   %|#<Foo>|
-                        plain    %| not to return a truthy result for |
-                        expected %|strong?|
-                        plain    %| or |
-                        expected %|strongs?|
-                        plain    %|.|
-                      end
-                    },
-                  )
+                  expected_output =
+                    build_expected_output(
+                      color_enabled: color_enabled,
+                      snippet: %|expect(Foo.new).not_to #{prefix}_strong|,
+                      expectation:
+                        proc do
+                          line do
+                            plain "Expected "
+                            actual "#<Foo>"
+                            plain " not to return a truthy result for "
+                            expected "strong?"
+                            plain " or "
+                            expected "strongs?"
+                            plain "."
+                          end
+                        end
+                    )
 
-                  expect(program).
-                    to produce_output_when_run(expected_output).
-                    in_color(color_enabled).
-                    removing_object_ids
+                  expect(program).to produce_output_when_run(
+                    expected_output
+                  ).in_color(color_enabled).removing_object_ids
                 end
               end
             end
 
-            context "when the inspected version of the actual   value is long" do
+            context "when the inspected version of the actual value is long" do
               it "produces the correct failure message when used in the negative" do
                 as_both_colored_and_uncolored do |color_enabled|
                   snippet = <<~TEST.strip
@@ -559,34 +574,36 @@ RSpec.describe "Integration with RSpec's #be_<predicate> matcher", type: :integr
 
                     expect(hash).not_to #{prefix}_y
                   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(hash).not_to #{prefix}_y|,
-                    newline_before_expectation: true,
-                    expectation: proc {
-                      line do
-                        plain    %|                         Expected |
-                        actual   %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
-                      end
+                  expected_output =
+                    build_expected_output(
+                      color_enabled: color_enabled,
+                      snippet: %|expect(hash).not_to #{prefix}_y|,
+                      newline_before_expectation: true,
+                      expectation:
+                        proc do
+                          line do
+                            plain "                         Expected "
+                            actual %|{ foo: "bar", baz: "qux", blargh: "foz", fizz: "buzz", aaaaaa: "bbbbbb" }|
+                          end
 
-                      line do
-                        plain    %|not to return a truthy result for |
-                        expected %|y?|
-                        plain    %| or |
-                        expected %|ys?|
-                      end
-                    },
-                  )
+                          line do
+                            plain "not to return a truthy result for "
+                            expected "y?"
+                            plain " or "
+                            expected "ys?"
+                          end
+                        end
+                    )
 
-                  expect(program).
-                    to produce_output_when_run(expected_output).
-                    in_color(color_enabled).
-                    removing_object_ids
+                  expect(program).to produce_output_when_run(
+                    expected_output
+                  ).in_color(color_enabled).removing_object_ids
                 end
               end
             end