super_diff 0.2.0 → 0.5.0

data/lib/super_diff/rspec/matcher_text_builders/match.rb

@@ -3,7 +3,7 @@ module SuperDiff
     module MatcherTextBuilders
       class Match < Base
         def initialize(expected_captures:, **rest)
-          super(rest)
+          super(**rest)
           @expected_captures = expected_captures
         end
 

data/lib/super_diff/rspec/matcher_text_builders/raise_error.rb

@@ -5,7 +5,19 @@ module SuperDiff
         protected
 
         def actual_phrase
-          "Expected raised exception"
+          if actual
+            "Expected raised exception"
+          else
+            "Expected"
+          end
+        end
+
+        def add_actual_value
+          if actual
+            template.add_text_in_color(beta_color) { actual }
+          else
+            template.add_text("block")
+          end
         end
       end
     end

data/lib/super_diff/rspec/matcher_text_builders/respond_to.rb

@@ -9,7 +9,7 @@ module SuperDiff
           unlimited_arguments:,
           **rest
         )
-          super(rest)
+          super(**rest)
           @expected_arity = expected_arity
           @arbitrary_keywords = arbitrary_keywords
           @expected_keywords = expected_keywords

data/lib/super_diff/rspec/matcher_text_template.rb

@@ -3,7 +3,7 @@ module SuperDiff
     class MatcherTextTemplate
       MAX_LINE_LENGTH = 100
 
-      def self.generate(&block)
+      def self.render(&block)
         new(&block).to_s
       end
 

data/lib/super_diff/rspec/monkey_patches.rb

@@ -91,21 +91,35 @@ module RSpec
           @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_colored: false
-            }
+            @failure_line_groups = [
+              {
+                lines: options[:failure_lines],
+                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 +143,68 @@ module RSpec
         # 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_colorized = exception_lines.any? do |line|
+              SuperDiff::Csi.already_colorized?(line)
             end
-            already_has_coloration = exception_lines.any? do |line|
-              line.match?(/\e\[\d+m/)
+
+            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
 
-            groups << {
-              lines: exception_lines[0..0],
-              already_colored: already_has_coloration
-            }
-            groups << {
-              lines: exception_lines[1..-1] + extra_failure_lines,
-              already_colored: true
-            }
+            @failure_line_groups
           end
         end
 
@@ -204,6 +253,11 @@ module RSpec
 
   module Support
     class ObjectFormatter
+      # Override to use our formatting algorithm
+      def self.format(value)
+        SuperDiff::ObjectInspection.inspect(value, as_single_line: true)
+      end
+
       # Override to use our formatting algorithm
       def format(value)
         SuperDiff::ObjectInspection.inspect(value, as_single_line: true)
@@ -303,20 +357,6 @@ module RSpec
         end)
       end
 
-      class BeTruthy
-        prepend SuperDiff::RSpec::AugmentedMatcher
-
-        prepend(Module.new do
-          def expected_action_for_matcher_text
-            "be"
-          end
-
-          def expected_for_matcher_text
-            "truthy"
-          end
-        end)
-      end
-
       class BeFalsey
         prepend SuperDiff::RSpec::AugmentedMatcher
 
@@ -375,12 +415,18 @@ module RSpec
         end)
       end
 
-      class Eq
+      class BeTruthy
         prepend SuperDiff::RSpec::AugmentedMatcher
-      end
 
-      class Equal
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        prepend(Module.new do
+          def expected_action_for_matcher_text
+            "be"
+          end
+
+          def expected_for_matcher_text
+            "truthy"
+          end
+        end)
       end
 
       class ContainExactly
@@ -405,72 +451,12 @@ module RSpec
         end)
       end
 
-      class Include
+      class Eq
         prepend SuperDiff::RSpec::AugmentedMatcher
-
-        prepend(Module.new do
-          # Override this method so that the differ knows that this is a partial
-          # array or hash
-          def expected_for_diff
-            if expecteds.all? { |item| item.is_a?(Hash) }
-              matchers.a_collection_including(expecteds.first)
-            else
-              matchers.a_collection_including(*expecteds)
-            end
-          end
-
-          private
-
-          # Override to capitalize message and add period at end
-          def build_failure_message(negated:)
-            message = super
-
-            if actual.respond_to?(:include?)
-              message
-            elsif message.end_with?(".")
-              message.sub("\.$", ", ") + "but it does not respond to `include?`."
-            else
-              message + "\n\nBut it does not respond to `include?`."
-            end
-          end
-
-          # Override to use readable_list_of
-          def expected_for_description
-            readable_list_of(expecteds).lstrip
-          end
-
-          # Override to use readable_list_of
-          def expected_for_failure_message
-            # TODO: Switch to using @divergent_items and handle this in the text
-            # builder
-            readable_list_of(@divergent_items).lstrip
-          end
-
-          # 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(/ \}$/, ')')
-            else
-              super
-            end
-          end
-        end)
       end
 
-      class Match
+      class Equal
         prepend SuperDiff::RSpec::AugmentedMatcher
-
-        prepend(Module.new do
-          def matcher_text_builder_class
-            SuperDiff::RSpec::MatcherTextBuilders::Match
-          end
-
-          def matcher_text_builder_args
-            super.merge(expected_captures: @expected_captures)
-          end
-        end)
       end
 
       class HaveAttributes
@@ -550,33 +536,113 @@ module RSpec
         end
       end
 
-      class RespondTo
+      class Has
         prepend SuperDiff::RSpec::AugmentedMatcher
 
         prepend(Module.new do
+          def actual_for_matcher_text
+            actual
+          end
+
+          def expected_for_matcher_text
+            "#{predicate}#{failure_message_args_description}"
+          end
+
+          def expected_action_for_matcher_text
+            "return true for"
+          end
+
           def matcher_text_builder_class
-            SuperDiff::RSpec::MatcherTextBuilders::RespondTo
+            SuperDiff::RSpec::MatcherTextBuilders::HavePredicate
           end
 
           def matcher_text_builder_args
             super.merge(
-              expected_arity: @expected_arity,
-              arbitrary_keywords: @arbitrary_keywords,
-              expected_keywords: @expected_keywords,
-              unlimited_arguments: @unlimited_arguments
+              predicate_accessible: predicate_accessible?,
+              private_predicate: private_predicate?
             )
           end
+        end)
+      end
 
+      class Include
+        prepend SuperDiff::RSpec::AugmentedMatcher
+
+        prepend(Module.new do
+          # Override this method so that the differ knows that this is a partial
+          # array or hash
+          def expected_for_diff
+            if expecteds.all? { |item| item.is_a?(Hash) }
+              matchers.a_collection_including(expecteds.first)
+            else
+              matchers.a_collection_including(*expecteds)
+            end
+          end
+
+          private
+
+          # Override to capitalize message and add period at end
+          def build_failure_message(negated:)
+            message = super
+
+            if actual.respond_to?(:include?)
+              message
+            elsif message.end_with?(".")
+              message.sub("\.$", ", ") + "but it does not respond to `include?`."
+            else
+              message + "\n\nBut it does not respond to `include?`."
+            end
+          end
+
+          # Override to use readable_list_of
           def expected_for_description
-            @names
+            readable_list_of(expecteds).lstrip
           end
 
+          # Override to use readable_list_of
           def expected_for_failure_message
-            @failing_method_names
+            # TODO: Switch to using @divergent_items and handle this in the text
+            # builder
+            readable_list_of(@divergent_items).lstrip
+          end
+
+          # 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(/ \}$/, ')')
+            else
+              super
+            end
+          end
+        end)
+      end
+
+      class Match
+        prepend SuperDiff::RSpec::AugmentedMatcher
+
+        prepend(Module.new do
+          def matcher_text_builder_class
+            SuperDiff::RSpec::MatcherTextBuilders::Match
+          end
+
+          def matcher_text_builder_args
+            super.merge(expected_captures: @expected_captures)
           end
         end)
       end
 
+      class MatchArray < ContainExactly
+        def expected_for_diff
+          matchers.an_array_matching(expected)
+        end
+
+        def expected_action_for_matcher_text
+          "match array with"
+        end
+      end
+
       class RaiseError
         prepend SuperDiff::RSpec::AugmentedMatcher
 
@@ -588,12 +654,16 @@ module RSpec
           end
 
           def actual_for_diff
-            @actual_error.message
+            if @actual_error
+              @actual_error.message
+            end
           end
 
           def expected_for_matcher_text
             if @expected_message
-              "#<#{@expected_error.name} #{@expected_message.inspect}>"
+              "#<#{@expected_error.name} #{description_of(@expected_message)}>"
+            elsif @expected_error.is_a? Regexp
+              "#<Exception #{description_of(@expected_error)}>"
             else
               "#<#{@expected_error.name}>"
             end
@@ -608,7 +678,11 @@ module RSpec
           end
 
           def expected_action_for_failure_message
-            "match"
+            if @actual_error
+              "match"
+            else
+              "raise error"
+            end
           end
 
           def matcher_text_builder_class
@@ -617,9 +691,46 @@ module RSpec
         end)
 
         def self.matcher_name
-          'raise error'
+          "raise error"
         end
       end
+
+      class RespondTo
+        prepend SuperDiff::RSpec::AugmentedMatcher
+
+        prepend(Module.new do
+          def initialize(*)
+            super
+            @failing_method_names = nil
+          end
+
+          def matcher_text_builder_class
+            SuperDiff::RSpec::MatcherTextBuilders::RespondTo
+          end
+
+          def matcher_text_builder_args
+            super.merge(
+              expected_arity: @expected_arity,
+              arbitrary_keywords: @arbitrary_keywords,
+              expected_keywords: @expected_keywords,
+              unlimited_arguments: @unlimited_arguments
+            )
+          end
+
+          def expected_for_description
+            @names
+          end
+
+          def expected_for_failure_message
+            @failing_method_names
+          end
+        end)
+      end
+    end
+
+    def match_array(items)
+      BuiltIn::MatchArray.new(items)
     end
+    alias_matcher :an_array_matching, :match_array
   end
 end