rspec-expectations 2.11.3 → 3.11.0

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

@@ -1,72 +1,198 @@
+RSpec::Support.require_rspec_support "method_signature_verifier"
+
 module RSpec
   module Matchers
     module BuiltIn
-      class RespondTo
+      # @api private
+      # Provides the implementation for `respond_to`.
+      # Not intended to be instantiated directly.
+      class RespondTo < BaseMatcher
         def initialize(*names)
           @names = names
           @expected_arity = nil
+          @expected_keywords = []
+          @ignoring_method_signature_failure = false
+          @unlimited_arguments = nil
+          @arbitrary_keywords = nil
+        end
+
+        # @api public
+        # Specifies the number of expected arguments.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with(3).arguments
+        def with(n)
+          @expected_arity = n
+          self
+        end
+
+        # @api public
+        # Specifies keyword arguments, if any.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_keywords(:color, :shape)
+        # @example with an expected number of arguments
+        #   expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape)
+        def with_keywords(*keywords)
+          @expected_keywords = keywords
+          self
+        end
+        alias :and_keywords :with_keywords
+
+        # @api public
+        # Specifies that the method accepts any keyword, i.e. the method has
+        #   a splatted keyword parameter of the form **kw_args.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_any_keywords
+        def with_any_keywords
+          @arbitrary_keywords = true
+          self
         end
+        alias :and_any_keywords :with_any_keywords
 
+        # @api public
+        # Specifies that the number of arguments has no upper limit, i.e. the
+        #   method has a splatted parameter of the form *args.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_unlimited_arguments
+        def with_unlimited_arguments
+          @unlimited_arguments = true
+          self
+        end
+        alias :and_unlimited_arguments :with_unlimited_arguments
+
+        # @api public
+        # No-op. Intended to be used as syntactic sugar when using `with`.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with(3).arguments
+        def argument
+          self
+        end
+        alias :arguments :argument
+
+        # @private
         def matches?(actual)
           find_failing_method_names(actual, :reject).empty?
         end
-        alias == matches?
 
+        # @private
         def does_not_match?(actual)
           find_failing_method_names(actual, :select).empty?
         end
 
-        def failure_message_for_should
-          "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to respond to #{@failing_method_names.map { |name| description_of(name) }.join(', ')}#{with_arity}"
         end
 
-        def failure_message_for_should_not
-          failure_message_for_should.sub(/to respond to/, 'not to respond to')
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          failure_message.sub(/to respond to/, 'not to respond to')
         end
 
+        # @api private
+        # @return [String]
         def description
           "respond to #{pp_names}#{with_arity}"
         end
 
-        def with(n)
-          @expected_arity = n
-          self
-        end
-
-        def argument
-          self
+        # @api private
+        # Used by other matchers to suppress a check
+        def ignoring_method_signature_failure!
+          @ignoring_method_signature_failure = true
         end
-        alias :arguments :argument
 
-        private
+      private
 
         def find_failing_method_names(actual, filter_method)
           @actual = actual
-          @failing_method_names = @names.send(filter_method) do |name|
+          @failing_method_names = @names.__send__(filter_method) do |name|
             @actual.respond_to?(name) && matches_arity?(actual, name)
           end
         end
 
         def matches_arity?(actual, name)
-          return true unless @expected_arity
-
-          actual_arity = actual.method(name).arity
-          if actual_arity < 0
-            # ~ inverts the one's complement and gives us the number of required args
-            ~actual_arity <= @expected_arity
-          else
-            actual_arity == @expected_arity
-          end
+          ArityCheck.new(@expected_arity, @expected_keywords, @arbitrary_keywords, @unlimited_arguments).matches?(actual, name)
+        rescue NameError
+          return true if @ignoring_method_signature_failure
+          raise ArgumentError, "The #{matcher_name} matcher requires that " \
+                               "the actual object define the method(s) in " \
+                               "order to check arity, but the method " \
+                               "`#{name}` is not defined. Remove the arity " \
+                               "check or define the method to continue."
         end
 
         def with_arity
-          @expected_arity.nil?? "" :
-            " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+          str = ''.dup
+          str << " with #{with_arity_string}" if @expected_arity
+          str << " #{str.length == 0 ? 'with' : 'and'} #{with_keywords_string}" if @expected_keywords && @expected_keywords.count > 0
+          str << " #{str.length == 0 ? 'with' : 'and'} unlimited arguments" if @unlimited_arguments
+          str << " #{str.length == 0 ? 'with' : 'and'} any keywords" if @arbitrary_keywords
+          str
+        end
+
+        def with_arity_string
+          "#{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def with_keywords_string
+          kw_str = case @expected_keywords.count
+                   when 1
+                     @expected_keywords.first.inspect
+                   when 2
+                     @expected_keywords.map(&:inspect).join(' and ')
+                   else
+                     "#{@expected_keywords[0...-1].map(&:inspect).join(', ')}, and #{@expected_keywords.last.inspect}"
+                   end
+
+          "keyword#{@expected_keywords.count == 1 ? '' : 's'} #{kw_str}"
         end
 
         def pp_names
-          # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
-          @names.length == 1 ? "##{@names.first}" : @names.inspect
+          @names.length == 1 ? "##{@names.first}" : description_of(@names)
+        end
+
+        # @private
+        class ArityCheck
+          def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments)
+            expectation = Support::MethodSignatureExpectation.new
+
+            if expected_arity.is_a?(Range)
+              expectation.min_count = expected_arity.min
+              expectation.max_count = expected_arity.max
+            else
+              expectation.min_count = expected_arity
+            end
+
+            expectation.keywords = expected_keywords
+            expectation.expect_unlimited_arguments = unlimited_arguments
+            expectation.expect_arbitrary_keywords  = arbitrary_keywords
+            @expectation = expectation
+          end
+
+          def matches?(actual, name)
+            return true if @expectation.empty?
+            verifier_for(actual, name).with_expectation(@expectation).valid?
+          end
+
+          def verifier_for(actual, name)
+            Support::StrictSignatureVerifier.new(method_signature_for(actual, name))
+          end
+
+          def method_signature_for(actual, name)
+            method_handle = Support.method_handle_for(actual, name)
+
+            if name == :new && method_handle.owner === ::Class && ::Class === actual
+              Support::MethodSignature.new(actual.instance_method(:initialize))
+            else
+              Support::MethodSignature.new(method_handle)
+            end
+          end
         end
       end
     end

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

@@ -1,28 +1,58 @@
 module RSpec
   module Matchers
     module BuiltIn
-      class Satisfy
-        def initialize(&block)
+      # @api private
+      # Provides the implementation for `satisfy`.
+      # Not intended to be instantiated directly.
+      class Satisfy < BaseMatcher
+        def initialize(description=nil, &block)
+          @description = description
           @block = block
         end
 
+        # @private
         def matches?(actual, &block)
           @block = block if block
           @actual = actual
           @block.call(actual)
         end
-        alias == matches?
 
-        def failure_message_for_should
-          "expected #{@actual} to satisfy block"
+        # @private
+        def description
+          @description ||= "satisfy #{block_representation}"
         end
 
-        def failure_message_for_should_not
-          "expected #{@actual} not to satisfy block"
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{actual_formatted} to #{description}"
         end
 
-        def description
-          "satisfy block"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{actual_formatted} not to #{description}"
+        end
+
+      private
+
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          def block_representation
+            if (block_snippet = extract_block_snippet)
+              "expression `#{block_snippet}`"
+            else
+              'block'
+            end
+          end
+
+          def extract_block_snippet
+            return nil unless @block
+            Expectations::BlockSnippetExtractor.try_extracting_single_line_body_of(@block, matcher_name)
+          end
+        else
+          def block_representation
+            'block'
+          end
         end
       end
     end

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

@@ -0,0 +1,94 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Base class for the `end_with` and `start_with` matchers.
+      # Not intended to be instantiated directly.
+      class StartOrEndWith < BaseMatcher
+        def initialize(*expected)
+          @actual_does_not_have_ordered_elements = false
+          @expected = expected.length == 1 ? expected.first : expected
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          super.tap do |msg|
+            if @actual_does_not_have_ordered_elements
+              msg << ", but it does not have ordered elements"
+            elsif !actual.respond_to?(:[])
+              msg << ", but it cannot be indexed using #[]"
+            end
+          end
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          return super unless Hash === expected
+          english_name = EnglishPhrasing.split_words(self.class.matcher_name)
+          description_of_expected = surface_descriptions_in(expected).inspect
+          "#{english_name} #{description_of_expected}"
+        end
+
+      private
+
+        def match(_expected, actual)
+          return false unless actual.respond_to?(:[])
+
+          begin
+            return true if subsets_comparable? && subset_matches?
+            element_matches?
+          rescue ArgumentError
+            @actual_does_not_have_ordered_elements = true
+            return false
+          end
+        end
+
+        def subsets_comparable?
+          # Structs support the Enumerable interface but don't really have
+          # the semantics of a subset of a larger set...
+          return false if Struct === expected
+
+          expected.respond_to?(:length)
+        end
+      end
+
+      # For RSpec 3.1, the base class was named `StartAndEndWith`. For SemVer reasons,
+      # we still provide this constant until 4.0.
+      # @deprecated Use StartOrEndWith instead.
+      # @private
+      StartAndEndWith = StartOrEndWith
+
+      # @api private
+      # Provides the implementation for `start_with`.
+      # Not intended to be instantiated directly.
+      class StartWith < StartOrEndWith
+      private
+
+        def subset_matches?
+          values_match?(expected, actual[0, expected.length])
+        end
+
+        def element_matches?
+          values_match?(expected, actual[0])
+        end
+      end
+
+      # @api private
+      # Provides the implementation for `end_with`.
+      # Not intended to be instantiated directly.
+      class EndWith < StartOrEndWith
+      private
+
+        def subset_matches?
+          values_match?(expected, actual[-expected.length, expected.length])
+        end
+
+        def element_matches?
+          values_match?(expected, actual[-1])
+        end
+      end
+    end
+  end
+end

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

@@ -1,14 +1,24 @@
 module RSpec
   module Matchers
     module BuiltIn
+      # @api private
+      # Provides the implementation for `throw_symbol`.
+      # Not intended to be instantiated directly.
       class ThrowSymbol
-        def initialize(expected_symbol = nil, expected_arg=nil)
+        include Composable
+
+        def initialize(expected_symbol=nil, expected_arg=nil)
           @expected_symbol = expected_symbol
           @expected_arg = expected_arg
           @caught_symbol = @caught_arg = nil
         end
 
+        # rubocop:disable MethodLength
+        # @private
         def matches?(given_proc)
+          @block = given_proc
+          return false unless Proc === given_proc
+
           begin
             if @expected_symbol.nil?
               given_proc.call
@@ -30,44 +40,78 @@ module RSpec
             # Ruby 1.8 uses NameError with `symbol'
             # Ruby 1.9 uses ArgumentError with :symbol
           rescue NameError, ArgumentError => e
-            unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+            unless (match_data = e.message.match(/uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/))
               other_exception = e
               raise
             end
-            @caught_symbol = $2.to_sym
+            @caught_symbol = match_data.captures[1].to_sym
           rescue => other_exception
             raise
           ensure
+            # rubocop:disable EnsureReturn
             unless other_exception
               if @expected_symbol.nil?
-                return !@caught_symbol.nil?
+                return !!@caught_symbol
               else
                 if @expected_arg.nil?
                   return @caught_symbol == @expected_symbol
                 else
-                  return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+                  return (@caught_symbol == @expected_symbol) && values_match?(@expected_arg, @caught_arg)
                 end
               end
             end
+            # rubocop:enable EnsureReturn
           end
         end
-        alias == matches?
+        # rubocop:enable MethodLength
+
+        def does_not_match?(given_proc)
+          !matches?(given_proc) && Proc === given_proc
+        end
 
-        def failure_message_for_should
-          "expected #{expected} to be thrown, got #{caught}"
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{expected} to be thrown, #{actual_result}"
         end
 
-        def failure_message_for_should_not
-          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, #{actual_result}"
         end
 
+        # @api private
+        # @return [String]
         def description
           "throw #{expected}"
         end
 
-        private
+        # @api private
+        # Indicates this matcher matches against a block.
+        # @return [True]
+        def supports_block_expectations?
+          true
+        end
+
+        # @api private
+        def supports_value_expectations?
+          false
+        end
+
+        # @api private
+        def expects_call_stack_jump?
+          true
+        end
+
+      private
+
+        def actual_result
+          return "but was not a block" unless Proc === @block
+          "got #{caught}"
+        end
 
-        def expected(symbol_desc = 'a Symbol')
+        def expected(symbol_desc='a Symbol')
           throw_description(@expected_symbol || symbol_desc, @expected_arg)
         end
 
@@ -76,10 +120,10 @@ module RSpec
         end
 
         def throw_description(symbol, arg)
-          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+          symbol_description = symbol.is_a?(String) ? symbol : description_of(symbol)
 
           arg_description = if arg
-                              " with #{arg.inspect}"
+                              " with #{description_of arg}"
                             elsif @expected_arg && @caught_symbol == @expected_symbol
                               " with no argument"
                             else