super_diff 0.9.0 → 0.10.0

data/spec/unit/equality_matchers/main_spec.rb

@@ -26,11 +26,11 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing numbers.
 
           #{
-            colored do
-              expected_line %(Expected: 42)
-              actual_line   %(  Actual: 1)
-            end
-          }
+          colored do
+            expected_line "Expected: 42"
+            actual_line "  Actual: 1"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -53,11 +53,11 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing symbols.
 
           #{
-            colored do
-              expected_line %(Expected: :foo)
-              actual_line   %(  Actual: :bar)
-            end
-          }
+          colored do
+            expected_line "Expected: :foo"
+            actual_line "  Actual: :bar"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -74,20 +74,18 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given completely different single-line strings" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: "Marty",
-          actual: "Jennifer",
-        )
+        actual_output =
+          described_class.call(expected: "Marty", actual: "Jennifer")
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line %(Expected: "Marty")
-              actual_line   %(  Actual: "Jennifer")
-            end
-          }
+          colored do
+            expected_line %(Expected: "Marty")
+            actual_line %(  Actual: "Jennifer")
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -96,20 +94,18 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given closely different single-line strings" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: "Marty",
-          actual: "Marty McFly",
-        )
+        actual_output =
+          described_class.call(expected: "Marty", actual: "Marty McFly")
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line %(Expected: "Marty")
-              actual_line   %(  Actual: "Marty McFly")
-            end
-          }
+          colored do
+            expected_line %(Expected: "Marty")
+            actual_line %(  Actual: "Marty McFly")
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -118,20 +114,21 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given a single-line string and a multi-line string" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: "Something entirely different",
-          actual: "This is a line\nAnd that's another line\n",
-        )
+        actual_output =
+          described_class.call(
+            expected: "Something entirely different",
+            actual: "This is a line\nAnd that's another line\n"
+          )
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line %(Expected: "Something entirely different")
-              actual_line   %(  Actual: "This is a line\\nAnd that's another line\\n")
-            end
-          }
+          colored do
+            expected_line %(Expected: "Something entirely different")
+            actual_line %(  Actual: "This is a line\\nAnd that's another line\\n")
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -140,20 +137,21 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given a multi-line string and a single-line string" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: "This is a line\nAnd that's another line\n",
-          actual: "Something entirely different",
-        )
+        actual_output =
+          described_class.call(
+            expected: "This is a line\nAnd that's another line\n",
+            actual: "Something entirely different"
+          )
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line %(Expected: "This is a line\\nAnd that's another line\\n")
-              actual_line   %(  Actual: "Something entirely different")
-            end
-          }
+          colored do
+            expected_line %(Expected: "This is a line\\nAnd that's another line\\n")
+            actual_line %(  Actual: "Something entirely different")
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -162,31 +160,34 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given closely different multi-line strings" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: "This is a line\nAnd that's a line\nAnd there's a line too",
-          actual: "This is a line\nSomething completely different\nAnd there's a line too",
-        )
+        actual_output =
+          described_class.call(
+            expected:
+              "This is a line\nAnd that's a line\nAnd there's a line too",
+            actual:
+              "This is a line\nSomething completely different\nAnd there's a line too"
+          )
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line %(Expected: "This is a line\\nAnd that's a line\\nAnd there's a line too")
-              actual_line   %(  Actual: "This is a line\\nSomething completely different\\nAnd there's a line too")
-            end
-          }
+          colored do
+            expected_line %(Expected: "This is a line\\nAnd that's a line\\nAnd there's a line too")
+            actual_line %(  Actual: "This is a line\\nSomething completely different\\nAnd there's a line too")
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  This is a line\\n)
-              expected_line %(- And that's a line\\n)
-              actual_line   %(+ Something completely different\\n)
-              plain_line    %(  And there's a line too)
-            end
-          }
+          colored do
+            plain_line %(  This is a line\\n)
+            expected_line %(- And that's a line\\n)
+            actual_line %(+ Something completely different\\n)
+            plain_line "  And there's a line too"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -195,31 +196,32 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given completely different multi-line strings" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: "This is a line\nAnd that's a line\n",
-          actual: "Something completely different\nAnd something else too\n",
-        )
+        actual_output =
+          described_class.call(
+            expected: "This is a line\nAnd that's a line\n",
+            actual: "Something completely different\nAnd something else too\n"
+          )
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line %(Expected: "This is a line\\nAnd that's a line\\n")
-              actual_line   %(  Actual: "Something completely different\\nAnd something else too\\n")
-            end
-          }
+          colored do
+            expected_line %(Expected: "This is a line\\nAnd that's a line\\n")
+            actual_line %(  Actual: "Something completely different\\nAnd something else too\\n")
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              expected_line %(- This is a line\\n)
-              expected_line %(- And that's a line\\n)
-              actual_line   %(+ Something completely different\\n)
-              actual_line   %(+ And something else too\\n)
-            end
-          }
+          colored do
+            expected_line %(- This is a line\\n)
+            expected_line %(- And that's a line\\n)
+            actual_line %(+ Something completely different\\n)
+            actual_line %(+ And something else too\\n)
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -234,58 +236,55 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
             red: 3,
             green: 8,
             blue: 4,
-            layer: :foreground,
+            layer: :foreground
           ),
           SuperDiff::Csi::TwentyFourBitColor.new(
             red: 47,
             green: 164,
             blue: 59,
-            layer: :foreground,
-          ),
+            layer: :foreground
+          )
         ]
 
         expected =
           colored("This is a line", colors[0]) + "\n" +
-          colored("And that's a line", colors[1]) + "\n" +
-          colored("And there's a line too", colors[2]) + "\n"
+            colored("And that's a line", colors[1]) + "\n" +
+            colored("And there's a line too", colors[2]) + "\n"
 
         actual =
-          colored("This is a line", colors[0])  + "\n" +
-          colored("Something completely different", colors[1]) + "\n" +
-          colored("And there's a line too", colors[2]) + "\n"
+          colored("This is a line", colors[0]) + "\n" +
+            colored("Something completely different", colors[1]) + "\n" +
+            colored("And there's a line too", colors[2]) + "\n"
 
-        actual_output = described_class.call(
-          expected: expected,
-          actual: actual,
-        )
+        actual_output = described_class.call(expected: expected, actual: actual)
 
         expected_output = <<~STR.strip
           Differing strings.
 
           #{
-            colored do
-              expected_line do
-                text "Expected: "
-                text %("\\e[34mThis is a line\\e[0m\\n\\e[38;5;176mAnd that's a line\\e[0m\\n\\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n")
-              end
-
-              actual_line   do
-                text "  Actual: "
-                text %("\\e[34mThis is a line\\e[0m\\n\\e[38;5;176mSomething completely different\\e[0m\\n\\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n")
-              end
+          colored do
+            expected_line do
+              text "Expected: "
+              text %("\\e[34mThis is a line\\e[0m\\n\\e[38;5;176mAnd that's a line\\e[0m\\n\\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n")
             end
-          }
+
+            actual_line do
+              text "  Actual: "
+              text %("\\e[34mThis is a line\\e[0m\\n\\e[38;5;176mSomething completely different\\e[0m\\n\\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n")
+            end
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  \\e[34mThis is a line\\e[0m\\n)
-              expected_line %(- \\e[38;5;176mAnd that's a line\\e[0m\\n)
-              actual_line   %(+ \\e[38;5;176mSomething completely different\\e[0m\\n)
-              plain_line    %(  \\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n)
-            end
-          }
+          colored do
+            plain_line %(  \\e[34mThis is a line\\e[0m\\n)
+            expected_line %(- \\e[38;5;176mAnd that's a line\\e[0m\\n)
+            actual_line %(+ \\e[38;5;176mSomething completely different\\e[0m\\n)
+            plain_line %(  \\e[38;2;47;59;164mAnd there's a line too\\e[0m\\n)
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -294,10 +293,11 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given the same array" do
       it "returns an empty string" do
-        output = described_class.call(
-          expected: ["sausage", "egg", "cheese"],
-          actual: ["sausage", "egg", "cheese"],
-        )
+        output =
+          described_class.call(
+            expected: %w[sausage egg cheese],
+            actual: %w[sausage egg cheese]
+          )
 
         expect(output).to eq("")
       end
@@ -305,34 +305,32 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-length, one-dimensional arrays with differing numbers" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [1, 2, 3, 4],
-          actual: [1, 2, 99, 4],
-        )
+        actual_output =
+          described_class.call(expected: [1, 2, 3, 4], actual: [1, 2, 99, 4])
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [1, 2, 3, 4])
-              actual_line   %(  Actual: [1, 2, 99, 4])
-            end
-          }
+          colored do
+            expected_line "Expected: [1, 2, 3, 4]"
+            actual_line "  Actual: [1, 2, 99, 4]"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    1,)
-              plain_line    %(    2,)
-              expected_line %(-   3,)
-              actual_line   %(+   99,)
-              plain_line    %(    4)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    1,"
+            plain_line "    2,"
+            expected_line "-   3,"
+            actual_line "+   99,"
+            plain_line "    4"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -341,34 +339,35 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-length, one-dimensional arrays with differing symbols" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [:one, :fish, :two, :fish],
-          actual: [:one, :FISH, :two, :fish],
-        )
+        actual_output =
+          described_class.call(
+            expected: %i[one fish two fish],
+            actual: %i[one FISH two fish]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [:one, :fish, :two, :fish])
-              actual_line   %(  Actual: [:one, :FISH, :two, :fish])
-            end
-          }
+          colored do
+            expected_line "Expected: [:one, :fish, :two, :fish]"
+            actual_line "  Actual: [:one, :FISH, :two, :fish]"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    :one,)
-              expected_line %(-   :fish,)
-              actual_line   %(+   :FISH,)
-              plain_line    %(    :two,)
-              plain_line    %(    :fish)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    :one,"
+            expected_line "-   :fish,"
+            actual_line "+   :FISH,"
+            plain_line "    :two,"
+            plain_line "    :fish"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -377,33 +376,34 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-length, one-dimensional arrays with differing strings" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: ["sausage", "egg", "cheese"],
-          actual: ["bacon", "egg", "cheese"],
-        )
+        actual_output =
+          described_class.call(
+            expected: %w[sausage egg cheese],
+            actual: %w[bacon egg cheese]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["sausage", "egg", "cheese"])
-              actual_line   %(  Actual: ["bacon", "egg", "cheese"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["sausage", "egg", "cheese"])
+            actual_line %(  Actual: ["bacon", "egg", "cheese"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              expected_line %(-   "sausage",)
-              actual_line   %(+   "bacon",)
-              plain_line    %(    "egg",)
-              plain_line    %(    "cheese")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            expected_line %(-   "sausage",)
+            actual_line %(+   "bacon",)
+            plain_line %(    "egg",)
+            plain_line %(    "cheese")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -412,45 +412,46 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-length, one-dimensional arrays with differing objects" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [
-            SuperDiff::Test::Person.new(name: "Marty", age: 18),
-            SuperDiff::Test::Person.new(name: "Jennifer", age: 17),
-          ],
-          actual: [
-            SuperDiff::Test::Person.new(name: "Marty", age: 18),
-            SuperDiff::Test::Person.new(name: "Doc", age: 50),
-          ],
-        )
+        actual_output =
+          described_class.call(
+            expected: [
+              SuperDiff::Test::Person.new(name: "Marty", age: 18),
+              SuperDiff::Test::Person.new(name: "Jennifer", age: 17)
+            ],
+            actual: [
+              SuperDiff::Test::Person.new(name: "Marty", age: 18),
+              SuperDiff::Test::Person.new(name: "Doc", age: 50)
+            ]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [#<SuperDiff::Test::Person name: "Marty", age: 18>, #<SuperDiff::Test::Person name: "Jennifer", age: 17>])
-              actual_line   %(  Actual: [#<SuperDiff::Test::Person name: "Marty", age: 18>, #<SuperDiff::Test::Person name: "Doc", age: 50>])
-            end
-          }
+          colored do
+            expected_line %(Expected: [#<SuperDiff::Test::Person name: "Marty", age: 18>, #<SuperDiff::Test::Person name: "Jennifer", age: 17>])
+            actual_line %(  Actual: [#<SuperDiff::Test::Person name: "Marty", age: 18>, #<SuperDiff::Test::Person name: "Doc", age: 50>])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    #<SuperDiff::Test::Person {)
-              plain_line    %(      name: "Marty",)
-              plain_line    %(      age: 18)
-              plain_line    %(    }>,)
-              plain_line    %(    #<SuperDiff::Test::Person {)
-              expected_line %(-     name: "Jennifer",)
-              actual_line   %(+     name: "Doc",)
-              expected_line %(-     age: 17)
-              actual_line   %(+     age: 50)
-              plain_line    %(    }>)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    #<SuperDiff::Test::Person {"
+            plain_line %(      name: "Marty",)
+            plain_line "      age: 18"
+            plain_line "    }>,"
+            plain_line "    #<SuperDiff::Test::Person {"
+            expected_line %(-     name: "Jennifer",)
+            actual_line %(+     name: "Doc",)
+            expected_line "-     age: 17"
+            actual_line "+     age: 50"
+            plain_line "    }>"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -459,32 +460,30 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two one-dimensional arrays where the actual has elements added to the end" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: ["bread"],
-          actual: ["bread", "eggs", "milk"],
-        )
+        actual_output =
+          described_class.call(expected: ["bread"], actual: %w[bread eggs milk])
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["bread"])
-              actual_line   %(  Actual: ["bread", "eggs", "milk"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["bread"])
+            actual_line %(  Actual: ["bread", "eggs", "milk"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    "bread",)
-              actual_line   %(+   "eggs",)
-              actual_line   %(+   "milk")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line %(    "bread",)
+            actual_line %(+   "eggs",)
+            actual_line %(+   "milk")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -493,32 +492,30 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two one-dimensional arrays where the actual has elements missing from the end" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: ["bread", "eggs", "milk"],
-          actual: ["bread"],
-        )
+        actual_output =
+          described_class.call(expected: %w[bread eggs milk], actual: ["bread"])
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["bread", "eggs", "milk"])
-              actual_line   %(  Actual: ["bread"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["bread", "eggs", "milk"])
+            actual_line %(  Actual: ["bread"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    "bread")
-              expected_line %(-   "eggs",)
-              expected_line %(-   "milk")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line %(    "bread")
+            expected_line %(-   "eggs",)
+            expected_line %(-   "milk")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -527,32 +524,30 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two one-dimensional arrays where the actual has elements added to the beginning" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: ["milk"],
-          actual: ["bread", "eggs", "milk"],
-        )
+        actual_output =
+          described_class.call(expected: ["milk"], actual: %w[bread eggs milk])
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["milk"])
-              actual_line   %(  Actual: ["bread", "eggs", "milk"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["milk"])
+            actual_line %(  Actual: ["bread", "eggs", "milk"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              actual_line   %(+   "bread",)
-              actual_line   %(+   "eggs",)
-              plain_line    %(    "milk")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            actual_line %(+   "bread",)
+            actual_line %(+   "eggs",)
+            plain_line %(    "milk")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -561,32 +556,30 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two one-dimensional arrays where the actual has elements removed from the beginning" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: ["bread", "eggs", "milk"],
-          actual: ["milk"],
-        )
+        actual_output =
+          described_class.call(expected: %w[bread eggs milk], actual: ["milk"])
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["bread", "eggs", "milk"])
-              actual_line   %(  Actual: ["milk"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["bread", "eggs", "milk"])
+            actual_line %(  Actual: ["milk"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              expected_line %(-   "bread",)
-              expected_line %(-   "eggs",)
-              plain_line    %(    "milk")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            expected_line %(-   "bread",)
+            expected_line %(-   "eggs",)
+            plain_line %(    "milk")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -595,38 +588,39 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two arrays containing arrays with differing values" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [1, 2, [:a, :b, :c], 4],
-          actual: [1, 2, [:a, :x, :c], 4],
-        )
+        actual_output =
+          described_class.call(
+            expected: [1, 2, %i[a b c], 4],
+            actual: [1, 2, %i[a x c], 4]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [1, 2, [:a, :b, :c], 4])
-              actual_line   %(  Actual: [1, 2, [:a, :x, :c], 4])
-            end
-          }
+          colored do
+            expected_line "Expected: [1, 2, [:a, :b, :c], 4]"
+            actual_line "  Actual: [1, 2, [:a, :x, :c], 4]"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    1,)
-              plain_line    %(    2,)
-              plain_line    %(    [)
-              plain_line    %(      :a,)
-              expected_line %(-     :b,)
-              actual_line   %(+     :x,)
-              plain_line    %(      :c)
-              plain_line    %(    ],)
-              plain_line    %(    4)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    1,"
+            plain_line "    2,"
+            plain_line "    ["
+            plain_line "      :a,"
+            expected_line "-     :b,"
+            actual_line "+     :x,"
+            plain_line "      :c"
+            plain_line "    ],"
+            plain_line "    4"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -635,37 +629,38 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two arrays containing hashes with differing values" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [1, 2, { foo: "bar", baz: "qux" }, 4],
-          actual: [1, 2, { foo: "bar", baz: "qox" }, 4],
-        )
+        actual_output =
+          described_class.call(
+            expected: [1, 2, { foo: "bar", baz: "qux" }, 4],
+            actual: [1, 2, { foo: "bar", baz: "qox" }, 4]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [1, 2, { foo: "bar", baz: "qux" }, 4])
-              actual_line   %(  Actual: [1, 2, { foo: "bar", baz: "qox" }, 4])
-            end
-          }
+          colored do
+            expected_line %(Expected: [1, 2, { foo: "bar", baz: "qux" }, 4])
+            actual_line %(  Actual: [1, 2, { foo: "bar", baz: "qox" }, 4])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    1,)
-              plain_line    %(    2,)
-              plain_line    %(    {)
-              plain_line    %(      foo: "bar",)
-              expected_line %(-     baz: "qux")
-              actual_line   %(+     baz: "qox")
-              plain_line    %(    },)
-              plain_line    %(    4)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    1,"
+            plain_line "    2,"
+            plain_line "    {"
+            plain_line %(      foo: "bar",)
+            expected_line %(-     baz: "qux")
+            actual_line %(+     baz: "qox")
+            plain_line "    },"
+            plain_line "    4"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -674,43 +669,44 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two arrays containing custom objects with differing attributes" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [
-            1,
-            2,
-            SuperDiff::Test::Person.new(name: "Marty", age: 18),
-            4,
-          ],
-          actual: [1, 2, SuperDiff::Test::Person.new(name: "Doc", age: 50), 4],
-        )
+        actual_output =
+          described_class.call(
+            expected: [
+              1,
+              2,
+              SuperDiff::Test::Person.new(name: "Marty", age: 18),
+              4
+            ],
+            actual: [1, 2, SuperDiff::Test::Person.new(name: "Doc", age: 50), 4]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [1, 2, #<SuperDiff::Test::Person name: "Marty", age: 18>, 4])
-              actual_line   %(  Actual: [1, 2, #<SuperDiff::Test::Person name: "Doc", age: 50>, 4])
-            end
-          }
+          colored do
+            expected_line %(Expected: [1, 2, #<SuperDiff::Test::Person name: "Marty", age: 18>, 4])
+            actual_line %(  Actual: [1, 2, #<SuperDiff::Test::Person name: "Doc", age: 50>, 4])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    1,)
-              plain_line    %(    2,)
-              plain_line    %(    #<SuperDiff::Test::Person {)
-              expected_line %(-     name: "Marty",)
-              actual_line   %(+     name: "Doc",)
-              expected_line %(-     age: 18)
-              actual_line   %(+     age: 50)
-              plain_line    %(    }>,)
-              plain_line    %(    4)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    1,"
+            plain_line "    2,"
+            plain_line "    #<SuperDiff::Test::Person {"
+            expected_line %(-     name: "Marty",)
+            actual_line %(+     name: "Doc",)
+            expected_line "-     age: 18"
+            actual_line "+     age: 50"
+            plain_line "    }>,"
+            plain_line "    4"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -719,71 +715,72 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two arrays which contain all different kinds of values, some which differ" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: [
-            [
-              :h1,
-              [:span, [:text, "Hello world"]],
-              {
-                class: "header",
-                data: { "sticky" => true },
-              },
+        actual_output =
+          described_class.call(
+            expected: [
+              [
+                :h1,
+                [:span, [:text, "Hello world"]],
+                { class: "header", data: { "sticky" => true } }
+              ]
             ],
-          ],
-          actual: [
-            [
-              :h2,
-              [:span, [:text, "Goodbye world"]],
-              {
-                id: "hero",
-                class: "header",
-                data: { "sticky" => false, role: "deprecated" },
-              },
-            ],
-            :br,
-          ],
-        )
+            actual: [
+              [
+                :h2,
+                [:span, [:text, "Goodbye world"]],
+                {
+                  id: "hero",
+                  class: "header",
+                  data: {
+                    "sticky" => false,
+                    :role => "deprecated"
+                  }
+                }
+              ],
+              :br
+            ]
+          )
 
         expected_output = <<~STR.strip
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: [[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true } }]])
-              actual_line   %(  Actual: [[:h2, [:span, [:text, "Goodbye world"]], { id: "hero", class: "header", data: { "sticky" => false, :role => "deprecated" } }], :br])
-            end
-          }
+          colored do
+            expected_line %(Expected: [[:h1, [:span, [:text, "Hello world"]], { class: "header", data: { "sticky" => true } }]])
+            actual_line %(  Actual: [[:h2, [:span, [:text, "Goodbye world"]], { id: "hero", class: "header", data: { "sticky" => false, :role => "deprecated" } }], :br])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    [)
-              expected_line %(-     :h1,)
-              actual_line   %(+     :h2,)
-              plain_line    %(      [)
-              plain_line    %(        :span,)
-              plain_line    %(        [)
-              plain_line    %(          :text,)
-              expected_line %(-         "Hello world")
-              actual_line   %(+         "Goodbye world")
-              plain_line    %(        ])
-              plain_line    %(      ],)
-              plain_line    %(      {)
-              actual_line   %(+       id: "hero",)
-              plain_line    %(        class: "header",)
-              plain_line    %(        data: {)
-              expected_line %(-         "sticky" => true)
-              actual_line   %(+         "sticky" => false,)
-              actual_line   %(+         :role => "deprecated")
-              plain_line    %(        })
-              plain_line    %(      })
-              plain_line    %(    ],)
-              actual_line   %(+   :br)
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line "    ["
+            expected_line "-     :h1,"
+            actual_line "+     :h2,"
+            plain_line "      ["
+            plain_line "        :span,"
+            plain_line "        ["
+            plain_line "          :text,"
+            expected_line %(-         "Hello world")
+            actual_line %(+         "Goodbye world")
+            plain_line "        ]"
+            plain_line "      ],"
+            plain_line "      {"
+            actual_line %(+       id: "hero",)
+            plain_line %(        class: "header",)
+            plain_line "        data: {"
+            expected_line %(-         "sticky" => true)
+            actual_line %(+         "sticky" => false,)
+            actual_line %(+         :role => "deprecated")
+            plain_line "        }"
+            plain_line "      }"
+            plain_line "    ],"
+            actual_line "+   :br"
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -792,10 +789,15 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given the same hash" do
       it "returns an empty string" do
-        output = described_class.call(
-          expected: { name: "Marty" },
-          actual: { name: "Marty" },
-        )
+        output =
+          described_class.call(
+            expected: {
+              name: "Marty"
+            },
+            actual: {
+              name: "Marty"
+            }
+          )
 
         expect(output).to eq("")
       end
@@ -803,33 +805,42 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where the same key has differing numbers" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: { tall: 12, grande: 19, venti: 20 },
-          actual: { tall: 12, grande: 16, venti: 20 },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              tall: 12,
+              grande: 19,
+              venti: 20
+            },
+            actual: {
+              tall: 12,
+              grande: 16,
+              venti: 20
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { tall: 12, grande: 19, venti: 20 })
-              actual_line   %(  Actual: { tall: 12, grande: 16, venti: 20 })
-            end
-          }
+          colored do
+            expected_line "Expected: { tall: 12, grande: 19, venti: 20 }"
+            actual_line "  Actual: { tall: 12, grande: 16, venti: 20 }"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    tall: 12,)
-              expected_line %(-   grande: 19,)
-              actual_line   %(+   grande: 16,)
-              plain_line    %(    venti: 20)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    tall: 12,"
+            expected_line "-   grande: 19,"
+            actual_line "+   grande: 16,"
+            plain_line "    venti: 20"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -838,33 +849,42 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where keys are strings and the same key has differing numbers" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: { "tall" => 12, "grande" => 19, "venti" => 20 },
-          actual: { "tall" => 12, "grande" => 16, "venti" => 20 },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              "tall" => 12,
+              "grande" => 19,
+              "venti" => 20
+            },
+            actual: {
+              "tall" => 12,
+              "grande" => 16,
+              "venti" => 20
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { "tall" => 12, "grande" => 19, "venti" => 20 })
-              actual_line   %(  Actual: { "tall" => 12, "grande" => 16, "venti" => 20 })
-            end
-          }
+          colored do
+            expected_line %(Expected: { "tall" => 12, "grande" => 19, "venti" => 20 })
+            actual_line %(  Actual: { "tall" => 12, "grande" => 16, "venti" => 20 })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    "tall" => 12,)
-              expected_line %(-   "grande" => 19,)
-              actual_line   %(+   "grande" => 16,)
-              plain_line    %(    "venti" => 20)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line %(    "tall" => 12,)
+            expected_line %(-   "grande" => 19,)
+            actual_line %(+   "grande" => 16,)
+            plain_line %(    "venti" => 20)
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -873,33 +893,42 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where the same key has differing symbols" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: { tall: :small, grande: :grand, venti: :large },
-          actual: { tall: :small, grande: :medium, venti: :large },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              tall: :small,
+              grande: :grand,
+              venti: :large
+            },
+            actual: {
+              tall: :small,
+              grande: :medium,
+              venti: :large
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { tall: :small, grande: :grand, venti: :large })
-              actual_line   %(  Actual: { tall: :small, grande: :medium, venti: :large })
-            end
-          }
+          colored do
+            expected_line "Expected: { tall: :small, grande: :grand, venti: :large }"
+            actual_line "  Actual: { tall: :small, grande: :medium, venti: :large }"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    tall: :small,)
-              expected_line %(-   grande: :grand,)
-              actual_line   %(+   grande: :medium,)
-              plain_line    %(    venti: :large)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    tall: :small,"
+            expected_line "-   grande: :grand,"
+            actual_line "+   grande: :medium,"
+            plain_line "    venti: :large"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -908,33 +937,42 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where the same key has differing strings" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: { tall: "small", grande: "grand", venti: "large" },
-          actual: { tall: "small", grande: "medium", venti: "large" },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              tall: "small",
+              grande: "grand",
+              venti: "large"
+            },
+            actual: {
+              tall: "small",
+              grande: "medium",
+              venti: "large"
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { tall: "small", grande: "grand", venti: "large" })
-              actual_line   %(  Actual: { tall: "small", grande: "medium", venti: "large" })
-            end
-          }
+          colored do
+            expected_line %(Expected: { tall: "small", grande: "grand", venti: "large" })
+            actual_line %(  Actual: { tall: "small", grande: "medium", venti: "large" })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    tall: "small",)
-              expected_line %(-   grande: "grand",)
-              actual_line   %(+   grande: "medium",)
-              plain_line    %(    venti: "large")
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line %(    tall: "small",)
+            expected_line %(-   grande: "grand",)
+            actual_line %(+   grande: "medium",)
+            plain_line %(    venti: "large")
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -943,45 +981,46 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where the same key has differing objects" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: {
-            steve: SuperDiff::Test::Person.new(name: "Jobs", age: 30),
-            susan: SuperDiff::Test::Person.new(name: "Kare", age: 27),
-          },
-          actual: {
-            steve: SuperDiff::Test::Person.new(name: "Wozniak", age: 33),
-            susan: SuperDiff::Test::Person.new(name: "Kare", age: 27),
-          },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              steve: SuperDiff::Test::Person.new(name: "Jobs", age: 30),
+              susan: SuperDiff::Test::Person.new(name: "Kare", age: 27)
+            },
+            actual: {
+              steve: SuperDiff::Test::Person.new(name: "Wozniak", age: 33),
+              susan: SuperDiff::Test::Person.new(name: "Kare", age: 27)
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { steve: #<SuperDiff::Test::Person name: "Jobs", age: 30>, susan: #<SuperDiff::Test::Person name: "Kare", age: 27> })
-              actual_line   %(  Actual: { steve: #<SuperDiff::Test::Person name: "Wozniak", age: 33>, susan: #<SuperDiff::Test::Person name: "Kare", age: 27> })
-            end
-          }
+          colored do
+            expected_line %(Expected: { steve: #<SuperDiff::Test::Person name: "Jobs", age: 30>, susan: #<SuperDiff::Test::Person name: "Kare", age: 27> })
+            actual_line %(  Actual: { steve: #<SuperDiff::Test::Person name: "Wozniak", age: 33>, susan: #<SuperDiff::Test::Person name: "Kare", age: 27> })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    steve: #<SuperDiff::Test::Person {)
-              expected_line %(-     name: "Jobs",)
-              actual_line   %(+     name: "Wozniak",)
-              expected_line %(-     age: 30)
-              actual_line   %(+     age: 33)
-              plain_line    %(    }>,)
-              plain_line    %(    susan: #<SuperDiff::Test::Person {)
-              plain_line    %(      name: "Kare",)
-              plain_line    %(      age: 27)
-              plain_line    %(    }>)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    steve: #<SuperDiff::Test::Person {"
+            expected_line %(-     name: "Jobs",)
+            actual_line %(+     name: "Wozniak",)
+            expected_line "-     age: 30"
+            actual_line "+     age: 33"
+            plain_line "    }>,"
+            plain_line "    susan: #<SuperDiff::Test::Person {"
+            plain_line %(      name: "Kare",)
+            plain_line "      age: 27"
+            plain_line "    }>"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -990,32 +1029,39 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where the actual has extra keys" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: { latte: 4.5 },
-          actual: { latte: 4.5, mocha: 3.5, cortado: 3 },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              latte: 4.5
+            },
+            actual: {
+              latte: 4.5,
+              mocha: 3.5,
+              cortado: 3
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { latte: 4.5 })
-              actual_line   %(  Actual: { latte: 4.5, mocha: 3.5, cortado: 3 })
-            end
-          }
+          colored do
+            expected_line "Expected: { latte: 4.5 }"
+            actual_line "  Actual: { latte: 4.5, mocha: 3.5, cortado: 3 }"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    latte: 4.5,)
-              actual_line   %(+   mocha: 3.5,)
-              actual_line   %(+   cortado: 3)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    latte: 4.5,"
+            actual_line "+   mocha: 3.5,"
+            actual_line "+   cortado: 3"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1024,32 +1070,39 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two equal-size, one-dimensional hashes where the actual has missing keys" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: { latte: 4.5, mocha: 3.5, cortado: 3 },
-          actual: { latte: 4.5 },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              latte: 4.5,
+              mocha: 3.5,
+              cortado: 3
+            },
+            actual: {
+              latte: 4.5
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { latte: 4.5, mocha: 3.5, cortado: 3 })
-              actual_line   %(  Actual: { latte: 4.5 })
-            end
-          }
+          colored do
+            expected_line "Expected: { latte: 4.5, mocha: 3.5, cortado: 3 }"
+            actual_line "  Actual: { latte: 4.5 }"
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    latte: 4.5)
-              expected_line %(-   mocha: 3.5,)
-              expected_line %(-   cortado: 3)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    latte: 4.5"
+            expected_line "-   mocha: 3.5,"
+            expected_line "-   cortado: 3"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1059,77 +1112,84 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
     context "given two equal-size, one-dimensional hashes where there is a mixture of missing and extra keys in relatively the same order" do
       context "and the actual value is in relatively the same order as the expected" do
         it "preserves the order of the keys as they are defined" do
-          actual_output = described_class.call(
-            expected: {
-              listed_count: 37_009,
-              created_at: "Tue Jan 13 19:28:24 +0000 2009",
-              favourites_count: 38,
-              geo_enabled: false,
-              verified: true,
-              statuses_count: 273_860,
-              media_count: 51_044,
-              contributors_enabled: false,
-              profile_background_color: "FFF1E0",
-              profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",
-              profile_background_tile: false,
-              profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",
-              profile_image_url_https: "https://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",
-              profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592",
-            },
-            actual: {
-              listed_count: 37_009,
-              created_at: "Tue Jan 13 19:28:24 +0000 2009",
-              favourites_count: 38,
-              utc_offset: nil,
-              time_zone: nil,
-              statuses_count: 273_860,
-              media_count: 51_044,
-              contributors_enabled: false,
-              is_translator: false,
-              is_translation_enabled: false,
-              profile_background_color: "FFF1E0",
-              profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",
-              profile_background_tile: false,
-              profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592",
-            }
-          )
+          actual_output =
+            described_class.call(
+              expected: {
+                listed_count: 37_009,
+                created_at: "Tue Jan 13 19:28:24 +0000 2009",
+                favourites_count: 38,
+                geo_enabled: false,
+                verified: true,
+                statuses_count: 273_860,
+                media_count: 51_044,
+                contributors_enabled: false,
+                profile_background_color: "FFF1E0",
+                profile_background_image_url_https:
+                  "https://abs.twimg.com/images/themes/theme1/bg.png",
+                profile_background_tile: false,
+                profile_image_url:
+                  "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",
+                profile_image_url_https:
+                  "https://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",
+                profile_banner_url:
+                  "https://pbs.twimg.com/profile_banners/18949452/1581526592"
+              },
+              actual: {
+                listed_count: 37_009,
+                created_at: "Tue Jan 13 19:28:24 +0000 2009",
+                favourites_count: 38,
+                utc_offset: nil,
+                time_zone: nil,
+                statuses_count: 273_860,
+                media_count: 51_044,
+                contributors_enabled: false,
+                is_translator: false,
+                is_translation_enabled: false,
+                profile_background_color: "FFF1E0",
+                profile_background_image_url_https:
+                  "https://abs.twimg.com/images/themes/theme1/bg.png",
+                profile_background_tile: false,
+                profile_banner_url:
+                  "https://pbs.twimg.com/profile_banners/18949452/1581526592"
+              }
+            )
 
           expected_output = <<~STR.strip
             Differing hashes.
 
             #{
-              colored do
-                expected_line %(Expected: { listed_count: 37009, created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, geo_enabled: false, verified: true, statuses_count: 273860, media_count: 51044, contributors_enabled: false, profile_background_color: "FFF1E0", profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_background_tile: false, profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg", profile_image_url_https: "https://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg", profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592" })
-                actual_line   %(  Actual: { listed_count: 37009, created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, utc_offset: nil, time_zone: nil, statuses_count: 273860, media_count: 51044, contributors_enabled: false, is_translator: false, is_translation_enabled: false, profile_background_color: "FFF1E0", profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_background_tile: false, profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592" })
-              end
-            }
+            colored do
+              expected_line %(Expected: { listed_count: 37009, created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, geo_enabled: false, verified: true, statuses_count: 273860, media_count: 51044, contributors_enabled: false, profile_background_color: "FFF1E0", profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_background_tile: false, profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg", profile_image_url_https: "https://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg", profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592" })
+              actual_line %(  Actual: { listed_count: 37009, created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, utc_offset: nil, time_zone: nil, statuses_count: 273860, media_count: 51044, contributors_enabled: false, is_translator: false, is_translation_enabled: false, profile_background_color: "FFF1E0", profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_background_tile: false, profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592" })
+            end
+          }
 
             Diff:
 
             #{
-              colored do
-                plain_line    %(  {)
-                plain_line    %(    listed_count: 37009,)
-                plain_line    %(    created_at: "Tue Jan 13 19:28:24 +0000 2009",)
-                plain_line    %(    favourites_count: 38,)
-                expected_line %(-   geo_enabled: false,)
-                expected_line %(-   verified: true,)
-                actual_line   %(+   utc_offset: nil,)
-                actual_line   %(+   time_zone: nil,)
-                plain_line    %(    statuses_count: 273860,)
-                plain_line    %(    media_count: 51044,)
-                plain_line    %(    contributors_enabled: false,)
-                actual_line   %(+   is_translator: false,)
-                actual_line   %(+   is_translation_enabled: false,)
-                plain_line    %(    profile_background_color: "FFF1E0",)
-                plain_line    %(    profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",)
-                plain_line    %(    profile_background_tile: false,)
-                expected_line %(-   profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",)
-                expected_line %(-   profile_image_url_https: "https://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",)
-                plain_line    %(    profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592")
-                plain_line    %(  })
-              end
-            }
+            colored do
+              plain_line "  {"
+              plain_line "    listed_count: 37009,"
+              plain_line %(    created_at: "Tue Jan 13 19:28:24 +0000 2009",)
+              plain_line "    favourites_count: 38,"
+              expected_line "-   geo_enabled: false,"
+              expected_line "-   verified: true,"
+              actual_line "+   utc_offset: nil,"
+              actual_line "+   time_zone: nil,"
+              plain_line "    statuses_count: 273860,"
+              plain_line "    media_count: 51044,"
+              plain_line "    contributors_enabled: false,"
+              actual_line "+   is_translator: false,"
+              actual_line "+   is_translation_enabled: false,"
+              plain_line %(    profile_background_color: "FFF1E0",)
+              plain_line %(    profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",)
+              plain_line "    profile_background_tile: false,"
+              expected_line %(-   profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",)
+              expected_line %(-   profile_image_url_https: "https://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",)
+              plain_line %(    profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592")
+              plain_line "  }"
+            end
+          }
           STR
 
           expect(actual_output).to match_output(expected_output)
@@ -1138,73 +1198,79 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
       context "and the actual value is in a different order than the expected" do
         it "preserves the order of the keys as they are defined" do
-          actual_output = described_class.call(
-            expected: {
-              created_at: "Tue Jan 13 19:28:24 +0000 2009",
-              favourites_count: 38,
-              geo_enabled: false,
-              verified: true,
-              media_count: 51_044,
-              statuses_count: 273_860,
-              contributors_enabled: false,
-              profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",
-              profile_background_color: "FFF1E0",
-              profile_background_tile: false,
-              profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",
-              listed_count: 37_009,
-              profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592",
-            },
-            actual: {
-              listed_count: 37_009,
-              created_at: "Tue Jan 13 19:28:24 +0000 2009",
-              favourites_count: 38,
-              utc_offset: nil,
-              statuses_count: 273_860,
-              media_count: 51_044,
-              contributors_enabled: false,
-              is_translator: false,
-              is_translation_enabled: false,
-              profile_background_color: "FFF1E0",
-              profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",
-              profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592",
-              profile_background_tile: false,
-            }
-          )
+          actual_output =
+            described_class.call(
+              expected: {
+                created_at: "Tue Jan 13 19:28:24 +0000 2009",
+                favourites_count: 38,
+                geo_enabled: false,
+                verified: true,
+                media_count: 51_044,
+                statuses_count: 273_860,
+                contributors_enabled: false,
+                profile_background_image_url_https:
+                  "https://abs.twimg.com/images/themes/theme1/bg.png",
+                profile_background_color: "FFF1E0",
+                profile_background_tile: false,
+                profile_image_url:
+                  "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",
+                listed_count: 37_009,
+                profile_banner_url:
+                  "https://pbs.twimg.com/profile_banners/18949452/1581526592"
+              },
+              actual: {
+                listed_count: 37_009,
+                created_at: "Tue Jan 13 19:28:24 +0000 2009",
+                favourites_count: 38,
+                utc_offset: nil,
+                statuses_count: 273_860,
+                media_count: 51_044,
+                contributors_enabled: false,
+                is_translator: false,
+                is_translation_enabled: false,
+                profile_background_color: "FFF1E0",
+                profile_background_image_url_https:
+                  "https://abs.twimg.com/images/themes/theme1/bg.png",
+                profile_banner_url:
+                  "https://pbs.twimg.com/profile_banners/18949452/1581526592",
+                profile_background_tile: false
+              }
+            )
 
           expected_output = <<~STR.strip
             Differing hashes.
 
             #{
-              colored do
-                expected_line %(Expected: { created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, geo_enabled: false, verified: true, media_count: 51044, statuses_count: 273860, contributors_enabled: false, profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_background_color: "FFF1E0", profile_background_tile: false, profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg", listed_count: 37009, profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592" })
-                actual_line   %(  Actual: { listed_count: 37009, created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, utc_offset: nil, statuses_count: 273860, media_count: 51044, contributors_enabled: false, is_translator: false, is_translation_enabled: false, profile_background_color: "FFF1E0", profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592", profile_background_tile: false })
-              end
-            }
+            colored do
+              expected_line %(Expected: { created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, geo_enabled: false, verified: true, media_count: 51044, statuses_count: 273860, contributors_enabled: false, profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_background_color: "FFF1E0", profile_background_tile: false, profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg", listed_count: 37009, profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592" })
+              actual_line %(  Actual: { listed_count: 37009, created_at: "Tue Jan 13 19:28:24 +0000 2009", favourites_count: 38, utc_offset: nil, statuses_count: 273860, media_count: 51044, contributors_enabled: false, is_translator: false, is_translation_enabled: false, profile_background_color: "FFF1E0", profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png", profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592", profile_background_tile: false })
+            end
+          }
 
             Diff:
 
             #{
-              colored do
-                plain_line    %(  {)
-                plain_line    %(    listed_count: 37009,)
-                plain_line    %(    created_at: "Tue Jan 13 19:28:24 +0000 2009",)
-                plain_line    %(    favourites_count: 38,)
-                expected_line %(-   geo_enabled: false,)
-                expected_line %(-   verified: true,)
-                actual_line   %(+   utc_offset: nil,)
-                plain_line    %(    statuses_count: 273860,)
-                plain_line    %(    media_count: 51044,)
-                plain_line    %(    contributors_enabled: false,)
-                actual_line   %(+   is_translator: false,)
-                actual_line   %(+   is_translation_enabled: false,)
-                plain_line    %(    profile_background_color: "FFF1E0",)
-                plain_line    %(    profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",)
-                expected_line %(-   profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",)
-                plain_line    %(    profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592",)
-                plain_line    %(    profile_background_tile: false)
-                plain_line    %(  })
-              end
-            }
+            colored do
+              plain_line "  {"
+              plain_line "    listed_count: 37009,"
+              plain_line %(    created_at: "Tue Jan 13 19:28:24 +0000 2009",)
+              plain_line "    favourites_count: 38,"
+              expected_line "-   geo_enabled: false,"
+              expected_line "-   verified: true,"
+              actual_line "+   utc_offset: nil,"
+              plain_line "    statuses_count: 273860,"
+              plain_line "    media_count: 51044,"
+              plain_line "    contributors_enabled: false,"
+              actual_line "+   is_translator: false,"
+              actual_line "+   is_translation_enabled: false,"
+              plain_line %(    profile_background_color: "FFF1E0",)
+              plain_line %(    profile_background_image_url_https: "https://abs.twimg.com/images/themes/theme1/bg.png",)
+              expected_line %(-   profile_image_url: "http://pbs.twimg.com/profile_images/931156393108885504/EqEMtLhM_normal.jpg",)
+              plain_line %(    profile_banner_url: "https://pbs.twimg.com/profile_banners/18949452/1581526592",)
+              plain_line "    profile_background_tile: false"
+              plain_line "  }"
+            end
+          }
           STR
 
           expect(actual_output).to match_output(expected_output)
@@ -1214,45 +1280,46 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two hashes containing arrays with differing values" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: {
-            name: "Elliot",
-            interests: ["music", "football", "programming"],
-            age: 30,
-          },
-          actual: {
-            name: "Elliot",
-            interests: ["music", "travel", "programming"],
-            age: 30,
-          },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              name: "Elliot",
+              interests: %w[music football programming],
+              age: 30
+            },
+            actual: {
+              name: "Elliot",
+              interests: %w[music travel programming],
+              age: 30
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { name: "Elliot", interests: ["music", "football", "programming"], age: 30 })
-              actual_line   %(  Actual: { name: "Elliot", interests: ["music", "travel", "programming"], age: 30 })
-            end
-          }
+          colored do
+            expected_line %(Expected: { name: "Elliot", interests: ["music", "football", "programming"], age: 30 })
+            actual_line %(  Actual: { name: "Elliot", interests: ["music", "travel", "programming"], age: 30 })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    name: "Elliot",)
-              plain_line    %(    interests: [)
-              plain_line    %(      "music",)
-              expected_line %(-     "football",)
-              actual_line   %(+     "travel",)
-              plain_line    %(      "programming")
-              plain_line    %(    ],)
-              plain_line    %(    age: 30)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line %(    name: "Elliot",)
+            plain_line "    interests: ["
+            plain_line %(      "music",)
+            expected_line %(-     "football",)
+            actual_line %(+     "travel",)
+            plain_line %(      "programming")
+            plain_line "    ],"
+            plain_line "    age: 30"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1261,53 +1328,54 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two hashes containing hashes with differing values" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: {
-            check_spelling: true,
-            substitutions: {
-              "YOLO" => "You only live once",
-              "BRB" => "Buns, ribs, and bacon",
-              "YMMV" => "Your mileage may vary",
-            },
-            check_grammar: false,
-          },
-          actual: {
-            check_spelling: true,
-            substitutions: {
-              "YOLO" => "You only live once",
-              "BRB" => "Be right back",
-              "YMMV" => "Your mileage may vary",
+        actual_output =
+          described_class.call(
+            expected: {
+              check_spelling: true,
+              substitutions: {
+                "YOLO" => "You only live once",
+                "BRB" => "Buns, ribs, and bacon",
+                "YMMV" => "Your mileage may vary"
+              },
+              check_grammar: false
             },
-            check_grammar: false,
-          },
-        )
+            actual: {
+              check_spelling: true,
+              substitutions: {
+                "YOLO" => "You only live once",
+                "BRB" => "Be right back",
+                "YMMV" => "Your mileage may vary"
+              },
+              check_grammar: false
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Buns, ribs, and bacon", "YMMV" => "Your mileage may vary" }, check_grammar: false })
-              actual_line   %(  Actual: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Be right back", "YMMV" => "Your mileage may vary" }, check_grammar: false })
-            end
-          }
+          colored do
+            expected_line %(Expected: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Buns, ribs, and bacon", "YMMV" => "Your mileage may vary" }, check_grammar: false })
+            actual_line %(  Actual: { check_spelling: true, substitutions: { "YOLO" => "You only live once", "BRB" => "Be right back", "YMMV" => "Your mileage may vary" }, check_grammar: false })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    check_spelling: true,)
-              plain_line    %(    substitutions: {)
-              plain_line    %(      "YOLO" => "You only live once",)
-              expected_line %(-     "BRB" => "Buns, ribs, and bacon",)
-              actual_line   %(+     "BRB" => "Be right back",)
-              plain_line    %(      "YMMV" => "Your mileage may vary")
-              plain_line    %(    },)
-              plain_line    %(    check_grammar: false)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    check_spelling: true,"
+            plain_line "    substitutions: {"
+            plain_line %(      "YOLO" => "You only live once",)
+            expected_line %(-     "BRB" => "Buns, ribs, and bacon",)
+            actual_line %(+     "BRB" => "Be right back",)
+            plain_line %(      "YMMV" => "Your mileage may vary")
+            plain_line "    },"
+            plain_line "    check_grammar: false"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1316,45 +1384,46 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two hashes containing custom objects with differing attributes" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: {
-            order_id: 1234,
-            person: SuperDiff::Test::Person.new(name: "Marty", age: 18),
-            amount: 350_00,
-          },
-          actual: {
-            order_id: 1234,
-            person: SuperDiff::Test::Person.new(name: "Doc", age: 50),
-            amount: 350_00,
-          },
-        )
+        actual_output =
+          described_class.call(
+            expected: {
+              order_id: 1234,
+              person: SuperDiff::Test::Person.new(name: "Marty", age: 18),
+              amount: 350_00
+            },
+            actual: {
+              order_id: 1234,
+              person: SuperDiff::Test::Person.new(name: "Doc", age: 50),
+              amount: 350_00
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Marty", age: 18>, amount: 35000 })
-              actual_line   %(  Actual: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Doc", age: 50>, amount: 35000 })
-            end
-          }
+          colored do
+            expected_line %(Expected: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Marty", age: 18>, amount: 35000 })
+            actual_line %(  Actual: { order_id: 1234, person: #<SuperDiff::Test::Person name: "Doc", age: 50>, amount: 35000 })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    order_id: 1234,)
-              plain_line    %(    person: #<SuperDiff::Test::Person {)
-              expected_line %(-     name: "Marty",)
-              actual_line   %(+     name: "Doc",)
-              expected_line %(-     age: 18)
-              actual_line   %(+     age: 50)
-              plain_line    %(    }>,)
-              plain_line    %(    amount: 35000)
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    order_id: 1234,"
+            plain_line "    person: #<SuperDiff::Test::Person {"
+            expected_line %(-     name: "Marty",)
+            actual_line %(+     name: "Doc",)
+            expected_line "-     age: 18"
+            actual_line "+     age: 50"
+            plain_line "    }>,"
+            plain_line "    amount: 35000"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1363,91 +1432,92 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two hashes which contain all different kinds of values, some which differ" do
       it "returns a message along with the diff" do
-        actual_output = described_class.call(
-          expected: {
-            customer: {
-              name: "Marty McFly",
-              shipping_address: {
-                line_1: "123 Main St.",
-                city: "Hill Valley",
-                state: "CA",
-                zip: "90382",
-              },
-            },
-            items: [
-              {
-                name: "Fender Stratocaster",
-                cost: 100_000,
-                options: ["red", "blue", "green"],
-              },
-              { name: "Chevy 4x4" },
-            ],
-          },
-          actual: {
-            customer: {
-              name: "Marty McFly, Jr.",
-              shipping_address: {
-                line_1: "456 Ponderosa Ct.",
-                city: "Hill Valley",
-                state: "CA",
-                zip: "90382",
+        actual_output =
+          described_class.call(
+            expected: {
+              customer: {
+                name: "Marty McFly",
+                shipping_address: {
+                  line_1: "123 Main St.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382"
+                }
               },
+              items: [
+                {
+                  name: "Fender Stratocaster",
+                  cost: 100_000,
+                  options: %w[red blue green]
+                },
+                { name: "Chevy 4x4" }
+              ]
             },
-            items: [
-              {
-                name: "Fender Stratocaster",
-                cost: 100_000,
-                options: ["red", "blue", "green"],
+            actual: {
+              customer: {
+                name: "Marty McFly, Jr.",
+                shipping_address: {
+                  line_1: "456 Ponderosa Ct.",
+                  city: "Hill Valley",
+                  state: "CA",
+                  zip: "90382"
+                }
               },
-              { name: "Mattel Hoverboard" },
-            ],
-          },
-        )
+              items: [
+                {
+                  name: "Fender Stratocaster",
+                  cost: 100_000,
+                  options: %w[red blue green]
+                },
+                { name: "Mattel Hoverboard" }
+              ]
+            }
+          )
 
         expected_output = <<~STR.strip
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { customer: { name: "Marty McFly", shipping_address: { line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Chevy 4x4" }] })
-              actual_line   %(  Actual: { customer: { name: "Marty McFly, Jr.", shipping_address: { line_1: "456 Ponderosa Ct.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Mattel Hoverboard" }] })
-            end
-          }
+          colored do
+            expected_line %(Expected: { customer: { name: "Marty McFly", shipping_address: { line_1: "123 Main St.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Chevy 4x4" }] })
+            actual_line %(  Actual: { customer: { name: "Marty McFly, Jr.", shipping_address: { line_1: "456 Ponderosa Ct.", city: "Hill Valley", state: "CA", zip: "90382" } }, items: [{ name: "Fender Stratocaster", cost: 100000, options: ["red", "blue", "green"] }, { name: "Mattel Hoverboard" }] })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    customer: {)
-              expected_line %(-     name: "Marty McFly",)
-              actual_line   %(+     name: "Marty McFly, Jr.",)
-              plain_line    %(      shipping_address: {)
-              expected_line %(-       line_1: "123 Main St.",)
-              actual_line   %(+       line_1: "456 Ponderosa Ct.",)
-              plain_line    %(        city: "Hill Valley",)
-              plain_line    %(        state: "CA",)
-              plain_line    %(        zip: "90382")
-              plain_line    %(      })
-              plain_line    %(    },)
-              plain_line    %(    items: [)
-              plain_line    %(      {)
-              plain_line    %(        name: "Fender Stratocaster",)
-              plain_line    %(        cost: 100000,)
-              plain_line    %(        options: [)
-              plain_line    %(          "red",)
-              plain_line    %(          "blue",)
-              plain_line    %(          "green")
-              plain_line    %(        ])
-              plain_line    %(      },)
-              plain_line    %(      {)
-              expected_line %(-       name: "Chevy 4x4")
-              actual_line   %(+       name: "Mattel Hoverboard")
-              plain_line    %(      })
-              plain_line    %(    ])
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    customer: {"
+            expected_line %(-     name: "Marty McFly",)
+            actual_line %(+     name: "Marty McFly, Jr.",)
+            plain_line "      shipping_address: {"
+            expected_line %(-       line_1: "123 Main St.",)
+            actual_line %(+       line_1: "456 Ponderosa Ct.",)
+            plain_line %(        city: "Hill Valley",)
+            plain_line %(        state: "CA",)
+            plain_line %(        zip: "90382")
+            plain_line "      }"
+            plain_line "    },"
+            plain_line "    items: ["
+            plain_line "      {"
+            plain_line %(        name: "Fender Stratocaster",)
+            plain_line "        cost: 100000,"
+            plain_line "        options: ["
+            plain_line %(          "red",)
+            plain_line %(          "blue",)
+            plain_line %(          "green")
+            plain_line "        ]"
+            plain_line "      },"
+            plain_line "      {"
+            expected_line %(-       name: "Chevy 4x4")
+            actual_line %(+       name: "Mattel Hoverboard")
+            plain_line "      }"
+            plain_line "    ]"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1470,33 +1540,30 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
         expected = SuperDiff::Test::Person.new(name: "Marty", age: 18)
         actual = SuperDiff::Test::Person.new(name: "Doc", age: 50)
 
-        actual_output = described_class.call(
-          expected: expected,
-          actual: actual,
-        )
+        actual_output = described_class.call(expected: expected, actual: actual)
 
         expected_output = <<~STR.strip
           Differing objects.
 
           #{
-            colored do
-              expected_line %(Expected: #<SuperDiff::Test::Person name: "Marty", age: 18>)
-              actual_line   %(  Actual: #<SuperDiff::Test::Person name: "Doc", age: 50>)
-            end
-          }
+          colored do
+            expected_line %(Expected: #<SuperDiff::Test::Person name: "Marty", age: 18>)
+            actual_line %(  Actual: #<SuperDiff::Test::Person name: "Doc", age: 50>)
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  #<SuperDiff::Test::Person {)
-              expected_line %(-   name: "Marty",)
-              actual_line   %(+   name: "Doc",)
-              expected_line %(-   age: 18)
-              actual_line   %(+   age: 50)
-              plain_line    %(  }>)
-            end
-          }
+          colored do
+            plain_line "  #<SuperDiff::Test::Person {"
+            expected_line %(-   name: "Marty",)
+            actual_line %(+   name: "Doc",)
+            expected_line "-   age: 18"
+            actual_line "+   age: 50"
+            plain_line "  }>"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1505,22 +1572,24 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two different versions of the same non-custom class" do
       it "returns a message along with the diff" do
-        expected = SuperDiff::Test::Player.new(
-          handle: "martymcfly",
-          character: "mirage",
-          inventory: ["flatline", "purple body shield"],
-          shields: 0.6,
-          health: 0.3,
-          ultimate: 0.8,
-        )
-        actual = SuperDiff::Test::Player.new(
-          handle: "docbrown",
-          character: "lifeline",
-          inventory: ["wingman", "mastiff"],
-          shields: 0.6,
-          health: 0.3,
-          ultimate: 0.8,
-        )
+        expected =
+          SuperDiff::Test::Player.new(
+            handle: "martymcfly",
+            character: "mirage",
+            inventory: ["flatline", "purple body shield"],
+            shields: 0.6,
+            health: 0.3,
+            ultimate: 0.8
+          )
+        actual =
+          SuperDiff::Test::Player.new(
+            handle: "docbrown",
+            character: "lifeline",
+            inventory: %w[wingman mastiff],
+            shields: 0.6,
+            health: 0.3,
+            ultimate: 0.8
+          )
 
         actual_output = described_class.call(expected: expected, actual: actual)
 
@@ -1528,33 +1597,33 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing objects.
 
           #{
-            colored do
-              expected_line %(Expected: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(expected)} @character="mirage", @handle="martymcfly", @health=0.3, @inventory=["flatline", "purple body shield"], @shields=0.6, @ultimate=0.8>)
-              actual_line   %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} @character="lifeline", @handle="docbrown", @health=0.3, @inventory=["wingman", "mastiff"], @shields=0.6, @ultimate=0.8>)
-            end
-          }
+          colored do
+            expected_line %(Expected: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(expected)} @character="mirage", @handle="martymcfly", @health=0.3, @inventory=["flatline", "purple body shield"], @shields=0.6, @ultimate=0.8>)
+            actual_line %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} @character="lifeline", @handle="docbrown", @health=0.3, @inventory=["wingman", "mastiff"], @shields=0.6, @ultimate=0.8>)
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} {)
-              expected_line %(-   @character="mirage",)
-              actual_line   %(+   @character="lifeline",)
-              expected_line %(-   @handle="martymcfly",)
-              actual_line   %(+   @handle="docbrown",)
-              plain_line    %(    @health=0.3,)
-              plain_line    %(    @inventory=[)
-              expected_line %(-     "flatline",)
-              actual_line   %(+     "wingman",)
-              expected_line %(-     "purple body shield")
-              actual_line   %(+     "mastiff")
-              plain_line    %(    ],)
-              plain_line    %(    @shields=0.6,)
-              plain_line    %(    @ultimate=0.8)
-              plain_line    %(  }>)
-            end
-          }
+          colored do
+            plain_line %(  #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} {)
+            expected_line %(-   @character="mirage",)
+            actual_line %(+   @character="lifeline",)
+            expected_line %(-   @handle="martymcfly",)
+            actual_line %(+   @handle="docbrown",)
+            plain_line "    @health=0.3,"
+            plain_line "    @inventory=["
+            expected_line %(-     "flatline",)
+            actual_line %(+     "wingman",)
+            expected_line %(-     "purple body shield")
+            actual_line %(+     "mastiff")
+            plain_line "    ],"
+            plain_line "    @shields=0.6,"
+            plain_line "    @ultimate=0.8"
+            plain_line "  }>"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1563,15 +1632,13 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two completely different kinds of custom objects" do
       it "returns a message along with the diff" do
-        expected = SuperDiff::Test::Person.new(
-          name: "Marty",
-          age: 31,
-        )
-        actual = SuperDiff::Test::Customer.new(
-          name: "Doc",
-          shipping_address: :some_shipping_address,
-          phone: "1234567890",
-        )
+        expected = SuperDiff::Test::Person.new(name: "Marty", age: 31)
+        actual =
+          SuperDiff::Test::Customer.new(
+            name: "Doc",
+            shipping_address: :some_shipping_address,
+            phone: "1234567890"
+          )
 
         actual_output = described_class.call(expected: expected, actual: actual)
 
@@ -1579,11 +1646,11 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing objects.
 
           #{
-            colored do
-              expected_line %(Expected: #<SuperDiff::Test::Person name: "Marty", age: 31>)
-              actual_line   %(  Actual: #<SuperDiff::Test::Customer name: "Doc", shipping_address: :some_shipping_address, phone: "1234567890">)
-            end
-          }
+          colored do
+            expected_line %(Expected: #<SuperDiff::Test::Person name: "Marty", age: 31>)
+            actual_line %(  Actual: #<SuperDiff::Test::Customer name: "Doc", shipping_address: :some_shipping_address, phone: "1234567890">)
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1592,18 +1659,16 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "given two completely different kinds of non-custom objects" do
       it "returns a message along with the diff" do
-        expected = SuperDiff::Test::Item.new(
-          name: "camera",
-          quantity: 3,
-        )
-        actual = SuperDiff::Test::Player.new(
-          handle: "mcmire",
-          character: "Jon",
-          inventory: ["sword"],
-          shields: 11.4,
-          health: 4,
-          ultimate: true,
-        )
+        expected = SuperDiff::Test::Item.new(name: "camera", quantity: 3)
+        actual =
+          SuperDiff::Test::Player.new(
+            handle: "mcmire",
+            character: "Jon",
+            inventory: ["sword"],
+            shields: 11.4,
+            health: 4,
+            ultimate: true
+          )
 
         actual_output = described_class.call(expected: expected, actual: actual)
 
@@ -1611,11 +1676,11 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing objects.
 
           #{
-            colored do
-              expected_line %(Expected: #<SuperDiff::Test::Item:#{SuperDiff::Helpers.object_address_for(expected)} @name="camera", @quantity=3>)
-              actual_line   %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} @character="Jon", @handle="mcmire", @health=4, @inventory=["sword"], @shields=11.4, @ultimate=true>)
-            end
-          }
+          colored do
+            expected_line %(Expected: #<SuperDiff::Test::Item:#{SuperDiff::Helpers.object_address_for(expected)} @name="camera", @quantity=3>)
+            actual_line %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} @character="Jon", @handle="mcmire", @health=4, @inventory=["sword"], @shields=11.4, @ultimate=true>)
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1624,9 +1689,9 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "when the expected value is a data structure that refers to itself somewhere inside of it" do
       it "replaces the reference with ∙∙∙" do
-        expected = ["a", "b", "c"]
+        expected = %w[a b c]
         expected.insert(1, expected)
-        actual = ["a", "x", "b", "c"]
+        actual = %w[a x b c]
 
         actual_output = described_class.call(expected: expected, actual: actual)
 
@@ -1634,25 +1699,25 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["a", ∙∙∙, "b", "c"])
-              actual_line   %(  Actual: ["a", "x", "b", "c"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["a", ∙∙∙, "b", "c"])
+            actual_line %(  Actual: ["a", "x", "b", "c"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    "a",)
-              expected_line %(-   ∙∙∙,)
-              actual_line   %(+   "x",)
-              plain_line    %(    "b",)
-              plain_line    %(    "c")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line %(    "a",)
+            expected_line "-   ∙∙∙,"
+            actual_line %(+   "x",)
+            plain_line %(    "b",)
+            plain_line %(    "c")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1661,8 +1726,8 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "when the actual value is a data structure that refers to itself somewhere inside of it" do
       it "replaces the reference with ∙∙∙" do
-        expected = ["a", "x", "b", "c"]
-        actual = ["a", "b", "c"]
+        expected = %w[a x b c]
+        actual = %w[a b c]
         actual.insert(1, actual)
 
         actual_output = described_class.call(expected: expected, actual: actual)
@@ -1671,25 +1736,25 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing arrays.
 
           #{
-            colored do
-              expected_line %(Expected: ["a", "x", "b", "c"])
-              actual_line   %(  Actual: ["a", ∙∙∙, "b", "c"])
-            end
-          }
+          colored do
+            expected_line %(Expected: ["a", "x", "b", "c"])
+            actual_line %(  Actual: ["a", ∙∙∙, "b", "c"])
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  [)
-              plain_line    %(    "a",)
-              expected_line %(-   "x",)
-              actual_line   %(+   ∙∙∙,)
-              plain_line    %(    "b",)
-              plain_line    %(    "c")
-              plain_line    %(  ])
-            end
-          }
+          colored do
+            plain_line "  ["
+            plain_line %(    "a",)
+            expected_line %(-   "x",)
+            actual_line "+   ∙∙∙,"
+            plain_line %(    "b",)
+            plain_line %(    "c")
+            plain_line "  ]"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1698,8 +1763,8 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "when the data structure being different is present inside a secondary layer" do
       it "replaces the reference with ∙∙∙" do
-        expected = { foo: ["a", "x", "b", "c"] }
-        actual = { foo: ["a", "b", "c"] }
+        expected = { foo: %w[a x b c] }
+        actual = { foo: %w[a b c] }
         actual[:foo].insert(1, actual)
 
         actual_output = described_class.call(expected: expected, actual: actual)
@@ -1708,27 +1773,27 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { foo: ["a", "x", "b", "c"] })
-              actual_line   %(  Actual: { foo: ["a", ∙∙∙, "b", "c"] })
-            end
-          }
+          colored do
+            expected_line %(Expected: { foo: ["a", "x", "b", "c"] })
+            actual_line %(  Actual: { foo: ["a", ∙∙∙, "b", "c"] })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    foo: [)
-              plain_line    %(      "a",)
-              expected_line %(-     "x",)
-              actual_line   %(+     ∙∙∙,)
-              plain_line    %(      "b",)
-              plain_line    %(      "c")
-              plain_line    %(    ])
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    foo: ["
+            plain_line %(      "a",)
+            expected_line %(-     "x",)
+            actual_line "+     ∙∙∙,"
+            plain_line %(      "b",)
+            plain_line %(      "c")
+            plain_line "    ]"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)
@@ -1737,8 +1802,8 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
     context "when a secondary layer of a data structure refers to itself" do
       it "replaces the reference with ∙∙∙" do
-        expected = { foo: ["a", "x", "b", "c"] }
-        actual = { foo: ["a", "b", "c"] }
+        expected = { foo: %w[a x b c] }
+        actual = { foo: %w[a b c] }
         actual[:foo].insert(1, actual[:foo])
 
         actual_output = described_class.call(expected: expected, actual: actual)
@@ -1747,27 +1812,27 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
           Differing hashes.
 
           #{
-            colored do
-              expected_line %(Expected: { foo: ["a", "x", "b", "c"] })
-              actual_line   %(  Actual: { foo: ["a", ∙∙∙, "b", "c"] })
-            end
-          }
+          colored do
+            expected_line %(Expected: { foo: ["a", "x", "b", "c"] })
+            actual_line %(  Actual: { foo: ["a", ∙∙∙, "b", "c"] })
+          end
+        }
 
           Diff:
 
           #{
-            colored do
-              plain_line    %(  {)
-              plain_line    %(    foo: [)
-              plain_line    %(      "a",)
-              expected_line %(-     "x",)
-              actual_line   %(+     ∙∙∙,)
-              plain_line    %(      "b",)
-              plain_line    %(      "c")
-              plain_line    %(    ])
-              plain_line    %(  })
-            end
-          }
+          colored do
+            plain_line "  {"
+            plain_line "    foo: ["
+            plain_line %(      "a",)
+            expected_line %(-     "x",)
+            actual_line "+     ∙∙∙,"
+            plain_line %(      "b",)
+            plain_line %(      "c")
+            plain_line "    ]"
+            plain_line "  }"
+          end
+        }
         STR
 
         expect(actual_output).to match_output(expected_output)