rspec-expectations 2.14.0 → 3.13.0

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

@@ -1,29 +1,52 @@
+require 'rspec/matchers/built_in/count_expectation'
+
+RSpec::Support.require_rspec_support 'method_signature_verifier'
+
 module RSpec
   module Matchers
     module BuiltIn
+      # @private
+      # Object that is yielded to `expect` when one of the
+      # yield matchers is used. Provides information about
+      # the yield behavior of the object-under-test.
       class YieldProbe
-        def self.probe(block)
-          probe = new
-          assert_valid_expect_block!(block)
-          block.call(probe)
-          probe.assert_used!
-          probe
+        def self.probe(block, &callback)
+          probe = new(block, &callback)
+          return probe unless probe.has_block?
+          probe.probe
         end
 
         attr_accessor :num_yields, :yielded_args
 
-        def initialize
+        def initialize(block, &callback)
+          @block = block
+          @callback = callback || Proc.new {}
           @used = false
-          self.num_yields, self.yielded_args = 0, []
+          self.num_yields = 0
+          self.yielded_args = []
+        end
+
+        def has_block?
+          Proc === @block
+        end
+
+        def probe
+          assert_valid_expect_block!
+          @block.call(self)
+          assert_used!
+          self
         end
 
         def to_proc
           @used = true
 
           probe = self
+          callback = @callback
           Proc.new do |*args|
             probe.num_yields += 1
             probe.yielded_args << args
+            callback.call(*args)
+            nil # to indicate the block does not return a meaningful value
           end
         end
 
@@ -36,261 +59,317 @@ module RSpec
           when 1 then true
           when 0 then false
           else
-            raise "The #{matcher_name} matcher is not designed to be used with a " +
-                  "method that yields multiple times. Use the yield_successive_args " +
-                  "matcher for that case."
-          end
-        end
-
-        def successive_yield_args
-          yielded_args.map do |arg_array|
-            arg_array.size == 1 ? arg_array.first : arg_array
+            raise "The #{matcher_name} matcher is not designed to be used with a " \
+                  'method that yields multiple times. Use the yield_successive_args ' \
+                  'matcher for that case.'
           end
         end
 
         def assert_used!
           return if @used
-          raise "You must pass the argument yielded to your expect block on " +
-                "to the method-under-test as a block. It acts as a probe that " +
-                "allows the matcher to detect whether or not the method-under-test " +
-                "yields, and, if so, how many times, and what the yielded arguments " +
-                "are."
-        end
-
-        def self.assert_valid_expect_block!(block)
-          return if block.arity == 1
-          raise "Your expect block must accept an argument to be used with this " +
-                "matcher. Pass the argument as a block on to the method you are testing."
+          raise 'You must pass the argument yielded to your expect block on ' \
+                'to the method-under-test as a block. It acts as a probe that ' \
+                'allows the matcher to detect whether or not the method-under-test ' \
+                'yields, and, if so, how many times, and what the yielded arguments ' \
+                'are.'
+        end
+
+        if RUBY_VERSION.to_f > 1.8
+          def assert_valid_expect_block!
+            block_signature = RSpec::Support::BlockSignature.new(@block)
+            return if RSpec::Support::StrictSignatureVerifier.new(block_signature, [self]).valid?
+            raise 'Your expect block must accept an argument to be used with this ' \
+                  'matcher. Pass the argument as a block on to the method you are testing.'
+          end
+        else
+          # :nocov:
+          # On 1.8.7, `lambda { }.arity` and `lambda { |*a| }.arity` both return -1,
+          # so we can't distinguish between accepting no args and an arg splat.
+          # It's OK to skip, this, though; it just provides a nice error message
+          # when the user forgets to accept an arg in their block. They'll still get
+          # the `assert_used!` error message from above, which is sufficient.
+          def assert_valid_expect_block!
+            # nothing to do
+          end
+          # :nocov:
         end
       end
 
+      # @api private
+      # Provides the implementation for `yield_control`.
+      # Not intended to be instantiated directly.
       class YieldControl < BaseMatcher
-        def initialize
-          @expectation_type = nil
-          @expected_yields_count = nil
-        end
-
+        include CountExpectation
+        # @private
         def matches?(block)
-          probe = YieldProbe.probe(block)
-
-          if @expectation_type
-            probe.num_yields.send(@expectation_type, @expected_yields_count)
-          else
-            probe.yielded_once?(:yield_control)
-          end
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+          expected_count_matches?(@probe.num_yields)
         end
 
-        def once
-          exactly(1)
-          self
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
         end
 
-        def twice
-          exactly(2)
-          self
+        # @api private
+        # @return [String]
+        def failure_message
+          'expected given block to yield control' + failure_reason
         end
 
-        def exactly(number)
-          set_expected_yields_count(:==, number)
-          self
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          'expected given block not to yield control' + failure_reason
         end
 
-        def at_most(number)
-          set_expected_yields_count(:<=, number)
-          self
+        # @private
+        def supports_block_expectations?
+          true
         end
 
-        def at_least(number)
-          set_expected_yields_count(:>=, number)
-          self
+        # @private
+        def supports_value_expectations?
+          false
         end
 
-        def times
-          self
-        end
+      private
 
-        def failure_message_for_should
-          'expected given block to yield control'.tap do |failure_message|
-            failure_message << relativity_failure_message
-          end
+        def failure_reason
+          return ' but was not a block' unless @probe.has_block?
+          return "#{count_expectation_description} but did not yield" if @probe.num_yields == 0
+          count_failure_reason('yielded')
         end
+      end
 
-        def failure_message_for_should_not
-          'expected given block not to yield control'.tap do |failure_message|
-            failure_message << relativity_failure_message
-          end
+      # @api private
+      # Provides the implementation for `yield_with_no_args`.
+      # Not intended to be instantiated directly.
+      class YieldWithNoArgs < BaseMatcher
+        # @private
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          return false unless @probe.has_block?
+          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
         end
 
-        private
-
-        def set_expected_yields_count(relativity, n)
-          @expectation_type = relativity
-          @expected_yields_count = case n
-                                   when Numeric then n
-                                   when :once then 1
-                                   when :twice then 2
-                                   end
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
         end
 
-        def relativity_failure_message
-          return '' unless @expected_yields_count
-          " #{human_readable_expecation_type}#{human_readable_count}"
+        # @private
+        def failure_message
+          "expected given block to yield with no arguments, but #{positive_failure_reason}"
         end
 
-        def human_readable_expecation_type
-          case @expectation_type
-          when :<= then 'at most '
-          when :>= then 'at least '
-          else ''
-          end
+        # @private
+        def failure_message_when_negated
+          "expected given block not to yield with no arguments, but #{negative_failure_reason}"
         end
 
-        def human_readable_count
-          case @expected_yields_count
-          when 1 then "once"
-          when 2 then "twice"
-          else "#{@expected_yields_count} times"
-          end
+        # @private
+        def supports_block_expectations?
+          true
         end
-      end
-
-      class YieldWithNoArgs < BaseMatcher
 
-        def matches?(block)
-          @probe = YieldProbe.probe(block)
-          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
+        # @private
+        def supports_value_expectations?
+          false
         end
 
-        def failure_message_for_should
-          "expected given block to yield with no arguments, but #{failure_reason}"
-        end
+      private
 
-        def failure_message_for_should_not
-          "expected given block not to yield with no arguments, but did"
+        def positive_failure_reason
+          return 'was not a block' unless @probe.has_block?
+          return 'did not yield' if @probe.num_yields.zero?
+          "yielded with arguments: #{description_of @probe.single_yield_args}"
         end
 
-      private
-
-        def failure_reason
-          if @probe.num_yields.zero?
-            "did not yield"
-          else
-            "yielded with arguments: #{@probe.single_yield_args.inspect}"
-          end
+        def negative_failure_reason
+          return 'was not a block' unless @probe.has_block?
+          'did'
         end
       end
 
-      class YieldWithArgs
+      # @api private
+      # Provides the implementation for `yield_with_args`.
+      # Not intended to be instantiated directly.
+      class YieldWithArgs < BaseMatcher
         def initialize(*args)
           @expected = args
         end
 
+        # @private
         def matches?(block)
-          @probe = YieldProbe.probe(block)
-          @actual = @probe.single_yield_args
-          @probe.yielded_once?(:yield_with_args) && args_match?
+          @args_matched_when_yielded = true
+          @probe = YieldProbe.new(block) do
+            @actual = @probe.single_yield_args
+            @actual_formatted = actual_formatted
+            @args_matched_when_yielded &&= args_currently_match?
+          end
+          return false unless @probe.has_block?
+          @probe.probe
+          @probe.yielded_once?(:yield_with_args) && @args_matched_when_yielded
+        end
+
+        # @private
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
         end
-        alias == matches?
 
-        def failure_message_for_should
+        # @private
+        def failure_message
           "expected given block to yield with arguments, but #{positive_failure_reason}"
         end
 
-        def failure_message_for_should_not
+        # @private
+        def failure_message_when_negated
           "expected given block not to yield with arguments, but #{negative_failure_reason}"
         end
 
+        # @private
         def description
-          desc = "yield with args"
-          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")" unless @expected.empty?
+          desc = 'yield with args'
+          desc = "#{desc}(#{expected_arg_description})" unless @expected.empty?
           desc
         end
 
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def positive_failure_reason
-          if @probe.num_yields.zero?
-            "did not yield"
-          else
-            @positive_args_failure
-          end
+          return 'was not a block' unless @probe.has_block?
+          return 'did not yield' if @probe.num_yields.zero?
+          @positive_args_failure
+        end
+
+        def expected_arg_description
+          @expected.map { |e| description_of e }.join(', ')
         end
 
         def negative_failure_reason
-          if all_args_match?
-            "yielded with expected arguments" +
-              "\nexpected not: #{@expected.inspect}" +
-              "\n         got: #{@actual.inspect} (compared using === and ==)"
+          if !@probe.has_block?
+            'was not a block'
+          elsif @args_matched_when_yielded && !@expected.empty?
+            'yielded with expected arguments' \
+              "\nexpected not: #{surface_descriptions_in(@expected).inspect}" \
+              "\n         got: #{@actual_formatted}"
           else
-            "did"
+            'did'
           end
         end
 
-        def args_match?
+        def args_currently_match?
           if @expected.empty? # expect {...}.to yield_with_args
-            @positive_args_failure = "yielded with no arguments" if @actual.empty?
+            @positive_args_failure = 'yielded with no arguments' if @actual.empty?
             return !@actual.empty?
           end
 
-          unless match = all_args_match?
-            @positive_args_failure = "yielded with unexpected arguments" +
-              "\nexpected: #{@expected.inspect}" +
-              "\n     got: #{@actual.inspect} (compared using === and ==)"
+          unless (match = all_args_match?)
+            @positive_args_failure = 'yielded with unexpected arguments' \
+              "\nexpected: #{surface_descriptions_in(@expected).inspect}" \
+              "\n     got: #{@actual_formatted}"
           end
 
           match
         end
 
         def all_args_match?
-          return false if @expected.size != @actual.size
-
-          @expected.zip(@actual).all? do |expected, actual|
-            expected === actual || actual == expected
-          end
+          values_match?(@expected, @actual)
         end
       end
 
-      class YieldSuccessiveArgs
+      # @api private
+      # Provides the implementation for `yield_successive_args`.
+      # Not intended to be instantiated directly.
+      class YieldSuccessiveArgs < BaseMatcher
         def initialize(*args)
           @expected = args
         end
 
+        # @private
         def matches?(block)
-          @probe = YieldProbe.probe(block)
-          @actual = @probe.successive_yield_args
-          args_match?
+          @actual_formatted = []
+          @actual = []
+          args_matched_when_yielded = true
+          yield_count = 0
+
+          @probe = YieldProbe.probe(block) do |*arg_array|
+            arg_or_args = arg_array.size == 1 ? arg_array.first : arg_array
+            @actual_formatted << RSpec::Support::ObjectFormatter.format(arg_or_args)
+            @actual << arg_or_args
+            args_matched_when_yielded &&= values_match?(@expected[yield_count], arg_or_args)
+            yield_count += 1
+          end
+
+          return false unless @probe.has_block?
+          args_matched_when_yielded && yield_count == @expected.length
         end
-        alias == matches?
 
-        def failure_message_for_should
-          "expected given block to yield successively with arguments, but yielded with unexpected arguments" +
-            "\nexpected: #{@expected.inspect}" +
-            "\n     got: #{@actual.inspect} (compared using === and ==)"
+        def does_not_match?(block)
+          !matches?(block) && @probe.has_block?
         end
 
-        def failure_message_for_should_not
-          "expected given block not to yield successively with arguments, but yielded with expected arguments" +
-              "\nexpected not: #{@expected.inspect}" +
-              "\n         got: #{@actual.inspect} (compared using === and ==)"
+        # @private
+        def failure_message
+          'expected given block to yield successively with arguments, ' \
+          "but #{positive_failure_reason}"
         end
 
+        # @private
+        def failure_message_when_negated
+          'expected given block not to yield successively with arguments, ' \
+          "but #{negative_failure_reason}"
+        end
+
+        # @private
         def description
-          desc = "yield successive args"
-          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")"
-          desc
+          "yield successive args(#{expected_arg_description})"
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        # @private
+        def supports_value_expectations?
+          false
         end
 
       private
 
-        def args_match?
-          return false if @expected.size != @actual.size
+        def expected_arg_description
+          @expected.map { |e| description_of e }.join(', ')
+        end
 
-          @expected.zip(@actual).all? do |expected, actual|
-            expected === actual || actual == expected
-          end
+        def positive_failure_reason
+          return 'was not a block' unless @probe.has_block?
+
+          'yielded with unexpected arguments' \
+          "\nexpected: #{surface_descriptions_in(@expected).inspect}" \
+          "\n     got: [#{@actual_formatted.join(", ")}]"
+        end
+
+        def negative_failure_reason
+          return 'was not a block' unless @probe.has_block?
+
+          'yielded with expected arguments' \
+          "\nexpected not: #{surface_descriptions_in(@expected).inspect}" \
+          "\n         got: [#{@actual_formatted.join(", ")}]"
         end
       end
     end
   end
 end
-

data/lib/rspec/matchers/built_in.rb

@@ -1,39 +1,53 @@
+RSpec::Support.require_rspec_matchers "built_in/base_matcher"
+
 module RSpec
   module Matchers
+    # Container module for all built-in matchers. The matcher classes are here
+    # (rather than directly under `RSpec::Matchers`) in order to prevent name
+    # collisions, since `RSpec::Matchers` gets included into the user's namespace.
+    #
+    # Autoloading is used to delay when the matcher classes get loaded, allowing
+    # rspec-matchers to boot faster, and avoiding loading matchers the user is
+    # not using.
     module BuiltIn
-      require 'rspec/matchers/built_in/base_matcher'
-      autoload :BeAnInstanceOf, 'rspec/matchers/built_in/be_instance_of'
-      autoload :Be,             'rspec/matchers/built_in/be'
-      autoload :BeTrue,         'rspec/matchers/built_in/be'
-      autoload :BeFalse,        'rspec/matchers/built_in/be'
-      autoload :BeNil,          'rspec/matchers/built_in/be'
-      autoload :BeComparedTo,   'rspec/matchers/built_in/be'
-      autoload :BePredicate,    'rspec/matchers/built_in/be'
-      autoload :BeAKindOf,      'rspec/matchers/built_in/be_kind_of'
-      autoload :BeWithin,       'rspec/matchers/built_in/be_within'
-      autoload :Change,         'rspec/matchers/built_in/change'
-      autoload :Cover,          'rspec/matchers/built_in/cover' if (1..2).respond_to?(:cover?)
-      autoload :Eq,             'rspec/matchers/built_in/eq'
-      autoload :Eql,            'rspec/matchers/built_in/eql'
-      autoload :Equal,          'rspec/matchers/built_in/equal'
-      autoload :Exist,          'rspec/matchers/built_in/exist'
-      autoload :Has,            'rspec/matchers/built_in/has'
-      autoload :Have,           'rspec/matchers/built_in/have'
-      autoload :Include,        'rspec/matchers/built_in/include'
-      autoload :Match,          'rspec/matchers/built_in/match'
-      autoload :MatchArray,     'rspec/matchers/built_in/match_array'
-      autoload :RaiseError,     'rspec/matchers/built_in/raise_error'
-      autoload :RespondTo,      'rspec/matchers/built_in/respond_to'
-      autoload :StartWith,      'rspec/matchers/built_in/start_and_end_with'
-      autoload :EndWith,        'rspec/matchers/built_in/start_and_end_with'
-      autoload :Satisfy,        'rspec/matchers/built_in/satisfy'
-      autoload :ThrowSymbol,    'rspec/matchers/built_in/throw_symbol'
-      autoload :YieldControl,   'rspec/matchers/built_in/yield'
-      autoload :YieldWithArgs,  'rspec/matchers/built_in/yield'
-      autoload :YieldWithNoArgs, 'rspec/matchers/built_in/yield'
-      autoload :YieldSuccessiveArgs, 'rspec/matchers/built_in/yield'
+      autoload :BeAKindOf,               'rspec/matchers/built_in/be_kind_of'
+      autoload :BeAnInstanceOf,          'rspec/matchers/built_in/be_instance_of'
+      autoload :BeBetween,               'rspec/matchers/built_in/be_between'
+      autoload :Be,                      'rspec/matchers/built_in/be'
+      autoload :BeComparedTo,            'rspec/matchers/built_in/be'
+      autoload :BeFalsey,                'rspec/matchers/built_in/be'
+      autoload :BeHelpers,               'rspec/matchers/built_in/be'
+      autoload :BeNil,                   'rspec/matchers/built_in/be'
+      autoload :BePredicate,             'rspec/matchers/built_in/has'
+      autoload :BeTruthy,                'rspec/matchers/built_in/be'
+      autoload :BeWithin,                'rspec/matchers/built_in/be_within'
+      autoload :Change,                  'rspec/matchers/built_in/change'
+      autoload :Compound,                'rspec/matchers/built_in/compound'
+      autoload :ContainExactly,          'rspec/matchers/built_in/contain_exactly'
+      autoload :Cover,                   'rspec/matchers/built_in/cover'
+      autoload :EndWith,                 'rspec/matchers/built_in/start_or_end_with'
+      autoload :Eq,                      'rspec/matchers/built_in/eq'
+      autoload :Eql,                     'rspec/matchers/built_in/eql'
+      autoload :Equal,                   'rspec/matchers/built_in/equal'
+      autoload :Exist,                   'rspec/matchers/built_in/exist'
+      autoload :Has,                     'rspec/matchers/built_in/has'
+      autoload :HaveAttributes,          'rspec/matchers/built_in/have_attributes'
+      autoload :Include,                 'rspec/matchers/built_in/include'
+      autoload :All,                     'rspec/matchers/built_in/all'
+      autoload :Match,                   'rspec/matchers/built_in/match'
+      autoload :NegativeOperatorMatcher, 'rspec/matchers/built_in/operators'
+      autoload :OperatorMatcher,         'rspec/matchers/built_in/operators'
+      autoload :Output,                  'rspec/matchers/built_in/output'
+      autoload :PositiveOperatorMatcher, 'rspec/matchers/built_in/operators'
+      autoload :RaiseError,              'rspec/matchers/built_in/raise_error'
+      autoload :RespondTo,               'rspec/matchers/built_in/respond_to'
+      autoload :Satisfy,                 'rspec/matchers/built_in/satisfy'
+      autoload :StartWith,               'rspec/matchers/built_in/start_or_end_with'
+      autoload :ThrowSymbol,             'rspec/matchers/built_in/throw_symbol'
+      autoload :YieldControl,            'rspec/matchers/built_in/yield'
+      autoload :YieldSuccessiveArgs,     'rspec/matchers/built_in/yield'
+      autoload :YieldWithArgs,           'rspec/matchers/built_in/yield'
+      autoload :YieldWithNoArgs,         'rspec/matchers/built_in/yield'
     end
   end
 end
-
-