super_diff 0.9.0 → 0.11.0

data/lib/super_diff/rspec/monkey_patches.rb

@@ -60,19 +60,22 @@ module RSpec
             if code_or_symbol
               if (config_method = config_colors_to_methods[code_or_symbol])
                 console_code_for RSpec.configuration.__send__(config_method)
-              elsif RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES.key?(code_or_symbol)
+              elsif RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES.key?(
+                    code_or_symbol
+                  )
                 code_or_symbol
               else
-                RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.fetch(code_or_symbol) do
+                RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.fetch(
                   code_or_symbol
-                end
+                ) { code_or_symbol }
               end
             end
           end
 
           # Patch so it does not apply a color if code_or_symbol is nil
           def wrap(text, code_or_symbol)
-            if RSpec.configuration.color_enabled? && code = console_code_for(code_or_symbol)
+            if SuperDiff.configuration.color_enabled? &&
+                 code = console_code_for(code_or_symbol)
               "\e[#{code}m#{text}\e[0m"
             else
               text
@@ -86,50 +89,56 @@ module RSpec
         RESET_CODE = "\e[0m"
 
         SuperDiff.insert_overrides(self) do
-          def initialize(exception, example, options={})
-            @exception               = exception
-            @example                 = example
-            @message_color           = options.fetch(:message_color)          { RSpec.configuration.failure_color }
-            @description             = options.fetch(:description)            { example.full_description }
-            @detail_formatter        = options.fetch(:detail_formatter)       { Proc.new {} }
-            @extra_detail_formatter  = options.fetch(:extra_detail_formatter) { Proc.new {} }
-            @backtrace_formatter     = options.fetch(:backtrace_formatter)    { RSpec.configuration.backtrace_formatter }
-            @indentation             = options.fetch(:indentation, 2)
-            @skip_shared_group_trace = options.fetch(:skip_shared_group_trace, false)
+          def initialize(exception, example, options = {})
+            @exception = exception
+            @example = example
+            @message_color =
+              options.fetch(:message_color) do
+                RSpec.configuration.failure_color
+              end
+            @description =
+              options.fetch(:description) { example.full_description }
+            @detail_formatter = options.fetch(:detail_formatter) { Proc.new {} }
+            @extra_detail_formatter =
+              options.fetch(:extra_detail_formatter) { Proc.new {} }
+            @backtrace_formatter =
+              options.fetch(:backtrace_formatter) do
+                RSpec.configuration.backtrace_formatter
+              end
+            @indentation = options.fetch(:indentation, 2)
+            @skip_shared_group_trace =
+              options.fetch(:skip_shared_group_trace, false)
             # Patch to convert options[:failure_lines] to groups
             if options.include?(:failure_lines)
               @failure_line_groups = [
-                {
-                  lines: options[:failure_lines],
-                  already_colorized: false
-                }
+                { lines: options[:failure_lines], already_colorized: false }
               ]
             end
           end
 
           # Override to only color uncolored lines in red
           # 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_colorized]
-                group[:lines]
-              else
-                group[:lines].map do |line|
-                  if line.strip.empty?
-                    line
-                  else
-                    indentation = line[/^[ ]+/]
-                    rest = colorizer.wrap(line.sub(/^[ ]+/, ''), message_color)
-
-                    if indentation
-                      indentation + rest
+          def colorized_message_lines(
+            colorizer = ::RSpec::Core::Formatters::ConsoleCodes
+          )
+            lines =
+              failure_line_groups.flat_map do |group|
+                if group[:already_colorized]
+                  group[:lines]
+                else
+                  group[:lines].map do |line|
+                    if line.strip.empty?
+                      line
                     else
-                      rest
+                      indentation = line[/^[ ]+/]
+                      rest =
+                        colorizer.wrap(line.sub(/^[ ]+/, ""), message_color)
+
+                      indentation ? indentation + rest : rest
                     end
                   end
                 end
               end
-            end
 
             add_shared_group_lines(lines, colorizer)
           end
@@ -158,25 +167,24 @@ module RSpec
               @failure_line_groups
             else
               @failure_line_groups = [
-                {
-                  lines: failure_slash_error_lines,
-                  already_colorized: true
-                }
+                { 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?
-              )
+              separate_groups =
+                (
+                  sections.any? { |section| section.size > 1 } &&
+                    !exception_lines.first.empty?
+                )
 
               if separate_groups
-                @failure_line_groups << { lines: [''], already_colorized: true }
+                @failure_line_groups << { lines: [""], already_colorized: true }
               end
 
-              already_colorized = exception_lines.any? do |line|
-                SuperDiff::Csi.already_colorized?(line)
-              end
+              already_colorized =
+                exception_lines.any? do |line|
+                  SuperDiff::Csi.already_colorized?(line)
+                end
 
               if already_colorized
                 @failure_line_groups << {
@@ -210,7 +218,10 @@ module RSpec
                   }
                 end
               end
-
+              @failure_line_groups << {
+                lines: extra_failure_lines,
+                already_colorized: true
+              }
               @failure_line_groups
             end
           end
@@ -225,15 +236,32 @@ module RSpec
               lines[0] = failure_slash_error + lines[0].strip
             else
               least_indentation = SnippetExtractor.least_indentation_from(lines)
-              lines = lines.map do |line|
-                line.sub(/^#{least_indentation}/, '  ')
-              end
+              lines =
+                lines.map { |line| line.sub(/^#{least_indentation}/, "  ") }
               lines.unshift(failure_slash_error)
             end
 
             lines
           end
 
+          # Override to ensure that each item in the array returned is one and
+          # only one line and doesn't contain any newline characters
+          def extra_failure_lines
+            @extra_failure_lines ||=
+              begin
+                original_lines = Array(example.metadata[:extra_failure_lines])
+                normalized_lines =
+                  original_lines.flat_map { |line| line.split("\n") }
+                unless normalized_lines.empty?
+                  unless normalized_lines.first == ""
+                    normalized_lines.unshift("")
+                  end
+                  normalized_lines.push("") unless normalized_lines.last == ""
+                end
+                normalized_lines
+              end
+          end
+
           # Exclude this file from being included in backtraces, so that the
           # SnippetExtractor prints the right thing
           def find_failed_line
@@ -243,7 +271,8 @@ module RSpec
             exception_backtrace.find do |line|
               next unless (line_path = line[/(.+?):(\d+)(|:\d+)/, 1])
               path = File.expand_path(line_path)
-              path != __FILE__ && (loaded_spec_files.include?(path) || path =~ line_regex)
+              path != __FILE__ &&
+                (loaded_spec_files.include?(path) || path =~ line_regex)
             end || exception_backtrace.first
           end
         end
@@ -286,36 +315,38 @@ module RSpec
         def from(expected)
           return expected if self === expected
 
-          text =
-            colorizer.wrap("Diff:", SuperDiff.configuration.header_color) +
-            "\n\n" +
-            colorizer.wrap(
-              "┌ (Key) ──────────────────────────┐",
-              SuperDiff.configuration.border_color
-            ) +
-            "\n" +
-            colorizer.wrap("│ ", SuperDiff.configuration.border_color) +
-            colorizer.wrap(
-              "‹-› in expected, not in actual",
-              SuperDiff.configuration.expected_color
-            ) +
-            colorizer.wrap("  │", SuperDiff.configuration.border_color) +
-            "\n" +
-            colorizer.wrap("│ ", SuperDiff.configuration.border_color) +
-            colorizer.wrap(
-              "‹+› in actual, not in expected",
-              SuperDiff.configuration.actual_color
-            ) +
-            colorizer.wrap("  │", SuperDiff.configuration.border_color) +
-            "\n" +
-            colorizer.wrap("│ ", SuperDiff.configuration.border_color) +
-            "‹ › in both expected and actual" +
-            colorizer.wrap(" │", SuperDiff.configuration.border_color) +
-            "\n" +
-            colorizer.wrap(
-              "└─────────────────────────────────┘",
-              SuperDiff.configuration.border_color
-            )
+          text = colorizer.wrap("Diff:", SuperDiff.configuration.header_color)
+
+          if SuperDiff.configuration.key_enabled?
+            text +=
+              "\n\n" +
+                colorizer.wrap(
+                  "┌ (Key) ──────────────────────────┐",
+                  SuperDiff.configuration.border_color
+                ) + "\n" +
+                colorizer.wrap("│ ", SuperDiff.configuration.border_color) +
+                colorizer.wrap(
+                  "‹-› in expected, not in actual",
+                  SuperDiff.configuration.expected_color
+                ) +
+                colorizer.wrap("  │", SuperDiff.configuration.border_color) +
+                "\n" +
+                colorizer.wrap("│ ", SuperDiff.configuration.border_color) +
+                colorizer.wrap(
+                  "‹+› in actual, not in expected",
+                  SuperDiff.configuration.actual_color
+                ) +
+                colorizer.wrap("  │", SuperDiff.configuration.border_color) +
+                "\n" +
+                colorizer.wrap("│ ", SuperDiff.configuration.border_color) +
+                "‹ › in both expected and actual" +
+                colorizer.wrap(" │", SuperDiff.configuration.border_color) +
+                "\n" +
+                colorizer.wrap(
+                  "└─────────────────────────────────┘",
+                  SuperDiff.configuration.border_color
+                )
+          end
 
           new([[expected, text]])
         end
@@ -330,22 +361,21 @@ module RSpec
         def message_with_diff(message, differ, actual)
           diff = diffs(differ, actual)
 
-          if diff.empty?
-            message
-          else
-            "#{message.rstrip}\n\n#{diff}"
-          end
+          diff.empty? ? message : "#{message.rstrip}\n\n#{diff}"
         end
 
         private
 
         # Add extra line breaks in between diffs, and colorize the word "Diff"
         def diffs(differ, actual)
-          @expected_list.map do |(expected, diff_label)|
-            diff = differ.diff(actual, expected)
-            next if diff.strip.empty?
-            diff_label + diff
-          end.compact.join("\n\n")
+          @expected_list
+            .map do |(expected, diff_label)|
+              diff = differ.diff(actual, expected)
+              next if diff.strip.empty?
+              diff_label + diff
+            end
+            .compact
+            .join("\n\n")
         end
       end
     end
@@ -366,7 +396,7 @@ module RSpec
 
         SuperDiff.insert_overrides(self) do
           def expected_action_for_matcher_text
-            if [:==, :===, :=~].include?(@operator)
+            if %i[== === =~].include?(@operator)
               "#{@operator}"
             else
               "be #{@operator}"
@@ -415,7 +445,7 @@ module RSpec
             if SuperDiff::RSpec.rspec_version < "3.10"
               expected
             else
-              predicate.to_s.chomp('?')
+              predicate.to_s.chomp("?")
             end
           end
 
@@ -507,7 +537,7 @@ module RSpec
 
           # Override to use (...) as delimiters rather than {...}
           def expected_for_matcher_text
-            super.sub(/^\{ /, '(').gsub(/ \}$/, ')')
+            super.sub(/^\{ /, "(").gsub(/ \}$/, ")")
           end
 
           # Override so that the differ knows that this is a partial object
@@ -538,14 +568,17 @@ module RSpec
           # Override this method to skip non-existent attributes, and to use
           # public_send
           def cache_all_values
-            @values = @expected.keys.inject({}) do |hash, attribute_key|
-              if @actual.respond_to?(attribute_key)
-                actual_value = @actual.public_send(attribute_key)
-                hash.merge(attribute_key => actual_value)
-              else
-                hash
-              end
-            end
+            @values =
+              @expected
+                .keys
+                .inject({}) do |hash, attribute_key|
+                  if @actual.respond_to?(attribute_key)
+                    actual_value = @actual.public_send(attribute_key)
+                    hash.merge(attribute_key => actual_value)
+                  else
+                    hash
+                  end
+                end
           end
 
           def actual_has_attribute?(attribute_key, attribute_value)
@@ -624,7 +657,8 @@ module RSpec
             if actual.respond_to?(:include?)
               message
             elsif message.end_with?(".")
-              message.sub("\.$", ", ") + "but it does not respond to `include?`."
+              message.sub("\.$", ", ") +
+                "but it does not respond to `include?`."
             else
               message + "\n\nBut it does not respond to `include?`."
             end
@@ -649,9 +683,10 @@ module RSpec
           # Update to use (...) as delimiter instead of {...}
           def readable_list_of(items)
             if items && items.all? { |item| item.is_a?(Hash) }
-              description_of(items.inject(:merge)).
-                sub(/^\{ /, '(').
-                sub(/ \}$/, ')')
+              description_of(items.inject(:merge)).sub(/^\{ /, "(").sub(
+                / \}$/,
+                ")"
+              )
             else
               super
             end
@@ -687,25 +722,36 @@ module RSpec
         SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
         SuperDiff.insert_overrides(self) do
+          def expected_action_for_description
+            "raise"
+          end
+
           def actual_for_matcher_text
             if @actual_error
               "#<#{@actual_error.class.name} #{@actual_error.message.inspect}>"
+            else
+              "exception-free block"
             end
           end
 
           def actual_for_diff
-            if @actual_error
-              @actual_error.message
-            end
+            @actual_error.message if @actual_error
           end
 
           def expected_for_matcher_text
-            if @expected_message
-              "#<#{@expected_error.name} #{description_of(@expected_message)}>"
-            elsif @expected_error.is_a? Regexp
-              "#<Exception #{description_of(@expected_error)}>"
+            case @expected_message
+            when nil
+              if RSpec::Matchers.is_a_describable_matcher?(@expected_error)
+                description_of(@expected_error)
+              elsif @expected_error.is_a?(Regexp)
+                "a kind of Exception with message matching #{description_of(@expected_error)}"
+              else
+                "a kind of #{@expected_error}"
+              end
+            when Regexp
+              "#{described_expected_error} with message matching #{description_of(@expected_message)}"
             else
-              "#<#{@expected_error.name}>"
+              "#{described_expected_error} with message #{description_of(@expected_message)}"
             end
           end
 
@@ -718,16 +764,22 @@ module RSpec
           end
 
           def expected_action_for_failure_message
-            if @actual_error
-              "match"
-            else
-              "raise error"
-            end
+            @actual_error ? "match" : "raise"
           end
 
           def matcher_text_builder_class
             SuperDiff::RSpec::MatcherTextBuilders::RaiseError
           end
+
+          private
+
+          def described_expected_error
+            if @expected_error.is_a?(Class)
+              "a kind of #{@expected_error}"
+            else
+              description_of(@expected_error)
+            end
+          end
         end
 
         def self.matcher_name
@@ -770,13 +822,18 @@ module RSpec
 
     SuperDiff.insert_overrides(self) do
       def self.prepended(base)
-        base.class_eval do
-          alias_matcher :an_array_matching, :match_array
-        end
+        base.class_eval { alias_matcher :an_array_matching, :match_array }
       end
 
       def match_array(items)
-        BuiltIn::MatchArray.new(items.is_a?(String) ? [items] : items)
+        # This is a bit strange, but this is fundamentally different from
+        # splatting `items` in the argument list. It's functionally equivalent
+        # to, though not quite the same as:
+        #
+        #     items.is_a?(Array) ? items : [items]
+        #
+        items = *items
+        BuiltIn::MatchArray.new(items)
       end
     end
   end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/collection_containing_exactly.rb

@@ -8,17 +8,24 @@ module SuperDiff
           end
 
           def call
-            SuperDiff::ObjectInspection::InspectionTree.new do
-              as_lines_when_rendering_to_lines(collection_bookend: :open) do
-                add_text "#<a collection containing exactly ("
+            SuperDiff::ObjectInspection::InspectionTree.new do |t1|
+              # stree-ignore
+              t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t2|
+                t2.add_text "#<a collection containing exactly ("
               end
 
-              nested do |aliased_matcher|
-                insert_array_inspection_of(aliased_matcher.expected)
+              # stree-ignore
+              t1.nested do |t2|
+                t2.insert_array_inspection_of(object.expected)
               end
 
-              as_lines_when_rendering_to_lines(collection_bookend: :close) do
-                add_text ")>"
+              # stree-ignore
+              t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t2|
+                t2.add_text ")>"
               end
             end
           end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/collection_including.rb

@@ -4,26 +4,34 @@ module SuperDiff
       module InspectionTreeBuilders
         class CollectionIncluding < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
           def self.applies_to?(value)
-            SuperDiff::RSpec.a_collection_including_something?(value) || SuperDiff::RSpec.array_including_something?(value)
+            SuperDiff::RSpec.a_collection_including_something?(value) ||
+              SuperDiff::RSpec.array_including_something?(value)
           end
 
           def call
-            SuperDiff::ObjectInspection::InspectionTree.new do
-              as_lines_when_rendering_to_lines(collection_bookend: :open) do
-                add_text "#<a collection including ("
+            SuperDiff::ObjectInspection::InspectionTree.new do |t1|
+              # stree-ignore
+              t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t2|
+                t2.add_text "#<a collection including ("
               end
 
-              nested do |value|
-                array = if SuperDiff::RSpec.a_collection_including_something?(value)
-                          value.expecteds
-                        else
-                          value.instance_variable_get(:@expected)
-                        end
-                insert_array_inspection_of(array)
+              t1.nested do |t2|
+                if SuperDiff::RSpec.a_collection_including_something?(object)
+                  t2.insert_array_inspection_of(object.expecteds)
+                else
+                  t2.insert_array_inspection_of(
+                    object.instance_variable_get(:@expected)
+                  )
+                end
               end
 
-              as_lines_when_rendering_to_lines(collection_bookend: :close) do
-                add_text ")>"
+              # stree-ignore
+              t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t2|
+                t2.add_text ")>"
               end
             end
           end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/double.rb

@@ -8,53 +8,51 @@ module SuperDiff
           end
 
           def call
-            builder = self
-            empty = -> { empty? }
-            nonempty = -> { !empty? }
-
-            SuperDiff::ObjectInspection::InspectionTree.new do
-              only_when empty do
-                as_lines_when_rendering_to_lines do
-                  add_text do |object|
-                    inspected_class = builder.inspected_class
-                    inspected_name = builder.inspected_name
-                    "#<#{inspected_class} #{inspected_name}>"
-                  end
+            SuperDiff::ObjectInspection::InspectionTree.new do |t1|
+              t1.only_when method(:empty?) do |t2|
+                t2.as_lines_when_rendering_to_lines do |t3|
+                  t3.add_text("#<#{inspected_class} #{inspected_name}>")
                 end
               end
 
-              only_when nonempty do
-                as_lines_when_rendering_to_lines(collection_bookend: :open) do
-                  add_text do |object|
-                    inspected_class = builder.inspected_class
-                    inspected_name = builder.inspected_name
-                    "#<#{inspected_class} #{inspected_name}"
-                  end
+              t1.only_when method(:nonempty?) do |t2|
+                t2.as_lines_when_rendering_to_lines(
+                  collection_bookend: :open
+                ) do |t3|
+                  t3.add_text("#<#{inspected_class} #{inspected_name}")
 
-                  when_rendering_to_lines do
-                    add_text " {"
+                  # stree-ignore
+                  t3.when_rendering_to_lines do |t4|
+                    t4.add_text " {"
                   end
                 end
 
-                when_rendering_to_string do
-                  add_text " "
+                # stree-ignore
+                t2.when_rendering_to_string do |t3|
+                  t3.add_text " "
                 end
 
-                nested do |object|
-                  insert_hash_inspection_of(builder.doubled_methods)
+                # stree-ignore
+                t2.nested do |t3|
+                  t3.insert_hash_inspection_of doubled_methods
                 end
 
-                as_lines_when_rendering_to_lines(collection_bookend: :close) do
-                  when_rendering_to_lines do
-                    add_text "}"
+                t2.as_lines_when_rendering_to_lines(
+                  collection_bookend: :close
+                ) do |t3|
+                  # stree-ignore
+                  t3.when_rendering_to_lines do |t4|
+                    t4.add_text "}"
                   end
 
-                  add_text ">"
+                  t3.add_text ">"
                 end
               end
             end
           end
 
+          private
+
           def empty?
             doubled_methods.empty?
           end
@@ -85,16 +83,17 @@ module SuperDiff
           end
 
           def doubled_methods
-            @_doubled_methods ||= doubled_method_names.reduce({}) do |hash, key|
-              hash.merge(key => object.public_send(key))
-            end
+            @_doubled_methods ||=
+              doubled_method_names.reduce({}) do |hash, key|
+                hash.merge(key => object.public_send(key))
+              end
           end
 
           def doubled_method_names
-            object.
-              __send__(:__mock_proxy).
-              instance_variable_get("@method_doubles").
-              keys
+            object
+              .__send__(:__mock_proxy)
+              .instance_variable_get("@method_doubles")
+              .keys
           end
         end
       end