rspec-expectations 3.0.4 → 3.12.3

data/lib/rspec/matchers/aliased_matcher.rb

@@ -23,19 +23,94 @@ module RSpec
       # used.
       def method_missing(*)
         return_val = super
-        return return_val unless return_val.respond_to?(:description)
-        AliasedMatcher.new(return_val, @description_block)
+        return return_val unless RSpec::Matchers.is_a_matcher?(return_val)
+        self.class.new(return_val, @description_block)
       end
 
       # Provides the description of the aliased matcher. Aliased matchers
       # are designed to behave identically to the original matcher except
-      # for this method. The description is different to reflect the aliased
-      # name.
+      # for the description and failure messages. The description is different
+      # to reflect the aliased name.
       #
       # @api private
       def description
         @description_block.call(super)
       end
+
+      # Provides the failure_message of the aliased matcher. Aliased matchers
+      # are designed to behave identically to the original matcher except
+      # for the description and failure messages. The failure_message is different
+      # to reflect the aliased name.
+      #
+      # @api private
+      def failure_message
+        @description_block.call(super)
+      end
+
+      # Provides the failure_message_when_negated of the aliased matcher. Aliased matchers
+      # are designed to behave identically to the original matcher except
+      # for the description and failure messages. The failure_message_when_negated is different
+      # to reflect the aliased name.
+      #
+      # @api private
+      def failure_message_when_negated
+        @description_block.call(super)
+      end
+    end
+
+    # Decorator used for matchers that have special implementations of
+    # operators like `==` and `===`.
+    # @private
+    class AliasedMatcherWithOperatorSupport < AliasedMatcher
+      # We undef these so that they get delegated via `method_missing`.
+      undef ==
+      undef ===
+    end
+
+    # @private
+    class AliasedNegatedMatcher < AliasedMatcher
+      def matches?(*args, &block)
+        if @base_matcher.respond_to?(:does_not_match?)
+          @base_matcher.does_not_match?(*args, &block)
+        else
+          !super
+        end
+      end
+
+      def does_not_match?(*args, &block)
+        @base_matcher.matches?(*args, &block)
+      end
+
+      def failure_message
+        optimal_failure_message(__method__, :failure_message_when_negated)
+      end
+
+      def failure_message_when_negated
+        optimal_failure_message(__method__, :failure_message)
+      end
+
+    private
+
+      DefaultFailureMessages = BuiltIn::BaseMatcher::DefaultFailureMessages
+
+      # For a matcher that uses the default failure messages, we prefer to
+      # use the override provided by the `description_block`, because it
+      # includes the phrasing that the user has expressed a preference for
+      # by going through the effort of defining a negated matcher.
+      #
+      # However, if the override didn't actually change anything, then we
+      # should return the opposite failure message instead -- the overridden
+      # message is going to be confusing if we return it as-is, as it represents
+      # the non-negated failure message for a negated match (or vice versa).
+      def optimal_failure_message(same, inverted)
+        if DefaultFailureMessages.has_default_failure_messages?(@base_matcher)
+          base_message = @base_matcher.__send__(same)
+          overridden    = @description_block.call(base_message)
+          return overridden if overridden != base_message
+        end
+
+        @base_matcher.__send__(inverted)
+      end
     end
   end
 end

data/lib/rspec/matchers/built_in/all.rb

@@ -21,6 +21,10 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
+          unless iterable?
+            return "#{improve_hash_formatting(super)}, but was not iterable"
+          end
+
           all_messages = [improve_hash_formatting(super)]
           failed_objects.each do |index, matcher_failure_message|
             all_messages << failure_message_for_item(index, matcher_failure_message)
@@ -37,6 +41,8 @@ module RSpec
       private
 
         def match(_expected, _actual)
+          return false unless iterable?
+
           index_failed_objects
           failed_objects.empty?
         end
@@ -67,8 +73,13 @@ module RSpec
 
         def initialize_copy(other)
           @matcher = @matcher.clone
+          @failed_objects = @failed_objects.clone
           super
         end
+
+        def iterable?
+          @actual.respond_to?(:each_with_index)
+        end
       end
     end
   end

data/lib/rspec/matchers/built_in/base_matcher.rb

@@ -8,11 +8,10 @@ module RSpec
       #
       # ### Warning:
       #
-      # This class is for internal use, and subject to change without notice.  We
-      # strongly recommend that you do not base your custom matchers on this
+      # This class is for internal use, and subject to change without notice.
+      # We strongly recommend that you do not base your custom matchers on this
       # class. If/when this changes, we will announce it and remove this warning.
       class BaseMatcher
-        include RSpec::Matchers::Pretty
         include RSpec::Matchers::Composable
 
         # @api private
@@ -23,6 +22,9 @@ module RSpec
         # @private
         attr_reader :actual, :expected, :rescued_exception
 
+        # @private
+        attr_writer :matcher_name
+
         def initialize(expected=UNDEFINED)
           @expected = expected unless UNDEFINED.equal?(expected)
         end
@@ -53,31 +55,12 @@ module RSpec
         end
 
         # @api private
-        # Provides a good generic failure message. Based on `description`.
-        # When subclassing, if you are not satisfied with this failure message
-        # you often only need to override `description`.
-        # @return [String]
-        def failure_message
-          assert_ivars :@actual
-          "expected #{@actual.inspect} to #{description}"
-        end
-
-        # @api private
-        # Provides a good generic negative failure message. Based on `description`.
-        # When subclassing, if you are not satisfied with this failure message
-        # you often only need to override `description`.
-        # @return [String]
-        def failure_message_when_negated
-          assert_ivars :@actual
-          "expected #{@actual.inspect} not to #{description}"
-        end
-
-        # @api private
-        # Generates a "pretty" description using the logic in {Pretty}.
+        # Generates a description using {EnglishPhrasing}.
         # @return [String]
         def description
-          return name_to_sentence unless defined?(@expected)
-          "#{name_to_sentence}#{to_sentence @expected}"
+          desc = EnglishPhrasing.split_words(self.class.matcher_name)
+          desc << EnglishPhrasing.list(@expected) if defined?(@expected)
+          desc
         end
 
         # @api private
@@ -95,20 +78,120 @@ module RSpec
           false
         end
 
+        # @private
+        def supports_value_expectations?
+          true
+        end
+
+        # @api private
+        def expects_call_stack_jump?
+          false
+        end
+
+        # @private
+        def expected_formatted
+          RSpec::Support::ObjectFormatter.format(@expected)
+        end
+
+        # @private
+        def actual_formatted
+          RSpec::Support::ObjectFormatter.format(@actual)
+        end
+
+        # @private
+        def self.matcher_name
+          @matcher_name ||= underscore(name.split('::').last)
+        end
+
+        # @private
+        def matcher_name
+          if defined?(@matcher_name)
+            @matcher_name
+          else
+            self.class.matcher_name
+          end
+        end
+
+        # @private
+        # Borrowed from ActiveSupport.
+        def self.underscore(camel_cased_word)
+          word = camel_cased_word.to_s.dup
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.tr!('-', '_')
+          word.downcase!
+          word
+        end
+        private_class_method :underscore
+
       private
 
         def assert_ivars(*expected_ivars)
           return unless (expected_ivars - present_ivars).any?
-          raise "#{self.class.name} needs to supply#{to_sentence expected_ivars}"
+          ivar_list = EnglishPhrasing.list(expected_ivars)
+          raise "#{self.class.name} needs to supply#{ivar_list}"
         end
 
         if RUBY_VERSION.to_f < 1.9
+          # :nocov:
           def present_ivars
-            instance_variables.map { |v| v.to_sym }
+            instance_variables.map(&:to_sym)
           end
+          # :nocov:
         else
           alias present_ivars instance_variables
         end
+
+        # @private
+        module HashFormatting
+          # `{ :a => 5, :b => 2 }.inspect` produces:
+          #
+          #     {:a=>5, :b=>2}
+          #
+          # ...but it looks much better as:
+          #
+          #     {:a => 5, :b => 2}
+          #
+          # This is idempotent and safe to run on a string multiple times.
+          def improve_hash_formatting(inspect_string)
+            inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
+          end
+          module_function :improve_hash_formatting
+        end
+
+        include HashFormatting
+
+        # @api private
+        # Provides default implementations of failure messages, based on the `description`.
+        module DefaultFailureMessages
+          # @api private
+          # Provides a good generic failure message. Based on `description`.
+          # When subclassing, if you are not satisfied with this failure message
+          # you often only need to override `description`.
+          # @return [String]
+          def failure_message
+            "expected #{description_of @actual} to #{description}".dup
+          end
+
+          # @api private
+          # Provides a good generic negative failure message. Based on `description`.
+          # When subclassing, if you are not satisfied with this failure message
+          # you often only need to override `description`.
+          # @return [String]
+          def failure_message_when_negated
+            "expected #{description_of @actual} not to #{description}".dup
+          end
+
+          # @private
+          def self.has_default_failure_messages?(matcher)
+            matcher.method(:failure_message).owner == self &&
+              matcher.method(:failure_message_when_negated).owner == self
+          rescue NameError
+            false
+          end
+        end
+
+        include DefaultFailureMessages
       end
     end
   end

data/lib/rspec/matchers/built_in/be.rb

@@ -8,13 +8,13 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected: truthy value\n     got: #{actual.inspect}"
+          "expected: truthy value\n     got: #{actual_formatted}"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          "expected: falsey value\n     got: #{actual.inspect}"
+          "expected: falsey value\n     got: #{actual_formatted}"
         end
 
       private
@@ -31,13 +31,13 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected: falsey value\n     got: #{actual.inspect}"
+          "expected: falsey value\n     got: #{actual_formatted}"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          "expected: truthy value\n     got: #{actual.inspect}"
+          "expected: truthy value\n     got: #{actual_formatted}"
         end
 
       private
@@ -54,7 +54,7 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected: nil\n     got: #{actual.inspect}"
+          "expected: nil\n     got: #{actual_formatted}"
         end
 
         # @api private
@@ -83,15 +83,15 @@ module RSpec
         end
 
         def inspected_args
-          @args.map { |a| a.inspect }
+          @args.map { |a| RSpec::Support::ObjectFormatter.format(a) }
         end
 
         def expected_to_sentence
-          split_words(@expected)
+          EnglishPhrasing.split_words(@expected)
         end
 
         def args_to_sentence
-          to_sentence(@args)
+          EnglishPhrasing.list(@args)
         end
       end
 
@@ -108,13 +108,13 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected #{@actual.inspect} to evaluate to true"
+          "expected #{actual_formatted} to evaluate to true"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          "expected #{@actual.inspect} to evaluate to false"
+          "expected #{actual_formatted} to evaluate to false"
         end
 
         [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
@@ -137,25 +137,35 @@ module RSpec
         include BeHelpers
 
         def initialize(operand, operator)
-          @expected, @operator = operand, operator
+          @expected = operand
+          @operator = operator
           @args = []
         end
 
         def matches?(actual)
-          @actual = actual
-          @actual.__send__ @operator, @expected
+          perform_match(actual)
+        rescue ArgumentError, NoMethodError
+          false
+        end
+
+        def does_not_match?(actual)
+          !perform_match(actual)
+        rescue ArgumentError, NoMethodError
+          false
         end
 
         # @api private
         # @return [String]
         def failure_message
-          "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
+          "expected: #{@operator} #{expected_formatted}\n" \
+          "     got: #{@operator.to_s.gsub(/./, ' ')} #{actual_formatted}"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          message = "`expect(#{@actual.inspect}).not_to be #{@operator} #{@expected.inspect}`"
+          message = "`expect(#{actual_formatted}).not_to " \
+                    "be #{@operator} #{expected_formatted}`"
           if [:<, :>, :<=, :>=].include?(@operator)
             message + " not only FAILED, it is a bit confusing."
           else
@@ -168,108 +178,12 @@ module RSpec
         def description
           "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
         end
-      end
-
-      # @api private
-      # Provides the implementation of `be_<predicate>`.
-      # Not intended to be instantiated directly.
-      class BePredicate < BaseMatcher
-        include BeHelpers
-
-        def initialize(*args, &block)
-          @expected = parse_expected(args.shift)
-          @args = args
-          @block = block
-        end
-
-        def matches?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?
-        end
-
-        def does_not_match?(actual, &block)
-          @actual  = actual
-          @block ||= block
-          predicate_accessible? && !predicate_matches?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          failure_message_expecting(true)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message_expecting(false)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
-        end
 
       private
 
-        def predicate_accessible?
-          !private_predicate? && predicate_exists?
-        end
-
-        # support 1.8.7, evaluate once at load time for performance
-        if String === methods.first
-          def private_predicate?
-            @actual.private_methods.include? predicate.to_s
-          end
-        else
-          def private_predicate?
-            @actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate_exists?
-          actual.respond_to?(predicate) || actual.respond_to?(present_tense_predicate)
-        end
-
-        def predicate_matches?
-          method_name = actual.respond_to?(predicate) ? predicate : present_tense_predicate
-          @predicate_matches = actual.__send__(method_name, *@args, &@block)
-        end
-
-        def predicate
-          :"#{@expected}?"
-        end
-
-        def present_tense_predicate
-          :"#{@expected}s?"
-        end
-
-        def parse_expected(expected)
-          @prefix, expected = prefix_and_expected(expected)
-          expected
-        end
-
-        def prefix_and_expected(symbol)
-          Matchers::BE_PREDICATE_REGEX.match(symbol.to_s).captures.compact
-        end
-
-        def prefix_to_sentence
-          split_words(@prefix)
-        end
-
-        def failure_message_expecting(value)
-          validity_message ||
-            "expected `#{@actual.inspect}.#{predicate}#{args_to_s}` to return #{value}, got #{@predicate_matches.inspect}"
-        end
-
-        def validity_message
-          if private_predicate?
-            "expected #{@actual} to respond to `#{predicate}` but `#{predicate}` is a private method"
-          elsif !predicate_exists?
-            "expected #{@actual} to respond to `#{predicate}`"
-          end
+        def perform_match(actual)
+          @actual = actual
+          @actual.__send__ @operator, @expected
         end
       end
     end

data/lib/rspec/matchers/built_in/be_between.rb

@@ -55,7 +55,7 @@ module RSpec
         # @api private
         # @return [String]
         def description
-          "be between #{@min.inspect} and #{@max.inspect} (#{@mode})"
+          "be between #{description_of @min} and #{description_of @max} (#{@mode})"
         end
 
       private

data/lib/rspec/matchers/built_in/be_instance_of.rb

@@ -14,7 +14,11 @@ module RSpec
       private
 
         def match(expected, actual)
-          actual.instance_of? expected
+          actual.instance_of?(expected)
+        rescue NoMethodError
+          raise ::ArgumentError, "The #{matcher_name} matcher requires that " \
+                                 "the actual object responds to #instance_of? method " \
+                                 "but a `NoMethodError` was encountered instead."
         end
       end
     end

data/lib/rspec/matchers/built_in/be_kind_of.rb

@@ -8,7 +8,11 @@ module RSpec
       private
 
         def match(expected, actual)
-          actual.kind_of? expected
+          actual.kind_of?(expected)
+        rescue NoMethodError
+          raise ::ArgumentError, "The #{matcher_name} matcher requires that " \
+                                 "the actual object responds to #kind_of? method " \
+                                 "but a `NoMethodError` was encountered instead."
         end
       end
     end

data/lib/rspec/matchers/built_in/be_within.rb

@@ -4,9 +4,7 @@ module RSpec
       # @api private
       # Provides the implementation for `be_within`.
       # Not intended to be instantiated directly.
-      class BeWithin
-        include Composable
-
+      class BeWithin < BaseMatcher
         def initialize(delta)
           @delta = delta
         end
@@ -25,7 +23,7 @@ module RSpec
         # a percent comparison.
         def percent_of(expected)
           @expected  = expected
-          @tolerance = @delta * @expected.abs / 100.0
+          @tolerance = @expected.abs * @delta / 100.0
           @unit      = '%'
           self
         end
@@ -40,24 +38,19 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected #{@actual.inspect} to #{description}#{not_numeric_clause}"
+          "expected #{actual_formatted} to #{description}#{not_numeric_clause}"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          "expected #{@actual.inspect} not to #{description}"
+          "expected #{actual_formatted} not to #{description}"
         end
 
         # @api private
         # @return [String]
         def description
-          "be within #{@delta}#{@unit} of #{@expected}"
-        end
-
-        # @private
-        def supports_block_expectations?
-          false
+          "be within #{@delta}#{@unit} of #{expected_formatted}"
         end
 
       private