super_diff 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7c5f949ffe359d395ca46825b8bf8be046c4c0e940710c82acc4777e3f239e9
-  data.tar.gz: 222f3864ffe1a7d5e0e1fc5d01b66a1820bf0a3e0125e2f0e6de6771febeadef
+  metadata.gz: 8efa30260e2d32c10ea6571d37a393756b216c1ba2c991d28a4124a0822c7e6f
+  data.tar.gz: a98a146c39eda8aeb3735869ffadacb279c26b76f2bf3f4b2ebc212fd6e8dbe1
 SHA512:
-  metadata.gz: 6c05bd06aab01df5c8ed84af2b38ebaaae913436e16cf11566c23b7afd9cc893a59c30fdb8c666c8e088c0101f3e970e0f549da9a3df4c44482142a3d649cd4d
-  data.tar.gz: 0d4040820fa2633d106c2f8dc5e4462393c7b12a2cb250444755d77a333bc5ea9375660f8e8b3bab1d3985e63d0c25e27eb4e8aaac7a991d9858af9821106b08
+  metadata.gz: a0fdf3017f5a38865bb8cfbb15dfacf3a070f42c23883a6821b39a4b2bb00da3c9beb1e65c417b5094693ab14de18edf9934f23c7f242849cc2dfb950ee60649
+  data.tar.gz: 6484896862126281d2f051d7ef17b760426083bfba3f9ba7f93936f331dca3cee187cbd8e75e46e6a9f86cbcd17d38e47fd9c2096a7ffdb6dc4290bed763c92f

data/README.md

@@ -10,7 +10,7 @@
 SuperDiff is a gem that hooks into RSpec to intelligently display the
 differences between two data structures of any type.
 
-📢 **[See what's changed in the latest version (0.2.0)][changelog].**
+📢 **[See what's changed in the latest version (0.3.0)][changelog].**
 
 [changelog]: CHANGELOG.md
 
@@ -84,13 +84,13 @@ expect(actual).to eq(expected)
 
 You would get output that looks like this:
 
-![Before super_diff](doc/before_super_diff.png)
+![Before super_diff](doc/before.png)
 
 What this library does is to provide a diff engine that knows how to figure out
 the differences between any two data structures and display them in a sensible
 way. So, using the example above, you'd get this instead:
 
-![After super_diff](doc/after_super_diff.png)
+![After super_diff](doc/after.png)
 
 ## Installation
 

data/lib/super_diff/active_record.rb

@@ -36,6 +36,8 @@ if defined?(SuperDiff::RSpec)
   end
 end
 
+require "super_diff/active_record/monkey_patches"
+
 SuperDiff::ObjectInspection.map.prepend(
   SuperDiff::ActiveRecord::ObjectInspection::MapExtension,
 )

data/lib/super_diff/active_record/monkey_patches.rb

@@ -0,0 +1,9 @@
+# rubocop:disable Style/BracesAroundHashParameters, Style/ClassAndModuleChildren
+class ActiveRecord::Base
+  def attributes_for_super_diff
+    (attributes.keys.sort - ["id"]).reduce({ id: id }) do |hash, key|
+      hash.merge(key.to_sym => attributes[key])
+    end
+  end
+end
+# rubocop:enable Style/BracesAroundHashParameters, Style/ClassAndModuleChildren

data/lib/super_diff/csi.rb

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

data/lib/super_diff/equality_matchers/default.rb

@@ -34,7 +34,7 @@ module SuperDiff
       end
 
       def diff_section
-        if diff.blank?
+        if diff.empty?
           ""
         else
           <<~SECTION

data/lib/super_diff/operation_sequences/base.rb

@@ -6,6 +6,20 @@ module SuperDiff
         raise NotImplementedError
       end
       # rubocop:enable Lint/UnusedMethodArgument
+
+      def pretty_print(pp)
+        pp.text "#{self.class.name}.new(["
+        pp.group_sub do
+          pp.nest(2) do
+            pp.breakable
+            pp.seplist(self) do |value|
+              pp.pp value
+            end
+          end
+        end
+        pp.breakable
+        pp.text("])")
+      end
     end
   end
 end

data/lib/super_diff/rspec.rb

@@ -25,30 +25,30 @@ module SuperDiff
       @_configuration ||= Configuration.new
     end
 
-    def self.partial_hash?(value)
-      partial_placeholder?(value) &&
+    def self.a_hash_including_something?(value)
+      fuzzy_object?(value) &&
         value.respond_to?(:expecteds) &&
         value.expecteds.one? &&
         value.expecteds.first.is_a?(::Hash)
     end
 
-    def self.partial_array?(value)
-      partial_placeholder?(value) &&
+    def self.a_collection_including_something?(value)
+      fuzzy_object?(value) &&
         value.respond_to?(:expecteds) &&
         !(value.expecteds.one? && value.expecteds.first.is_a?(::Hash))
     end
 
-    def self.partial_object?(value)
-      partial_placeholder?(value) &&
+    def self.an_object_having_some_attributes?(value)
+      fuzzy_object?(value) &&
         value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::HaveAttributes)
     end
 
-    def self.collection_containing_exactly?(value)
-      partial_placeholder?(value) &&
+    def self.a_collection_containing_exactly_something?(value)
+      fuzzy_object?(value) &&
         value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::ContainExactly)
     end
 
-    def self.partial_placeholder?(value)
+    def self.fuzzy_object?(value)
       value.is_a?(::RSpec::Matchers::AliasedMatcher)
     end
   end

data/lib/super_diff/rspec/differ.rb

@@ -14,16 +14,16 @@ module SuperDiff
             extra_classes: [
               *RSpec.configuration.extra_differ_classes,
               Differs::CollectionContainingExactly,
-              Differs::PartialArray,
-              Differs::PartialHash,
-              Differs::PartialObject,
+              Differs::CollectionIncluding,
+              Differs::HashIncluding,
+              Differs::ObjectHavingAttributes,
             ],
             extra_operational_sequencer_classes: [
               *RSpec.configuration.extra_operational_sequencer_classes,
               OperationalSequencers::CollectionContainingExactly,
-              OperationalSequencers::PartialArray,
-              OperationalSequencers::PartialHash,
-              OperationalSequencers::PartialObject,
+              OperationalSequencers::CollectionIncluding,
+              OperationalSequencers::HashIncluding,
+              OperationalSequencers::ObjectHavingAttributes,
             ],
             extra_diff_formatter_classes: RSpec.configuration.extra_diff_formatter_classes,
           )

data/lib/super_diff/rspec/differs.rb

@@ -5,9 +5,15 @@ module SuperDiff
         :CollectionContainingExactly,
         "super_diff/rspec/differs/collection_containing_exactly",
       )
-      autoload :PartialArray, "super_diff/rspec/differs/partial_array"
-      autoload :PartialHash, "super_diff/rspec/differs/partial_hash"
-      autoload :PartialObject, "super_diff/rspec/differs/partial_object"
+      autoload(
+        :CollectionIncluding,
+        "super_diff/rspec/differs/collection_including",
+      )
+      autoload :HashIncluding, "super_diff/rspec/differs/hash_including"
+      autoload(
+        :ObjectHavingAttributes,
+        "super_diff/rspec/differs/object_having_attributes",
+      )
     end
   end
 end

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

@@ -3,7 +3,7 @@ module SuperDiff
     module Differs
       class CollectionContainingExactly < SuperDiff::Differs::Array
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.collection_containing_exactly?(expected) &&
+          SuperDiff::RSpec.a_collection_containing_exactly_something?(expected) &&
             actual.is_a?(::Array)
         end
 

data/lib/super_diff/rspec/differs/{partial_hash.rb → collection_including.rb}

@@ -1,15 +1,16 @@
 module SuperDiff
   module RSpec
     module Differs
-      class PartialHash < SuperDiff::Differs::Hash
+      class CollectionIncluding < SuperDiff::Differs::Array
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.partial_hash?(expected) && actual.is_a?(::Hash)
+          SuperDiff::RSpec.a_collection_including_something?(expected) &&
+            actual.is_a?(::Array)
         end
 
         private
 
         def operations
-          OperationalSequencers::PartialHash.call(
+          OperationalSequencers::CollectionIncluding.call(
             expected: expected,
             actual: actual,
             extra_operational_sequencer_classes: extra_operational_sequencer_classes,

data/lib/super_diff/rspec/differs/{partial_array.rb → hash_including.rb}

@@ -1,15 +1,16 @@
 module SuperDiff
   module RSpec
     module Differs
-      class PartialArray < SuperDiff::Differs::Array
+      class HashIncluding < SuperDiff::Differs::Hash
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.partial_array?(expected) && actual.is_a?(::Array)
+          SuperDiff::RSpec.a_hash_including_something?(expected) &&
+            actual.is_a?(::Hash)
         end
 
         private
 
         def operations
-          OperationalSequencers::PartialArray.call(
+          OperationalSequencers::HashIncluding.call(
             expected: expected,
             actual: actual,
             extra_operational_sequencer_classes: extra_operational_sequencer_classes,

data/lib/super_diff/rspec/differs/{partial_object.rb → object_having_attributes.rb}

@@ -1,15 +1,15 @@
 module SuperDiff
   module RSpec
     module Differs
-      class PartialObject < SuperDiff::Differs::DefaultObject
+      class ObjectHavingAttributes < SuperDiff::Differs::DefaultObject
         def self.applies_to?(expected, _actual)
-          SuperDiff::RSpec.partial_object?(expected)
+          SuperDiff::RSpec.an_object_having_some_attributes?(expected)
         end
 
         private
 
         def operations
-          OperationalSequencers::PartialObject.call(
+          OperationalSequencers::ObjectHavingAttributes.call(
             expected: expected,
             actual: actual,
             extra_operational_sequencer_classes: extra_operational_sequencer_classes,

data/lib/super_diff/rspec/matcher_text_builders.rb

@@ -10,6 +10,10 @@ module SuperDiff
         :ContainExactly,
         "super_diff/rspec/matcher_text_builders/contain_exactly",
       )
+      autoload(
+        :HavePredicate,
+        "super_diff/rspec/matcher_text_builders/have_predicate",
+      )
       autoload :Match, "super_diff/rspec/matcher_text_builders/match"
       autoload(
         :RaiseError,

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

@@ -36,27 +36,46 @@ module SuperDiff
           end
         end
 
-        def add_expected_value_to(template, expected)
+        def add_expected_value_to_failure_message(template)
           template.add_text " "
-          template.add_text_in_color(alpha_color, "`#{expected}?`")
+          template.add_text_in_color(
+            alpha_color,
+            "#{expected_for_failure_message}?",
+          )
           template.add_text " or "
-          template.add_text_in_color(alpha_color, "`#{expected}s?`")
+          template.add_text_in_color(
+            alpha_color,
+            "#{expected_for_failure_message}s?",
+          )
+        end
+
+        def add_expected_value_to_description(template)
+          template.add_text " "
+          template.add_text_in_color(
+            alpha_color,
+            "`#{expected_for_description}?`",
+          )
+          template.add_text " or "
+          template.add_text_in_color(
+            alpha_color,
+            "`#{expected_for_description}s?`",
+          )
         end
 
         def add_extra_after_error
           if expected_predicate_method_name == :true?
             template.add_text "\n\n"
             template.add_text "(Perhaps you want to use "
-            template.add_text_in_color(:blue, "`be(true)`")
+            template.add_text_in_color(:blue, "be(true)")
             template.add_text " or "
-            template.add_text_in_color(:blue, "`be_truthy`")
+            template.add_text_in_color(:blue, "be_truthy")
             template.add_text " instead?)"
           elsif expected_predicate_method_name == :false?
             template.add_text "\n\n"
             template.add_text "(Perhaps you want to use "
-            template.add_text_in_color(:blue, "`be(false)`")
+            template.add_text_in_color(:blue, "be(false)")
             template.add_text " or "
-            template.add_text_in_color(:blue, "`be_falsey`")
+            template.add_text_in_color(:blue, "be_falsey")
             template.add_text " instead?)"
           end
         end

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

@@ -0,0 +1,61 @@
+module SuperDiff
+  module RSpec
+    module MatcherTextBuilders
+      class HavePredicate < Base
+        def initialize(predicate_accessible:, private_predicate:, **rest)
+          super(**rest)
+          @predicate_accessible = predicate_accessible
+          @private_predicate = private_predicate
+        end
+
+        protected
+
+        def expected_action_for_failure_message
+          if predicate_accessible?
+            "return a truthy result for"
+          elsif private_predicate?
+            "have a public method"
+          else
+            "respond to"
+          end
+        end
+
+        def beta_color
+          :yellow
+        end
+
+        def add_actual_value
+          template.add_text_in_color(beta_color) do
+            description_of(actual)
+          end
+        end
+
+        def add_expected_value_to_failure_message(template)
+          template.add_text " "
+          template.add_text_in_color(
+            alpha_color,
+            expected_for_failure_message,
+          )
+        end
+
+        def add_expected_value_to_description(template)
+          template.add_text " "
+          template.add_text_in_color(
+            alpha_color,
+            "`#{expected_for_description}`",
+          )
+        end
+
+        private
+
+        def private_predicate?
+          @private_predicate
+        end
+
+        def predicate_accessible?
+          @predicate_accessible
+        end
+      end
+    end
+  end
+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/monkey_patches.rb

@@ -93,19 +93,31 @@ module RSpec
           if options.include?(:failure_lines)
             @failure_line_groups = {
               lines: options[:failure_lines],
-              already_colored: false
+              already_colorized: false
             }
           end
         end
 
         # Override to only color uncolored lines in red
-        def colorized_message_lines(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        # and to not color empty lines
+        def colorized_message_lines(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
           lines = failure_line_groups.flat_map do |group|
-            if group[:already_colored]
+            if group[:already_colorized]
               group[:lines]
             else
               group[:lines].map do |line|
-                colorizer.wrap(line, message_color)
+                if line.strip.empty?
+                  line
+                else
+                  indentation = line[/^[ ]+/]
+                  rest = colorizer.wrap(line.sub(/^[ ]+/, ''), message_color)
+
+                  if indentation
+                    indentation + rest
+                  else
+                    rest
+                  end
+                end
               end
             end
           end
@@ -129,33 +141,68 @@ 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_has_coloration = exception_lines.any? do |line|
-              line.match?(/\e\[\d+m/)
+
+            already_colorized = exception_lines.any? do |line|
+              SuperDiff::Csi.already_colorized?(line)
             end
 
-            groups << {
-              lines: exception_lines[0..0],
-              already_colored: already_has_coloration
-            }
-            groups << {
-              lines: exception_lines[1..-1] + extra_failure_lines,
-              already_colored: true
-            }
+            if already_colorized
+              @failure_line_groups << {
+                lines: exception_lines,
+                already_colorized: true
+              }
+            else
+              locatable_exception_lines =
+                exception_lines.each_with_index.map do |line, index|
+                  { text: line, index: index }
+                end
+
+              boundary_line =
+                locatable_exception_lines.find do |line, index|
+                  line[:text].strip.empty? || line[:text].match?(/^    /)
+                end
+
+              if boundary_line
+                @failure_line_groups << {
+                  lines: exception_lines[0..boundary_line[:index] - 1],
+                  already_colorized: false
+                }
+                @failure_line_groups << {
+                  lines: exception_lines[boundary_line[:index]..-1],
+                  already_colorized: true
+                }
+              else
+                @failure_line_groups << {
+                  lines: exception_lines,
+                  already_colorized: false
+                }
+              end
+            end
+
+            @failure_line_groups
           end
         end
 
@@ -204,6 +251,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 +355,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 +413,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 +449,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 +534,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,7 +652,9 @@ module RSpec
           end
 
           def actual_for_diff
-            @actual_error.message
+            if @actual_error
+              @actual_error.message
+            end
           end
 
           def expected_for_matcher_text
@@ -608,7 +674,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 +687,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