super_diff 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fc8e5b83b3b02559e96bbd06f8703b688d56b32588639f7d49a4774d6869433
-  data.tar.gz: 5f0c9d472aa1170df1a52cc41eab384c4526342cf336e380cdbd01f9e95a3b61
+  metadata.gz: be7fd08d833b19c6a99401a1c7b80c448903c315d198b09e55baf70ee663dcfc
+  data.tar.gz: ea79d7bb6469e711058b71716c9ce1a23d6353381a8ae876c6bb180a57e78e2a
 SHA512:
-  metadata.gz: 24306d1fba59520092a8a446e0a9219a3e9e89813fd3818f2769f737084cc8f6565b12497c86bacb4b9a8f9c5a4b13bafe0479e330cc8169a6c574e11cc74a56
-  data.tar.gz: 514af50e6272ae3095b752d778b7f3bc776923bccb87a2ab8a50c2f8019c9aba991e129d2dad88248c621594ab5972029a798ada0e64eb8f8a27acc0e7cde496
+  metadata.gz: 75a1258f1d15d4a830a89ad898cefed4d6379d012fd7aa50d61f82672f10d0acacbf32e88177970fe46afa977dbce42c30212194867eefa1a72eb874417a1156
+  data.tar.gz: eb40c7881a21263fc89c6c2cfd1e54c5277449f98a32fb266bc720c43177772480d9834b61c4614102c236942d46ffcea82bc4e5090ad5f70dfc6d15f1d9e184

data/lib/super_diff.rb

@@ -30,10 +30,34 @@ module SuperDiff
     @_configuration ||= Configuration.new
   end
 
+  def self.inspect_object(object, as_single_line:, indent_level: 0)
+    ObjectInspection::Inspectors::Main.call(
+      object,
+      as_single_line: as_single_line,
+      indent_level: indent_level,
+    )
+  end
+
   def self.time_like?(value)
     # Check for ActiveSupport's #acts_like_time? for their time-like objects
     # (like ActiveSupport::TimeWithZone).
     (value.respond_to?(:acts_like_time?) && value.acts_like_time?) ||
       value.is_a?(Time)
   end
+
+  def self.insert_overrides(target_module, mod = nil, &block)
+    if mod
+      target_module.prepend(mod)
+    else
+      target_module.prepend(Module.new(&block))
+    end
+  end
+
+  def self.insert_singleton_overrides(target_module, mod = nil, &block)
+    if mod
+      target_module.singleton_class.prepend(mod)
+    else
+      target_module.singleton_class.prepend(Module.new(&block))
+    end
+  end
 end

data/lib/super_diff/diff_formatters/collection.rb

@@ -94,7 +94,7 @@ module SuperDiff
       end
 
       def build_chunk_by_inspecting(value, prefix:, icon:)
-        inspection = ObjectInspection.inspect(
+        inspection = SuperDiff.inspect_object(
           value,
           as_single_line: false,
         )

data/lib/super_diff/equality_matchers/array.rb

@@ -13,14 +13,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              ObjectInspection.inspect(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_single_line: true),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              ObjectInspection.inspect(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_single_line: true),
             )
           }
 

data/lib/super_diff/equality_matchers/default.rb

@@ -21,7 +21,7 @@ module SuperDiff
         Helpers.style(
           :expected,
           "Expected: " +
-          ObjectInspection.inspect(expected, as_single_line: true),
+          SuperDiff.inspect_object(expected, as_single_line: true),
         )
       end
 
@@ -29,7 +29,7 @@ module SuperDiff
         Helpers.style(
           :actual,
           "  Actual: " +
-          ObjectInspection.inspect(actual, as_single_line: true),
+          SuperDiff.inspect_object(actual, as_single_line: true),
         )
       end
 

data/lib/super_diff/equality_matchers/hash.rb

@@ -13,14 +13,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              ObjectInspection.inspect(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_single_line: true),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              ObjectInspection.inspect(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_single_line: true),
             )
           }
 

data/lib/super_diff/equality_matchers/multiline_string.rb

@@ -14,14 +14,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              ObjectInspection.inspect(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_single_line: true),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              ObjectInspection.inspect(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_single_line: true),
             )
           }
 

data/lib/super_diff/equality_matchers/primitive.rb

@@ -17,14 +17,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              ObjectInspection.inspect(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_single_line: true),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              ObjectInspection.inspect(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_single_line: true),
             )
           }
         OUTPUT

data/lib/super_diff/equality_matchers/singleline_string.rb

@@ -13,14 +13,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              ObjectInspection.inspect(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_single_line: true),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              ObjectInspection.inspect(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_single_line: true),
             )
           }
         OUTPUT

data/lib/super_diff/object_inspection.rb

@@ -3,13 +3,5 @@ module SuperDiff
     autoload :InspectionTree, "super_diff/object_inspection/inspection_tree"
     autoload :Inspectors, "super_diff/object_inspection/inspectors"
     autoload :Nodes, "super_diff/object_inspection/nodes"
-
-    def self.inspect(object, as_single_line:, indent_level: 0)
-      Inspectors::Main.call(
-        object,
-        as_single_line: as_single_line,
-        indent_level: indent_level,
-      )
-    end
   end
 end

data/lib/super_diff/object_inspection/nodes/inspection.rb

@@ -10,7 +10,7 @@ module SuperDiff
               immediate_value
             end
 
-          SuperDiff::ObjectInspection.inspect(
+          SuperDiff.inspect_object(
             value,
             indent_level: indent_level,
             as_single_line: as_single_line,

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_single_line: true)
+        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_single_line: true)
+        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.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
+      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
+            )
 
-      def self.colorizer
-        RSpec::Core::Formatters::ConsoleCodes
+          new([[expected, text]])
+        end
+
+        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,13 +400,13 @@ 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
@@ -416,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
@@ -430,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
@@ -452,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 }
@@ -502,48 +525,48 @@ 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
@@ -570,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
@@ -611,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 {...}
@@ -624,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
@@ -638,7 +670,7 @@ module RSpec
           def matcher_text_builder_args
             super.merge(expected_captures: @expected_captures)
           end
-        end)
+        end
       end
 
       class MatchArray < ContainExactly
@@ -652,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}>"
@@ -696,7 +728,7 @@ module RSpec
           def matcher_text_builder_class
             SuperDiff::RSpec::MatcherTextBuilders::RaiseError
           end
-        end)
+        end
 
         def self.matcher_name
           "raise error"
@@ -704,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
@@ -732,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