super_diff 0.5.3 → 0.8.0

data/lib/super_diff/rspec/differs/collection_including.rb

@@ -3,8 +3,10 @@ module SuperDiff
     module Differs
       class CollectionIncluding < SuperDiff::Differs::Array
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.a_collection_including_something?(expected) &&
-            actual.is_a?(::Array)
+          (
+            SuperDiff::RSpec.a_collection_including_something?(expected) ||
+            SuperDiff::RSpec.array_including_something?(expected)
+          ) && actual.is_a?(::Array)
         end
 
         private

data/lib/super_diff/rspec/differs/hash_including.rb

@@ -3,8 +3,10 @@ module SuperDiff
     module Differs
       class HashIncluding < SuperDiff::Differs::Hash
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.a_hash_including_something?(expected) &&
-            actual.is_a?(::Hash)
+          (
+            SuperDiff::RSpec.a_hash_including_something?(expected) ||
+            SuperDiff::RSpec.hash_including_something?(expected)
+          ) && actual.is_a?(::Hash)
         end
 
         private

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

@@ -45,12 +45,12 @@ module SuperDiff
         def add_extra_after_error
         end
 
-        def beta_color
-          SuperDiff::COLORS.fetch(:beta)
+        def actual_color
+          SuperDiff.configuration.actual_color
         end
 
-        def alpha_color
-          SuperDiff::COLORS.fetch(:alpha)
+        def expected_color
+          SuperDiff.configuration.expected_color
         end
 
         private
@@ -91,7 +91,7 @@ module SuperDiff
         end
 
         def add_actual_value
-          template.add_text_in_color(beta_color) { actual }
+          template.add_text_in_color(actual_color) { actual }
         end
 
         def expected_section
@@ -110,7 +110,7 @@ module SuperDiff
           else
             template.add_text " "
             template.add_text_in_color(
-              alpha_color,
+              expected_color,
               expected_for_failure_message,
             )
           end
@@ -121,7 +121,7 @@ module SuperDiff
             add_expected_value_to(template, expected_for_description)
           else
             template.add_text " "
-            template.add_text_in_color(alpha_color, expected_for_description)
+            template.add_text_in_color(expected_color, expected_for_description)
           end
         end
 

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

@@ -26,12 +26,12 @@ module SuperDiff
           end
         end
 
-        def beta_color
+        def actual_color
           :yellow
         end
 
         def add_actual_value
-          template.add_text_in_color(beta_color) do
+          template.add_text_in_color(actual_color) do
             description_of(actual)
           end
         end
@@ -39,12 +39,12 @@ module SuperDiff
         def add_expected_value_to_failure_message(template)
           template.add_text " "
           template.add_text_in_color(
-            alpha_color,
+            expected_color,
             "#{expected_for_failure_message}?",
           )
           template.add_text " or "
           template.add_text_in_color(
-            alpha_color,
+            expected_color,
             "#{expected_for_failure_message}s?",
           )
         end
@@ -52,12 +52,12 @@ module SuperDiff
         def add_expected_value_to_description(template)
           template.add_text " "
           template.add_text_in_color(
-            alpha_color,
+            expected_color,
             "`#{expected_for_description}?`",
           )
           template.add_text " or "
           template.add_text_in_color(
-            alpha_color,
+            expected_color,
             "`#{expected_for_description}s?`",
           )
         end

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

@@ -6,7 +6,7 @@ module SuperDiff
 
         def add_expected_value_to(template, expected)
           template.add_text " "
-          template.add_list_in_color(alpha_color, expected)
+          template.add_list_in_color(expected_color, expected)
         end
       end
     end

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

@@ -20,12 +20,12 @@ module SuperDiff
           end
         end
 
-        def beta_color
+        def actual_color
           :yellow
         end
 
         def add_actual_value
-          template.add_text_in_color(beta_color) do
+          template.add_text_in_color(actual_color) do
             description_of(actual)
           end
         end
@@ -33,7 +33,7 @@ module SuperDiff
         def add_expected_value_to_failure_message(template)
           template.add_text " "
           template.add_text_in_color(
-            alpha_color,
+            expected_color,
             expected_for_failure_message,
           )
         end
@@ -41,7 +41,7 @@ module SuperDiff
         def add_expected_value_to_description(template)
           template.add_text " "
           template.add_text_in_color(
-            alpha_color,
+            expected_color,
             "`#{expected_for_description}`",
           )
         end

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

@@ -14,7 +14,7 @@ module SuperDiff
 
         def add_actual_value
           if actual
-            template.add_text_in_color(beta_color) { actual }
+            template.add_text_in_color(actual_color) { actual }
           else
             template.add_text("block")
           end

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

@@ -20,7 +20,7 @@ module SuperDiff
 
         def add_expected_value_to(template, expected)
           template.add_text " "
-          template.add_list_in_color(alpha_color, expected)
+          template.add_list_in_color(expected_color, expected)
         end
 
         def add_extra_after_expected_to(template)
@@ -57,14 +57,14 @@ module SuperDiff
 
         def add_arity_clause_to(template)
           template.add_text " with "
-          template.add_text_in_color alpha_color, expected_arity
+          template.add_text_in_color expected_color, expected_arity
           template.add_text " "
           template.add_text pluralize("argument", expected_arity)
         end
 
         def add_arbitrary_keywords_clause_to(template)
           template.add_text " with "
-          template.add_text_in_color alpha_color, "any"
+          template.add_text_in_color expected_color, "any"
           template.add_text " keywords"
         end
 
@@ -72,7 +72,7 @@ module SuperDiff
           template.add_text " with "
           template.add_text pluralize("keyword", expected_keywords.length)
           template.add_text " "
-          template.add_list_in_color alpha_color, expected_keywords
+          template.add_list_in_color expected_color, expected_keywords
         end
 
         def add_unlimited_arguments_clause_to(template)
@@ -82,7 +82,7 @@ module SuperDiff
             template.add_text " with "
           end
 
-          template.add_text_in_color alpha_color, "unlimited"
+          template.add_text_in_color expected_color, "unlimited"
           template.add_text " arguments"
         end
 

data/lib/super_diff/rspec/monkey_patches.rb

@@ -12,34 +12,38 @@ require "rspec/matchers/built_in/match"
 
 module RSpec
   module Expectations
-    def self.differ
-      SuperDiff::RSpec::Differ
+    SuperDiff.insert_singleton_overrides(self) do
+      def differ
+        SuperDiff::RSpec::Differ
+      end
     end
 
     module ExpectationHelper
-      def self.handle_failure(matcher, message, failure_message_method)
-        message = message.call if message.respond_to?(:call)
-        message ||= matcher.__send__(failure_message_method)
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          # Look for expected_for_diff and actual_for_diff if possible
-          expected =
-            if matcher.respond_to?(:expected_for_diff)
-              matcher.expected_for_diff
-            else
-              matcher.expected
-            end
+      SuperDiff.insert_singleton_overrides(self) do
+        def handle_failure(matcher, message, failure_message_method)
+          message = message.call if message.respond_to?(:call)
+          message ||= matcher.__send__(failure_message_method)
+
+          if matcher.respond_to?(:diffable?) && matcher.diffable?
+            # Look for expected_for_diff and actual_for_diff if possible
+            expected =
+              if matcher.respond_to?(:expected_for_diff)
+                matcher.expected_for_diff
+              else
+                matcher.expected
+              end
 
-          actual =
-            if matcher.respond_to?(:actual_for_diff)
-              matcher.actual_for_diff
-            else
-              matcher.actual
-            end
+            actual =
+              if matcher.respond_to?(:actual_for_diff)
+                matcher.actual_for_diff
+              else
+                matcher.actual
+              end
 
-          ::RSpec::Expectations.fail_with(message, expected, actual)
-        else
-          ::RSpec::Expectations.fail_with(message)
+            ::RSpec::Expectations.fail_with(message, expected, actual)
+          else
+            ::RSpec::Expectations.fail_with(message)
+          end
         end
       end
     end
@@ -48,29 +52,31 @@ module RSpec
   module Core
     module Formatters
       module ConsoleCodes
-        # Patch so it returns nothing if code_or_symbol is nil, and that it uses
-        # code_or_symbol if it can't be found in VT100_CODE_VALUES to allow for
-        # customization
-        def self.console_code_for(code_or_symbol)
-          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)
-              code_or_symbol
-            else
-              RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.fetch(code_or_symbol) do
+        SuperDiff.insert_singleton_overrides(self) do
+          # Patch so it returns nothing if code_or_symbol is nil, and that it uses
+          # code_or_symbol if it can't be found in VT100_CODE_VALUES to allow for
+          # customization
+          def console_code_for(code_or_symbol)
+            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)
                 code_or_symbol
+              else
+                RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.fetch(code_or_symbol) do
+                  code_or_symbol
+                end
               end
             end
           end
-        end
 
-        # Patch so it does not apply a color if code_or_symbol is nil
-        def self.wrap(text, code_or_symbol)
-          if RSpec.configuration.color_enabled? && code = console_code_for(code_or_symbol)
-            "\e[#{code}m#{text}\e[0m"
-          else
-            text
+          # 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)
+              "\e[#{code}m#{text}\e[0m"
+            else
+              text
+            end
           end
         end
       end
@@ -79,173 +85,177 @@ module RSpec
         # UPDATE: Copy from SyntaxHighlighter::CodeRayImplementation
         RESET_CODE = "\e[0m"
 
-        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)
-          # Patch to convert options[:failure_lines] to groups
-          if options.include?(:failure_lines)
-            @failure_line_groups = [
-              {
-                lines: options[:failure_lines],
-                already_colorized: false
-              }
-            ]
+        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)
+            # Patch to convert options[:failure_lines] to groups
+            if options.include?(:failure_lines)
+              @failure_line_groups = [
+                {
+                  lines: options[:failure_lines],
+                  already_colorized: false
+                }
+              ]
+            end
           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
+          # 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
-                    rest
+                    indentation = line[/^[ ]+/]
+                    rest = colorizer.wrap(line.sub(/^[ ]+/, ''), message_color)
+
+                    if indentation
+                      indentation + rest
+                    else
+                      rest
+                    end
                   end
                 end
               end
             end
-          end
-
-          add_shared_group_lines(lines, colorizer)
-        end
-
-        private
-
-        def add_shared_group_lines(lines, colorizer)
-          return lines if @skip_shared_group_trace
 
-          example.metadata[:shared_group_inclusion_backtrace].each do |frame|
-            # Use red instead of the default color
-            lines << colorizer.wrap(frame.description, :failure)
+            add_shared_group_lines(lines, colorizer)
           end
 
-          lines
-        end
+          private
 
-        # 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
-          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?
-            )
+          def add_shared_group_lines(lines, colorizer)
+            return lines if @skip_shared_group_trace
 
-            if separate_groups
-              @failure_line_groups << { lines: [''], already_colorized: true }
+            example.metadata[:shared_group_inclusion_backtrace].each do |frame|
+              # Use red instead of the default color
+              lines << colorizer.wrap(frame.description, :failure)
             end
 
-            already_colorized = exception_lines.any? do |line|
-              SuperDiff::Csi.already_colorized?(line)
-            end
+            lines
+          end
 
-            if already_colorized
-              @failure_line_groups << {
-                lines: exception_lines,
-                already_colorized: true
-              }
+          # 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
+            if defined?(@failure_line_groups)
+              @failure_line_groups
             else
-              locatable_exception_lines =
-                exception_lines.each_with_index.map do |line, index|
-                  { text: line, index: index }
-                end
+              @failure_line_groups = [
+                {
+                  lines: failure_slash_error_lines,
+                  already_colorized: true
+                }
+              ]
 
-              boundary_line =
-                locatable_exception_lines.find do |line, index|
-                  line[:text].strip.empty? || line[:text].match?(/^    /)
-                end
+              sections = [failure_slash_error_lines, exception_lines]
+              separate_groups = (
+                sections.any? { |section| section.size > 1 } &&
+                !exception_lines.first.empty?
+              )
 
-              if boundary_line
-                @failure_line_groups << {
-                  lines: exception_lines[0..boundary_line[:index] - 1],
-                  already_colorized: false
-                }
+              if separate_groups
+                @failure_line_groups << { lines: [''], already_colorized: true }
+              end
+
+              already_colorized = exception_lines.any? do |line|
+                SuperDiff::Csi.already_colorized?(line)
+              end
+
+              if already_colorized
                 @failure_line_groups << {
-                  lines: exception_lines[boundary_line[:index]..-1],
+                  lines: exception_lines,
                   already_colorized: true
                 }
               else
-                @failure_line_groups << {
-                  lines: exception_lines,
-                  already_colorized: false
-                }
+                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
-            end
 
-            @failure_line_groups
+              @failure_line_groups
+            end
           end
-        end
 
-        # Style the first part in white and don't style the snippet of the line
-        def failure_slash_error_lines
-          lines = read_failed_lines
+          # Style the first part in white and don't style the snippet of the line
+          def failure_slash_error_lines
+            lines = read_failed_lines
 
-          failure_slash_error = ConsoleCodes.wrap("Failure/Error: ", :bold)
+            failure_slash_error = ConsoleCodes.wrap("Failure/Error: ", :bold)
 
-          if lines.count == 1
-            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}/, '  ')
+            if lines.count == 1
+              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.unshift(failure_slash_error)
             end
-            lines.unshift(failure_slash_error)
+
+            lines
           end
 
-          lines
-        end
+          # Exclude this file from being included in backtraces, so that the
+          # SnippetExtractor prints the right thing
+          def find_failed_line
+            line_regex = RSpec.configuration.in_project_source_dir_regex
+            loaded_spec_files = RSpec.configuration.loaded_spec_files
 
-        # Exclude this file from being included in backtraces, so that the
-        # SnippetExtractor prints the right thing
-        def find_failed_line
-          line_regex = RSpec.configuration.in_project_source_dir_regex
-          loaded_spec_files = RSpec.configuration.loaded_spec_files
-
-          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)
-          end || exception_backtrace.first
+            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)
+            end || exception_backtrace.first
+          end
         end
       end
 
       class SyntaxHighlighter
-        private
+        SuperDiff.insert_overrides(self) do
+          private
 
-        def implementation
-          RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+          def implementation
+            RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+          end
         end
       end
     end
@@ -253,100 +263,108 @@ module RSpec
 
   module Support
     class ObjectFormatter
-      # Override to use our formatting algorithm
-      def self.format(value)
-        SuperDiff::ObjectInspection.inspect(value, as_single_line: true)
+      SuperDiff.insert_singleton_overrides(self) do
+        # Override to use our formatting algorithm
+        def format(value)
+          SuperDiff.inspect_object(value, as_lines: false)
+        end
       end
 
-      # Override to use our formatting algorithm
-      def format(value)
-        SuperDiff::ObjectInspection.inspect(value, as_single_line: true)
+      SuperDiff.insert_overrides(self) do
+        # Override to use our formatting algorithm
+        def format(value)
+          SuperDiff.inspect_object(value, as_lines: false)
+        end
       end
     end
   end
 
   module Matchers
     class ExpectedsForMultipleDiffs
-      # Add a key for different sides
-      def self.from(expected)
-        return expected if self === expected
-
-        text =
-          colorizer.wrap("Diff:", SuperDiff::COLORS.fetch(:header)) +
-          "\n\n" +
-          colorizer.wrap(
-            "┌ (Key) ──────────────────────────┐",
-            SuperDiff::COLORS.fetch(:border)
-          ) +
-          "\n" +
-          colorizer.wrap("│ ", SuperDiff::COLORS.fetch(:border)) +
-          colorizer.wrap(
-            "‹-› in expected, not in actual",
-            SuperDiff::COLORS.fetch(:alpha)
-          ) +
-          colorizer.wrap("  │", SuperDiff::COLORS.fetch(:border)) +
-          "\n" +
-          colorizer.wrap("│ ", SuperDiff::COLORS.fetch(:border)) +
-          colorizer.wrap(
-            "‹+› in actual, not in expected",
-            SuperDiff::COLORS.fetch(:beta)
-          ) +
-          colorizer.wrap("  │", SuperDiff::COLORS.fetch(:border)) +
-          "\n" +
-          colorizer.wrap("│ ", SuperDiff::COLORS.fetch(:border)) +
-          "‹ › in both expected and actual" +
-          colorizer.wrap(" │", SuperDiff::COLORS.fetch(:border)) +
-          "\n" +
-          colorizer.wrap(
-            "└─────────────────────────────────┘",
-            SuperDiff::COLORS.fetch(:border)
-          )
-
-        new([[expected, text]])
-      end
+      SuperDiff.insert_singleton_overrides(self) do
+        # Add a key for different sides
+        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
+            )
+
+          new([[expected, text]])
+        end
 
-      def self.colorizer
-        RSpec::Core::Formatters::ConsoleCodes
+        def colorizer
+          RSpec::Core::Formatters::ConsoleCodes
+        end
       end
 
-      # Add an extra line break
-      def message_with_diff(message, differ, actual)
-        diff = diffs(differ, actual)
+      SuperDiff.insert_overrides(self) do
+        # Add an extra line break
+        def message_with_diff(message, differ, actual)
+          diff = diffs(differ, actual)
 
-        if diff.empty?
-          message
-        else
-          "#{message.rstrip}\n\n#{diff}"
+          if diff.empty?
+            message
+          else
+            "#{message.rstrip}\n\n#{diff}"
+          end
         end
-      end
 
-      private
+        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")
+        # 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")
+        end
       end
     end
 
     module BuiltIn
       class Be
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def expected_for_matcher_text
             "truthy"
           end
-        end)
+        end
       end
 
       class BeComparedTo
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def expected_action_for_matcher_text
             if [:==, :===, :=~].include?(@operator)
               "#{@operator}"
@@ -354,13 +372,13 @@ module RSpec
               "be #{@operator}"
             end
           end
-        end)
+        end
       end
 
       class BeFalsey
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def expected_action_for_matcher_text
             "be"
           end
@@ -368,13 +386,13 @@ module RSpec
           def expected_for_matcher_text
             "falsey"
           end
-        end)
+        end
       end
 
       class BeNil
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def expected_action_for_matcher_text
             "be"
           end
@@ -382,19 +400,23 @@ module RSpec
           def expected_for_matcher_text
             "nil"
           end
-        end)
+        end
       end
 
       class BePredicate
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def actual_for_matcher_text
             actual
           end
 
           def expected_for_matcher_text
-            expected
+            if SuperDiff::RSpec.rspec_version < "3.10"
+              expected
+            else
+              predicate.to_s.chomp('?')
+            end
           end
 
           def expected_action_for_matcher_text
@@ -412,13 +434,13 @@ module RSpec
               expected_predicate_method_name: predicate
             )
           end
-        end)
+        end
       end
 
       class BeTruthy
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def expected_action_for_matcher_text
             "be"
           end
@@ -426,13 +448,13 @@ module RSpec
           def expected_for_matcher_text
             "truthy"
           end
-        end)
+        end
       end
 
       class ContainExactly
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           # Override this method so that the differ knows that this is a partial
           # collection
           def expected_for_diff
@@ -448,21 +470,26 @@ module RSpec
           def matcher_text_builder_class
             SuperDiff::RSpec::MatcherTextBuilders::ContainExactly
           end
-        end)
+        end
       end
 
       class Eq
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
       end
 
       class Equal
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
       end
 
       class HaveAttributes
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
+
+        SuperDiff.insert_overrides(self) do
+          def initialize(*)
+            super
+            @actual = nil
+          end
 
-        prepend(Module.new do
           # Use the message in the base matcher
           def failure_message
             respond_to_failure_message_or { super }
@@ -498,54 +525,58 @@ module RSpec
               matchers.an_object_having_attributes(@expected)
             end
           end
-        end)
 
-        # Override to force @values to get populated so that we can show a
-        # proper diff
-        def respond_to_attributes?
-          cache_all_values
-          matches = respond_to_matcher.matches?(@actual)
-          @respond_to_failed = !matches
-          matches
-        end
+          # Override to force @values to get populated so that we can show a
+          # proper diff
+          def respond_to_attributes?
+            cache_all_values
+            matches = respond_to_matcher.matches?(@actual)
+            @respond_to_failed = !matches
+            matches
+          end
 
-        # 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
+          # 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
           end
-        end
 
-        def actual_has_attribute?(attribute_key, attribute_value)
-          values_match?(attribute_value, @values.fetch(attribute_key))
-        end
+          def actual_has_attribute?(attribute_key, attribute_value)
+            values_match?(attribute_value, @values.fetch(attribute_key))
+          end
 
-        # Override to not improve_hash_formatting
-        def respond_to_failure_message_or
-          if respond_to_failed
-            respond_to_matcher.failure_message
-          else
-            yield
+          # Override to not improve_hash_formatting
+          def respond_to_failure_message_or
+            if respond_to_failed
+              respond_to_matcher.failure_message
+            else
+              yield
+            end
           end
         end
       end
 
       class Has
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def actual_for_matcher_text
             actual
           end
 
           def expected_for_matcher_text
-            "#{predicate}#{failure_message_args_description}"
+            if SuperDiff::RSpec.rspec_version < "3.10"
+              "#{predicate}#{failure_message_args_description}"
+            else
+              "#{predicate}#{args_to_s}"
+            end
           end
 
           def expected_action_for_matcher_text
@@ -562,13 +593,18 @@ module RSpec
               private_predicate: private_predicate?
             )
           end
-        end)
+        end
       end
 
       class Include
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
+
+        SuperDiff.insert_overrides(self) do
+          def initialize(*)
+            super
+            @actual = nil
+          end
 
-        prepend(Module.new do
           # Override this method so that the differ knows that this is a partial
           # array or hash
           def expected_for_diff
@@ -603,7 +639,11 @@ module RSpec
           def expected_for_failure_message
             # TODO: Switch to using @divergent_items and handle this in the text
             # builder
-            readable_list_of(@divergent_items).lstrip
+            if defined?(@divergent_items)
+              readable_list_of(@divergent_items).lstrip
+            else
+              ""
+            end
           end
 
           # Update to use (...) as delimiter instead of {...}
@@ -616,13 +656,13 @@ module RSpec
               super
             end
           end
-        end)
+        end
       end
 
       class Match
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def matcher_text_builder_class
             SuperDiff::RSpec::MatcherTextBuilders::Match
           end
@@ -630,7 +670,7 @@ module RSpec
           def matcher_text_builder_args
             super.merge(expected_captures: @expected_captures)
           end
-        end)
+        end
       end
 
       class MatchArray < ContainExactly
@@ -644,9 +684,9 @@ module RSpec
       end
 
       class RaiseError
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def actual_for_matcher_text
             if @actual_error
               "#<#{@actual_error.class.name} #{@actual_error.message.inspect}>"
@@ -688,7 +728,7 @@ module RSpec
           def matcher_text_builder_class
             SuperDiff::RSpec::MatcherTextBuilders::RaiseError
           end
-        end)
+        end
 
         def self.matcher_name
           "raise error"
@@ -696,9 +736,9 @@ module RSpec
       end
 
       class RespondTo
-        prepend SuperDiff::RSpec::AugmentedMatcher
+        SuperDiff.insert_overrides(self, SuperDiff::RSpec::AugmentedMatcher)
 
-        prepend(Module.new do
+        SuperDiff.insert_overrides(self) do
           def initialize(*)
             super
             @failing_method_names = nil
@@ -724,13 +764,20 @@ module RSpec
           def expected_for_failure_message
             @failing_method_names
           end
-        end)
+        end
       end
     end
 
-    def match_array(items)
-      BuiltIn::MatchArray.new(items.is_a?(String) ? [items] : items)
+    SuperDiff.insert_overrides(self) do
+      def self.prepended(base)
+        base.class_eval do
+          alias_matcher :an_array_matching, :match_array
+        end
+      end
+
+      def match_array(items)
+        BuiltIn::MatchArray.new(items.is_a?(String) ? [items] : items)
+      end
     end
-    alias_matcher :an_array_matching, :match_array
   end
 end