rspec-mocks 2.99.4 → 3.0.0.beta1

data/lib/rspec/mocks/extensions/marshal.rb

@@ -6,21 +6,6 @@ module Marshal
       if ::RSpec::Mocks.space.nil? || !::RSpec::Mocks.space.registered?(object) || NilClass === object
         dump_without_mocks(object, *rest)
       else
-        unless ::RSpec::Mocks.configuration.marshal_patched?
-          RSpec.warn_deprecation(<<-EOS.gsub(/^\s+\|/, ''))
-            |Using Marshal.dump on stubbed objects relies on a monkey-patch
-            |that is being made opt-in in RSpec 3. To silence this warning
-            |please explicitly enable it:
-            |
-            |RSpec.configure do |rspec|
-            |  rspec.mock_with :rspec do |mocks|
-            |    mocks.patch_marshal_to_support_partial_doubles = true
-            |  end
-            |end
-            |
-            |Called from #{RSpec::CallerFilter.first_non_rspec_line}."
-          EOS
-        end
         dump_without_mocks(object.dup, *rest)
       end
     end

data/lib/rspec/mocks/framework.rb

@@ -2,10 +2,8 @@
 # supports wrapping rspec's mocking functionality without invading every
 # object in the system.
 
-require 'rspec/mocks/caller_filter' unless defined?(::RSpec::CallerFilter)
-require 'rspec/mocks/deprecation'
-require 'rspec/mocks/extensions/instance_exec'
-require 'rspec/mocks/extensions/proc'
+require 'rspec/support/caller_filter'
+require 'rspec/support/warnings'
 require 'rspec/mocks/instance_method_stasher'
 require 'rspec/mocks/method_double'
 require 'rspec/mocks/argument_matchers'
@@ -30,7 +28,9 @@ require 'rspec/mocks/any_instance/recorder'
 require 'rspec/mocks/mutate_const'
 require 'rspec/mocks/matchers/have_received'
 require 'rspec/mocks/matchers/receive'
+require 'rspec/mocks/matchers/receive_messages'
 require 'rspec/mocks/stub_chain'
 require 'rspec/mocks/targets'
 require 'rspec/mocks/syntax'
 require 'rspec/mocks/configuration'
+require 'rspec/mocks/verifying_double'

data/lib/rspec/mocks/instance_method_stasher.rb

@@ -2,91 +2,109 @@ module RSpec
   module Mocks
     # @private
     class InstanceMethodStasher
-      def initialize(klass, method)
-        @klass = klass
+      def initialize(object, method)
+        @object = object
         @method = method
+        @klass = (class << object; self; end)
 
+        @original_method = nil
         @method_is_stashed = false
       end
 
-      # @private
-      def method_is_stashed?
-        @method_is_stashed
-      end
+      attr_reader :original_method
 
-      # @private
-      def stash
-        return if !method_defined_directly_on_klass? || @method_is_stashed
-
-        @klass.__send__(:alias_method, stashed_method_name, @method)
-        @method_is_stashed = true
-      end
+      if RUBY_VERSION.to_f < 1.9
+        # @private
+        def method_is_stashed?
+          @method_is_stashed
+        end
 
-      private
+        # @private
+        def stash
+          return if !method_defined_directly_on_klass? || @method_is_stashed
 
-      # @private
-      def method_defined_directly_on_klass?
-        method_defined_on_klass? && method_owned_by_klass?
-      end
+          @klass.__send__(:alias_method, stashed_method_name, @method)
+          @method_is_stashed = true
+        end
 
-      # @private
-      def method_defined_on_klass?(klass = @klass)
-        klass.method_defined?(@method) || klass.private_method_defined?(@method)
-      end
+        # @private
+        def stashed_method_name
+          "obfuscated_by_rspec_mocks__#{@method}"
+        end
+        private :stashed_method_name
 
-      if ::UnboundMethod.method_defined?(:owner)
         # @private
-        def method_owned_by_klass?
-          owner = @klass.instance_method(@method).owner
-
-          # On Ruby 2.0.0+ the owner of a method on a class which has been
-          # `prepend`ed may actually be an instance, e.g.
-          # `#<MyClass:0x007fbb94e3cd10>`, rather than the expected `MyClass`.
-          owner = owner.class unless owner.is_a? Class
-
-          # On 1.8 (and some 1.9s -- e.g. rubinius) aliased methods
-          # can report the wrong owner. Example:
-          # class MyClass
-          #   class << self
-          #     alias alternate_new new
-          #   end
-          # end
-          #
-          # MyClass.owner(:alternate_new) returns `Class` on 1.8,
-          # but we need to consider the owner to be `MyClass` because
-          # it is not actually available on `Class` but is on `MyClass`.
-          # Hence, we verify that the owner actually has the method defined.
-          # If the given owner does not have the method defined, we assume
-          # that the method is actually owned by @klass.
-          owner == @klass || !(method_defined_on_klass?(owner))
+        def restore
+          return unless @method_is_stashed
+
+          if @klass.__send__(:method_defined?, @method)
+            @klass.__send__(:undef_method, @method)
+          end
+          @klass.__send__(:alias_method, @method, stashed_method_name)
+          @klass.__send__(:remove_method, stashed_method_name)
+          @method_is_stashed = false
         end
       else
+
+        # @private
+        def method_is_stashed?
+          !!@original_method
+        end
+
         # @private
-        def method_owned_by_klass?
-          # On 1.8.6, which does not support Method#owner, we have no choice but
-          # to assume it's defined on the klass even if it may be defined on
-          # a superclass.
-          true
+        def stash
+          return if !method_defined_directly_on_klass?
+          @original_method ||= ::RSpec::Mocks.method_handle_for(@object, @method)
+        end
+
+        # @private
+        def restore
+          return unless @original_method
+
+          if @klass.__send__(:method_defined?, @method)
+            @klass.__send__(:undef_method, @method)
+          end
+
+          @klass.__send__(:define_method, @method, @original_method)
+          @original_method = nil
         end
       end
 
-      public
+      private
 
       # @private
-      def stashed_method_name
-        "obfuscated_by_rspec_mocks__#{@method}"
+      def method_defined_directly_on_klass?
+        method_defined_on_klass? && method_owned_by_klass?
       end
 
       # @private
-      def restore
-        return unless @method_is_stashed
+      def method_defined_on_klass?(klass = @klass)
+        klass.method_defined?(@method) || klass.private_method_defined?(@method)
+      end
 
-        if @klass.__send__(:method_defined?, @method)
-          @klass.__send__(:undef_method, @method)
-        end
-        @klass.__send__(:alias_method, @method, stashed_method_name)
-        @klass.__send__(:remove_method, stashed_method_name)
-        @method_is_stashed = false
+      def method_owned_by_klass?
+        owner = @klass.instance_method(@method).owner
+
+        # On Ruby 2.0.0+ the owner of a method on a class which has been
+        # `prepend`ed may actually be an instance, e.g.
+        # `#<MyClass:0x007fbb94e3cd10>`, rather than the expected `MyClass`.
+        owner = owner.class unless Module === owner
+
+        # On some 1.9s (e.g. rubinius) aliased methods
+        # can report the wrong owner. Example:
+        # class MyClass
+        #   class << self
+        #     alias alternate_new new
+        #   end
+        # end
+        #
+        # MyClass.owner(:alternate_new) returns `Class` when incorrect,
+        # but we need to consider the owner to be `MyClass` because
+        # it is not actually available on `Class` but is on `MyClass`.
+        # Hence, we verify that the owner actually has the method defined.
+        # If the given owner does not have the method defined, we assume
+        # that the method is actually owned by @klass.
+        owner == @klass || !(method_defined_on_klass?(owner))
       end
     end
   end

data/lib/rspec/mocks/matchers/have_received.rb

@@ -4,25 +4,31 @@ module RSpec
       class HaveReceived
         COUNT_CONSTRAINTS = %w(exactly at_least at_most times once twice)
         ARGS_CONSTRAINTS = %w(with)
-        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS
+        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS + %w(ordered)
 
-        def initialize(method_name)
+        def initialize(method_name, &block)
           @method_name = method_name
+          @block = block
           @constraints = []
           @subject = nil
         end
 
-        def matches?(subject)
+        def name
+          "have_received"
+        end
+
+        def matches?(subject, &block)
+          @block ||= block
           @subject = subject
           @expectation = expect
-          expected_messages_received?
+          expected_messages_received_in_order?
         end
 
         def does_not_match?(subject)
           @subject = subject
           ensure_count_unconstrained
           @expectation = expect.never
-          expected_messages_received?
+          expected_messages_received_in_order?
         end
 
         def failure_message
@@ -44,14 +50,12 @@ module RSpec
           end
         end
 
-        private
+      private
 
         def expect
-          @expect ||= begin
-            expectation = mock_proxy.build_expectation(@method_name)
-            apply_constraints_to expectation
-            expectation
-          end
+          expectation = mock_proxy.build_expectation(@method_name)
+          apply_constraints_to expectation
+          expectation
         end
 
         def apply_constraints_to(expectation)
@@ -80,9 +84,9 @@ module RSpec
           error.message
         end
 
-        def expected_messages_received?
-          mock_proxy.replay_received_message_on @expectation
-          @expectation.expected_messages_received?
+        def expected_messages_received_in_order?
+          mock_proxy.replay_received_message_on @expectation, &@block
+          @expectation.expected_messages_received? && @expectation.ensure_expected_ordering_received!
         end
 
         def mock_proxy

data/lib/rspec/mocks/matchers/receive.rb

@@ -6,10 +6,20 @@ module RSpec
           @message                 = message
           @block                   = block
           @recorded_customizations = []
-          @backtrace_line          = CallerFilter.first_non_rspec_line
+
+          # MRI, JRuby and RBX report the caller inconsistently; MRI
+          # reports an extra "in `new'" line in the backtrace that the
+          # others do not include. The safest way to find the right
+          # line is to search for the first line BEFORE rspec/mocks/syntax.rb.
+          @backtrace_line = CallerFilter.first_non_rspec_line
+        end
+
+        def name
+          "receive"
         end
 
         def setup_expectation(subject, &block)
+          warn_if_any_instance("expect", subject)
           setup_mock_proxy_method_substitute(subject, :add_message_expectation, block)
         end
         alias matches? setup_expectation
@@ -19,11 +29,14 @@ module RSpec
           # where `and_return` is meant to raise an error
           @recorded_customizations.unshift Customization.new(:never, [], nil)
 
+          warn_if_any_instance("expect", subject)
+
           setup_expectation(subject, &block)
         end
         alias does_not_match? setup_negative_expectation
 
         def setup_allowance(subject, &block)
+          warn_if_any_instance("allow", subject)
           setup_mock_proxy_method_substitute(subject, :add_stub, block)
         end
 
@@ -42,16 +55,25 @@ module RSpec
         MessageExpectation.public_instance_methods(false).each do |method|
           next if method_defined?(method)
 
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(*args, &block)
-              @recorded_customizations << Customization.new(#{method.inspect}, args, block)
-              self
-            end
-          RUBY
+          define_method(method) do |*args, &block|
+            @recorded_customizations << Customization.new(method, args, block)
+            self
+          end
         end
 
       private
 
+        def warn_if_any_instance(expression, subject)
+          if AnyInstance::Recorder === subject
+            RSpec.warning(
+              "`#{expression}(#{subject.klass}.any_instance).to` " <<
+              "is probably not what you meant, it does not operate on " <<
+              "any instance of `#{subject.klass}`. " <<
+              "Use `#{expression}_any_instance_of(#{subject.klass}).to` instead."
+            )
+          end
+        end
+
         def setup_mock_proxy_method_substitute(subject, method, block)
           proxy = ::RSpec::Mocks.proxy_for(subject)
           setup_method_substitute(proxy, method, block, @backtrace_line)

data/lib/rspec/mocks/matchers/receive_messages.rb

@@ -0,0 +1,72 @@
+module RSpec
+  module Mocks
+    module Matchers
+      class ReceiveMessages
+
+        def initialize(message_return_value_hash)
+          @message_return_value_hash = message_return_value_hash
+          @backtrace_line = CallerFilter.first_non_rspec_line
+        end
+
+        def name
+          "receive_messages"
+        end
+
+        def setup_expectation(subject)
+          warn_about_block if block_given?
+          each_message_on( proxy_on(subject) ) do |host, message, return_value|
+            host.add_simple_expectation(message, return_value, @backtrace_line)
+          end
+        end
+        alias matches? setup_expectation
+
+        def setup_negative_expectation(subject)
+          raise NegationUnsupportedError,
+            "`expect(...).to_not receive_messages` is not supported since it " +
+            "doesn't really make sense. What would it even mean?"
+        end
+        alias does_not_match? setup_negative_expectation
+
+        def setup_allowance(subject)
+          warn_about_block if block_given?
+          each_message_on( proxy_on(subject) ) do |host, message, return_value|
+            host.add_simple_stub(message, return_value)
+          end
+        end
+
+        def setup_any_instance_expectation(subject)
+          warn_about_block if block_given?
+          each_message_on( any_instance_of(subject) ) do |host, message, return_value|
+            host.should_receive(message).and_return(return_value)
+          end
+        end
+
+        def setup_any_instance_allowance(subject)
+          warn_about_block if block_given?
+          any_instance_of(subject).stub(@message_return_value_hash)
+        end
+
+        def warn_about_block
+          raise "Implementation blocks aren't supported with `receive_messages`"
+        end
+
+      private
+
+        def proxy_on(subject)
+          ::RSpec::Mocks.proxy_for(subject)
+        end
+
+        def any_instance_of(subject)
+          ::RSpec::Mocks.any_instance_recorder_for(subject)
+        end
+
+        def each_message_on(host)
+          @message_return_value_hash.each do |message, value|
+            yield host, message, value
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rspec/mocks/message_expectation.rb

@@ -1,10 +1,42 @@
 module RSpec
   module Mocks
 
+    # A message expectation that only allows concrete return values to be set
+    # for a message. While this same effect can be achieved using a standard
+    # MessageExpecation, this version is much faster and so can be used as an
+    # optimization.
+    class SimpleMessageExpectation
+
+      def initialize(message, response, error_generator, backtrace_line = nil)
+        @message, @response, @error_generator, @backtrace_line = message, response, error_generator, backtrace_line
+        @received = false
+      end
+
+      def invoke(*_)
+        @received = true
+        @response
+      end
+
+      def matches?(message, *_)
+        @message == message
+      end
+
+      def called_max_times?
+        false
+      end
+
+      def verify_messages_received
+        InsertOntoBacktrace.line(@backtrace_line) do
+          unless @received
+            @error_generator.raise_expectation_error(@message, 1, ArgumentListMatcher::MATCH_ALL, 0, nil)
+          end
+        end
+      end
+    end
+
     class MessageExpectation
       # @private
       attr_accessor :error_generator, :implementation
-      attr_accessor :warn_about_yielding_receiver_to_implementation_block
       attr_reader :message
       attr_reader :orig_object
       attr_writer :expected_received_count, :expected_from, :argument_list_matcher
@@ -17,14 +49,14 @@ module RSpec
         @error_generator.opts = opts
         @expected_from = expected_from
         @method_double = method_double
-        @have_warned_about_yielding_receiver = false
         @orig_object = @method_double.object
-        @warn_about_yielding_receiver_to_implementation_block = false
         @message = @method_double.method_name
         @actual_received_count = 0
         @expected_received_count = expected_received_count
-        @argument_list_matcher = ArgumentListMatcher.new(ArgumentMatchers::AnyArgsMatcher.new)
+        @argument_list_matcher = ArgumentListMatcher::MATCH_ALL
         @order_group = expectation_ordering
+        @order_group.register(self)
+        @ordered = false
         @at_least = @at_most = @exactly = nil
         @args_to_yield = []
         @failed_fast = nil
@@ -35,6 +67,8 @@ module RSpec
         self.inner_implementation_action = implementation_block
       end
 
+      # @private
+
       # @private
       def expected_args
         @argument_list_matcher.expected_args
@@ -52,8 +86,8 @@ module RSpec
       # If the message is received more times than there are values, the last
       # value is received for every subsequent call.
       #
-      # The block format is deprecated in favor of just passing a block to the
-      # stub method.
+      # The block format is still supported, but is unofficially deprecated in
+      # favor of just passing a block to the stub method.
       #
       # @example
       #
@@ -69,35 +103,28 @@ module RSpec
       #   counter.count # => 3
       #   # etc
       #
-      #   # Deprecated ...
+      #   # Supported, but ...
       #   counter.stub(:count).and_return { 1 }
       #   counter.count # => 1
       #
-      #   # ... use this instead
+      #   # ... this is prefered
       #   counter.stub(:count) { 1 }
       #   counter.count # => 1
       def and_return(*values, &implementation)
         if negative?
-          RSpec.deprecate "`and_return` on a negative message expectation"
-        end
-
-        @expected_received_count = [@expected_received_count, values.size].max unless ignoring_args? || (@expected_received_count == 0 and @at_least)
-
-        if implementation
-          RSpec.deprecate('`and_return { value }`',
-                          :replacement => '`and_return(value)` or an implementation block without `and_return`')
-          self.inner_implementation_action = implementation
+          raise "`and_return` is not supported with negative message expectations"
         else
-          if values.empty?
-            RSpec.warn_deprecation('`and_return` without arguments is deprecated. ' +
-                                   'Remove the `and_return`. ' +
-                                   "Called from #{CallerFilter.first_non_rspec_line}.")
+          @expected_received_count = [@expected_received_count, values.size].max unless ignoring_args? || (@expected_received_count == 0 and @at_least)
+
+          if implementation
+            # TODO: deprecate `and_return { value }`
+            self.inner_implementation_action = implementation
+          else
+            self.terminal_implementation_action = AndReturnImplementation.new(values)
           end
 
-          self.terminal_implementation_action = AndReturnImplementation.new(values)
+          nil
         end
-
-        nil
       end
 
       def and_yield_receiver_to_implementation
@@ -121,9 +148,12 @@ module RSpec
       #   counter.increment
       #   expect(counter.count).to eq(original_count + 1)
       def and_call_original
-        if @method_double.object.is_a?(RSpec::Mocks::TestDouble)
+        if RSpec::Mocks::TestDouble === @method_double.object
           @error_generator.raise_only_valid_on_a_partial_mock(:and_call_original)
         else
+          if implementation.inner_action
+            RSpec.warning("You're overriding a previous implementation for this stub")
+          end
           @implementation = AndCallOriginalImplementation.new(@method_double.original_method)
           @yield_receiver_to_implementation_block = false
         end
@@ -181,7 +211,7 @@ module RSpec
       #
       #   stream.stub(:open).and_yield(StringIO.new)
       def and_yield(*args, &block)
-        yield @eval_context = Object.new.extend(RSpec::Mocks::InstanceExec) if block
+        yield @eval_context = Object.new if block
         @args_to_yield << args
         self.initial_implementation_action = AndYieldImplementation.new(@args_to_yield, @eval_context, @error_generator)
         self
@@ -239,39 +269,21 @@ module RSpec
 
       # @private
       def verify_messages_received
-        generate_error unless expected_messages_received? || failed_fast?
-      rescue RSpec::Mocks::MockExpectationError => error
-        error.backtrace.insert(0, @expected_from)
-        Kernel::raise error
-      end
-
-      # @private
-      def display_any_instance_deprecation_warning_if_necessary(block)
-        if passing_an_additional_arg_would_break_block?(block) &&
-           should_display_any_instance_deprecation_warning
-          line = if block.respond_to?(:source_location)
-                   block.source_location.join(':')
-                 else
-                   @any_instance_source_line
-                 end
-
-          display_any_instance_deprecation_warning(line)
-          @have_warned_about_yielding_receiver = true
+        InsertOntoBacktrace.line(@expected_from) do
+          generate_error unless expected_messages_received? || failed_fast?
         end
       end
 
-      # @private
-      def passing_an_additional_arg_would_break_block?(block)
-        return false unless block
-        return true if block.lambda?
-        !block.arity.zero?
-      end
-
       # @private
       def expected_messages_received?
         ignoring_args? || matches_exact_count? || matches_at_least_count? || matches_at_most_count?
       end
 
+      def ensure_expected_ordering_received!
+        @order_group.verify_invocation_order(self) if @ordered
+        true
+      end
+
       # @private
       def ignoring_args?
         @expected_received_count == :any
@@ -351,18 +363,13 @@ module RSpec
       #   cart.add(Book.new(:isbn => 1934356379))
       #   # => passes
       def with(*args, &block)
-        if block_given?
-          if args.empty?
-            RSpec.deprecate "Using the return value of a `with` block to validate passed arguments rather than as an implementation",
-              :replacement => "the `satisfy` matcher, a custom matcher or validate the arguments in an implementation block"
-          else
-            self.inner_implementation_action = block
-          end
-        elsif args.empty?
-          RSpec.deprecate "Using `with` without arguments", :replacement => "`with(no_args)`"
+        if args.empty?
+          raise ArgumentError,
+            "`with` must have at least one argument. Use `no_args` matcher to set the expectation of receiving no arguments."
         end
 
-        @argument_list_matcher = ArgumentListMatcher.new(*args, &block)
+        self.inner_implementation_action = block
+        @argument_list_matcher = ArgumentListMatcher.new(*args)
         self
       end
 
@@ -385,12 +392,14 @@ module RSpec
       #
       #   dealer.should_receive(:deal_card).at_least(9).times
       def at_least(n, &block)
+        set_expected_received_count :at_least, n
+
         if n == 0
-          RSpec.deprecate "at_least(0) with should_receive", :replacement => "stub"
+          raise "at_least(0) has been removed, use allow(...).to receive(:message) instead"
         end
 
         self.inner_implementation_action = block
-        set_expected_received_count :at_least, n
+
         self
       end
 
@@ -418,15 +427,6 @@ module RSpec
         self
       end
 
-
-      # Allows an expected message to be received any number of times.
-      def any_number_of_times(&block)
-        RSpec.deprecate "any_number_of_times", :replacement => "stub"
-        self.inner_implementation_action = block
-        @expected_received_count = :any
-        self
-      end
-
       # Expect a message not to be received at all.
       #
       # @example
@@ -469,11 +469,15 @@ module RSpec
       #   api.should_receive(:finish).ordered
       def ordered(&block)
         self.inner_implementation_action = block
-        @order_group.register(self)
         @ordered = true
         self
       end
 
+      # @private
+      def ordered?
+        @ordered
+      end
+
       # @private
       def negative_expectation_for?(message)
         @message == message && negative?
@@ -489,38 +493,6 @@ module RSpec
         @actual_received_count += 1
       end
 
-      def warn_about_receiver_passing(any_instance_source_line)
-        @any_instance_source_line = any_instance_source_line
-        @warn_about_yielding_receiver_to_implementation_block = true
-      end
-
-      def should_display_any_instance_deprecation_warning
-        warn_about_yielding_receiver_to_implementation_block &&
-          !@have_warned_about_yielding_receiver
-      end
-
-      def display_any_instance_deprecation_warning(block_source_line)
-        RSpec.warn_deprecation(<<MSG
-In RSpec 3, `any_instance` implementation blocks will be yielded the receiving
-instance as the first block argument to allow the implementation block to use
-the state of the receiver.  To maintain compatibility with RSpec 3 you need to
-either set rspec-mocks' `yield_receiver_to_any_instance_implementation_blocks`
-config option to `false` OR set it to `true` and update your `any_instance`
-implementation blocks to account for the first block argument being the receiving instance.
-
-To set the config option, use a snippet like:
-
-RSpec.configure do |rspec|
-  rspec.mock_with :rspec do |mocks|
-    mocks.yield_receiver_to_any_instance_implementation_blocks = false
-  end
-end
-
-Your `any_instance` implementation block is declared at: #{block_source_line}
-MSG
-)
-      end
-
     private
 
       def failed_fast?
@@ -543,7 +515,7 @@ MSG
       end
 
       def inner_implementation_action=(action)
-        display_any_instance_deprecation_warning_if_necessary(action)
+        RSpec.warning("You're overriding a previous implementation for this stub") if implementation.inner_action
         implementation.inner_action = action if action
       end
 
@@ -561,10 +533,6 @@ MSG
         @error_generator = error_generator
       end
 
-      def arity
-        -1
-      end
-
       def call(*args_to_ignore, &block)
         return if @args_to_yield.empty? && @eval_context.nil?
 
@@ -587,10 +555,6 @@ MSG
         @values_to_return = values_to_return
       end
 
-      def arity
-        -1
-      end
-
       def call(*args_to_ignore, &block)
         if @values_to_return.size > 1
           @values_to_return.shift
@@ -608,39 +572,10 @@ MSG
 
       def call(*args, &block)
         actions.map do |action|
-          if action.respond_to?(:lambda?) && action.lambda? && action.arity != args.size
-            RSpec.deprecate "stubbing implementations with mismatched arity",
-              :call_site => CallerFilter.first_non_rspec_line
-          end
-          action.call(*arg_slice_for(args, action.arity), &block)
+          action.call(*args, &block)
         end.last
       end
 
-      if RUBY_VERSION.to_f > 1.8
-        def arg_slice_for(args, arity)
-          if arity >= 0
-            args.slice(0, arity)
-          else
-            args
-          end
-        end
-      else
-        # 1.8.7's `arity` lies somtimes:
-        # Given:
-        #   def print_arity(&b) puts b.arity; end
-        #
-        # This prints 1:
-        #   print_arity { |a, b, c, &bl| }
-        #
-        # But this prints 3:
-        #   print_arity { |a, b, c| }
-        #
-        # Given that it lies, we can't trust it and we don't slice the args.
-        def arg_slice_for(args, arity)
-          args
-        end
-      end
-
       def present?
         actions.any?
       end
@@ -661,10 +596,6 @@ MSG
 
       CannotModifyFurtherError = Class.new(StandardError)
 
-      def arity
-        @method.arity
-      end
-
       def initial_action=(value)
         raise cannot_modify_further_error
       end
@@ -681,6 +612,10 @@ MSG
         true
       end
 
+      def inner_action
+        true
+      end
+
       def call(*args, &block)
         @method.call(*args, &block)
       end
@@ -692,5 +627,17 @@ MSG
           "to call the original implementation, and cannot be modified further."
       end
     end
+
+    # Insert original locations into stacktraces
+    # @api private
+    class InsertOntoBacktrace
+      def self.line(location)
+        yield
+      rescue RSpec::Mocks::MockExpectationError => error
+        error.backtrace.insert(0, location)
+        Kernel::raise error
+      end
+    end
+
   end
 end