Be smarter about highlighting first line of failure message

If a failure message has paragraphs or an indented section, only
highlight the first part of the message in red instead of just the very
first part. This is most applicable to shoulda-matchers, where it is
very common to have failure messages like:

    Expected Foo to have bar, but this could not be proven.
      Foo did not have a bar.

It's also possible however to have messages like:

    Expected Foo to have bar, but this could not be proven.

    Foo did not have a bar.

Author: mcmire

lib/super_diff/csi.rb

@@ -36,6 +36,10 @@ def self.decolorize(text)
       text.gsub(/\e\[\d+(?:;\d+)*m(.+?)\e\[0m/, '\1')
     end
 
+    def self.already_colorized?(text)
+      text.match?(/\e\[\d+m/)
+    end
+
     def self.inspect_colors_in(text)
       [FourBitColor, EightBitColor, TwentyFourBitColor].
         reduce(text) do |str, klass|

lib/super_diff/rspec/monkey_patches.rb

@@ -93,19 +93,31 @@ def initialize(exception, example, options={})
           if options.include?(:failure_lines)
             @failure_line_groups = {
               lines: options[:failure_lines],
-              already_colored: false
+              already_colorized: false
             }
           end
         end
 
         # Override to only color uncolored lines in red
-        def colorized_message_lines(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        # and to not color empty lines
+        def colorized_message_lines(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
           lines = failure_line_groups.flat_map do |group|
-            if group[:already_colored]
+            if group[:already_colorized]
               group[:lines]
             else
               group[:lines].map do |line|
-                colorizer.wrap(line, message_color)
+                if line.strip.empty?
+                  line
+                else
+                  indentation = line[/^[ ]+/]
+                  rest = colorizer.wrap(line.sub(/^[ ]+/, ''), message_color)
+
+                  if indentation
+                    indentation + rest
+                  else
+                    rest
+                  end
+                end
               end
             end
           end
@@ -129,33 +141,68 @@ def add_shared_group_lines(lines, colorizer)
         # Considering that `failure_slash_error_lines` is already colored,
         # extract this from the other lines so that they, too, can be colored,
         # later
+        #
+        # TODO: Refactor this somehow
+        #
         def failure_line_groups
-          @failure_line_groups ||= [].tap do |groups|
-            groups << {
-              lines: failure_slash_error_lines,
-              already_colored: true
-            }
+          if defined?(@failure_line_groups)
+            @failure_line_groups
+          else
+            @failure_line_groups = [
+              {
+                lines: failure_slash_error_lines,
+                already_colorized: true
+              }
+            ]
 
             sections = [failure_slash_error_lines, exception_lines]
             separate_groups = (
               sections.any? { |section| section.size > 1 } &&
               !exception_lines.first.empty?
             )
+
             if separate_groups
-              groups << { lines: [''], already_colored: true }
+              @failure_line_groups << { lines: [''], already_colorized: true }
             end
-            already_has_coloration = exception_lines.any? do |line|
-              line.match?(/\e\[\d+m/)
+
+            already_colorized = exception_lines.any? do |line|
+              SuperDiff::Csi.already_colorized?(line)
             end
 
-            groups << {
-              lines: exception_lines[0..0],
-              already_colored: already_has_coloration
-            }
-            groups << {
-              lines: exception_lines[1..-1] + extra_failure_lines,
-              already_colored: true
-            }
+            if already_colorized
+              @failure_line_groups << {
+                lines: exception_lines,
+                already_colorized: true
+              }
+            else
+              locatable_exception_lines =
+                exception_lines.each_with_index.map do |line, index|
+                  { text: line, index: index }
+                end
+
+              boundary_line =
+                locatable_exception_lines.find do |line, index|
+                  line[:text].strip.empty? || line[:text].match?(/^    /)
+                end
+
+              if boundary_line
+                @failure_line_groups << {
+                  lines: exception_lines[0..boundary_line[:index] - 1],
+                  already_colorized: false
+                }
+                @failure_line_groups << {
+                  lines: exception_lines[boundary_line[:index]..-1],
+                  already_colorized: true
+                }
+              else
+                @failure_line_groups << {
+                  lines: exception_lines,
+                  already_colorized: false
+                }
+              end
+            end
+
+            @failure_line_groups
           end
         end
 

spec/integration/rspec/third_party_matcher_spec.rb

@@ -0,0 +1,241 @@
+require "spec_helper"
+
+RSpec.describe "Integration with a third-party matcher", type: :integration do
+  context "when the matcher is used in the positive and fails" do
+    context "when the failure message spans multiple lines" do
+      context "and some of the message is indented" do
+        it "colorizes the non-indented part in red" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expect(:anything).to fail_with_indented_multiline_failure_message
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
+
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(:anything).to fail_with_indented_multiline_failure_message|,
+              newline_before_expectation: true,
+              expectation: proc {
+                red_line   "This is a message that spans multiple lines."
+                red_line   "Here is the next line."
+                plain_line "  This part is indented, for whatever reason. It just kinda keeps"
+                plain_line "  going until we finish saying whatever it is we want to say."
+              }
+            )
+
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
+        end
+      end
+
+      context "and some of the message is not indented" do
+        context "and the message is divided into paragraphs" do
+          it "colorizes the first paragraph in red" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect(:anything).to fail_with_paragraphed_failure_message
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect(:anything).to fail_with_paragraphed_failure_message|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  red_line "This is a message that spans multiple paragraphs."
+                  newline
+                  plain_line "Here is the next paragraph."
+                }
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the message is not divided into paragraphs" do
+          it "colorizes all of the message in red" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect(:anything).to fail_with_non_indented_multiline_failure_message
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect(:anything).to fail_with_non_indented_multiline_failure_message|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  red_line "This is a message that spans multiple lines."
+                  red_line "Here is the next line."
+                }
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the failure message does not span multiple lines" do
+      it "colorizes all of the message in red" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST.strip
+            expect(:anything).to fail_with_singleline_failure_message
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(:anything).to fail_with_singleline_failure_message|,
+            expectation: proc {
+              red_line "This is a message that spans only one line."
+            }
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+
+  context "when the matcher is used in the negative and fails" do
+    context "when the failure message spans multiple lines" do
+      context "and some of the message is indented" do
+        it "colorizes the non-indented part in red" do
+          as_both_colored_and_uncolored do |color_enabled|
+            snippet = <<~TEST.strip
+              expect(:anything).not_to pass_with_indented_multiline_failure_message
+            TEST
+            program = make_plain_test_program(
+              snippet,
+              color_enabled: color_enabled,
+            )
+
+            expected_output = build_expected_output(
+              color_enabled: color_enabled,
+              snippet: %|expect(:anything).not_to pass_with_indented_multiline_failure_message|,
+              newline_before_expectation: true,
+              expectation: proc {
+                red_line   "This is a message that spans multiple lines."
+                red_line   "Here is the next line."
+                plain_line "  This part is indented, for whatever reason. It just kinda keeps"
+                plain_line "  going until we finish saying whatever it is we want to say."
+              }
+            )
+
+            expect(program).
+              to produce_output_when_run(expected_output).
+              in_color(color_enabled)
+          end
+        end
+      end
+
+      context "and some of the message is not indented" do
+        context "and the message is divided into paragraphs" do
+          it "colorizes all of the message in red" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect(:anything).not_to pass_with_paragraphed_failure_message
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect(:anything).not_to pass_with_paragraphed_failure_message|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  red_line "This is a message that spans multiple paragraphs."
+                  newline
+                  plain_line "Here is the next paragraph."
+                }
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+
+        context "and the message is not divided into paragraphs" do
+          it "colorizes all of the message in red" do
+            as_both_colored_and_uncolored do |color_enabled|
+              snippet = <<~TEST.strip
+                expect(:anything).not_to pass_with_non_indented_multiline_failure_message
+              TEST
+              program = make_plain_test_program(
+                snippet,
+                color_enabled: color_enabled,
+              )
+
+              expected_output = build_expected_output(
+                color_enabled: color_enabled,
+                snippet: %|expect(:anything).not_to pass_with_non_indented_multiline_failure_message|,
+                newline_before_expectation: true,
+                expectation: proc {
+                  red_line "This is a message that spans multiple lines."
+                  red_line "Here is the next line."
+                }
+              )
+
+              expect(program).
+                to produce_output_when_run(expected_output).
+                in_color(color_enabled)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the failure message does not span multiple lines" do
+      it "colorizes all of the message in red" do
+        as_both_colored_and_uncolored do |color_enabled|
+          snippet = <<~TEST.strip
+            expect(:anything).not_to pass_with_singleline_failure_message
+          TEST
+          program = make_plain_test_program(
+            snippet,
+            color_enabled: color_enabled,
+          )
+
+          expected_output = build_expected_output(
+            color_enabled: color_enabled,
+            snippet: %|expect(:anything).not_to pass_with_singleline_failure_message|,
+            expectation: proc {
+              red_line "This is a message that spans only one line."
+            }
+          )
+
+          expect(program).
+            to produce_output_when_run(expected_output).
+            in_color(color_enabled)
+        end
+      end
+    end
+  end
+end