rspec-mocks 3.0.4 → 3.1.0

data/lib/rspec/mocks/error_generator.rb

@@ -40,29 +40,38 @@ module RSpec
       def raise_unexpected_message_args_error(expectation, *args)
         expected_args = format_args(*expectation.expected_args)
         actual_args = format_received_args(*args)
-        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+        __raise "#{intro} received #{expectation.message.inspect} with " \
+                "unexpected arguments\n  expected: #{expected_args}\n" \
+                "       got: #{actual_args}"
       end
 
       # @private
       def raise_missing_default_stub_error(expectation, *args)
         expected_args = format_args(*expectation.expected_args)
         actual_args = format_received_args(*args)
-        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}\n Please stub a default value first if message might be received with other args as well. \n"
+        __raise "#{intro} received #{expectation.message.inspect} with " \
+                "unexpected arguments\n  expected: #{expected_args}\n" \
+                "       got: #{actual_args}\n Please stub a default value " \
+                "first if message might be received with other args as well. \n"
       end
 
       # @private
       def raise_similar_message_args_error(expectation, *args_for_multiple_calls)
         expected_args = format_args(*expectation.expected_args)
-        actual_args = args_for_multiple_calls.collect {|a| format_received_args(*a)}.join(", ")
-        __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+        actual_args = args_for_multiple_calls.map { |a| format_received_args(*a) }.join(", ")
+        __raise "#{intro} received #{expectation.message.inspect} with " \
+                "unexpected arguments\n  expected: #{expected_args}\n" \
+                "       got: #{actual_args}"
       end
 
+      # rubocop:disable Style/ParameterLists
       # @private
       def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, *args)
         expected_part = expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
         received_part = received_part_of_expectation_error(actual_received_count, *args)
         __raise "(#{intro}).#{message}#{format_args(*args)}\n    #{expected_part}\n    #{received_part}"
       end
+      # rubocop:enable Style/ParameterLists
 
       # @private
       def raise_unimplemented_error(doubled_module, method_name)
@@ -87,10 +96,10 @@ module RSpec
       # @private
       def raise_expired_test_double_error
         raise ExpiredTestDoubleError,
-          "#{intro} was originally created in one example but has leaked into " +
-          "another example and can no longer be used. rspec-mocks' doubles are " +
-          "designed to only last for one example, and you need to create a new " +
-          "one in each example you wish to use it for."
+              "#{intro} was originally created in one example but has leaked into " \
+              "another example and can no longer be used. rspec-mocks' doubles are " \
+              "designed to only last for one example, and you need to create a new " \
+              "one in each example you wish to use it for."
       end
 
       # @private
@@ -128,15 +137,13 @@ module RSpec
       # @private
       def method_call_args_description(args)
         case args.first
-          when ArgumentMatchers::AnyArgsMatcher
-            return " with any arguments"
-          when ArgumentMatchers::NoArgsMatcher
-            return " with no arguments"
+        when ArgumentMatchers::AnyArgsMatcher then " with any arguments"
+        when ArgumentMatchers::NoArgsMatcher  then " with no arguments"
         end
       end
 
       # @private
-      def describe_expectation(message, expected_received_count, actual_received_count, *args)
+      def describe_expectation(message, expected_received_count, _actual_received_count, *args)
         "have received #{message}#{format_args(*args)} #{count_message(expected_received_count)}"
       end
 
@@ -162,30 +169,30 @@ module RSpec
 
       # @private
       def raise_only_valid_on_a_partial_double(method)
-        __raise "#{intro} is a pure test double. `#{method}` is only " +
+        __raise "#{intro} is a pure test double. `#{method}` is only " \
                 "available on a partial double."
       end
 
       # @private
       def raise_expectation_on_unstubbed_method(method)
-        __raise "#{intro} expected to have received #{method}, but that " +
-                "method has not been stubbed."
+        __raise "#{intro} expected to have received #{method}, but that " \
+                "object is not a spy or method has not been stubbed."
       end
 
       # @private
       def raise_expectation_on_mocked_method(method)
-        __raise "#{intro} expected to have received #{method}, but that " +
-                "method has been mocked instead of stubbed."
+        __raise "#{intro} expected to have received #{method}, but that " \
+                "method has been mocked instead of stubbed or spied."
       end
 
       def self.raise_double_negation_error(wrapped_expression)
-        raise "Isn't life confusing enough? You've already set a " +
-              "negative message expectation and now you are trying to " +
-              "negate it again with `never`. What does an expression like " +
+        raise "Isn't life confusing enough? You've already set a " \
+              "negative message expectation and now you are trying to " \
+              "negate it again with `never`. What does an expression like " \
               "`#{wrapped_expression}.not_to receive(:msg).never` even mean?"
       end
 
-      private
+    private
 
       def intro
         if @name
@@ -203,7 +210,7 @@ module RSpec
 
       def __raise(message)
         message = opts[:message] unless opts[:message].nil?
-        Kernel::raise(RSpec::Mocks::MockExpectationError, message)
+        Kernel.raise(RSpec::Mocks::MockExpectationError, message)
       end
 
       def arg_message(*args)
@@ -215,7 +222,7 @@ module RSpec
       end
 
       def arg_list(*args)
-        args.collect {|arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
+        args.map { |arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
       end
 
       def arg_has_valid_description(arg)
@@ -229,19 +236,18 @@ module RSpec
       end
 
       def received_arg_list(*args)
-        args.collect(&:inspect).join(", ")
+        args.map(&:inspect).join(", ")
       end
 
       def count_message(count, expectation_count_type=nil)
         return "at least #{times(count.abs)}" if count < 0 || expectation_count_type == :at_least
         return "at most #{times(count)}" if expectation_count_type == :at_most
-        return times(count)
+        times(count)
       end
 
       def times(count)
         "#{count} time#{count == 1 ? '' : 's'}"
       end
-
     end
   end
 end

data/lib/rspec/mocks/example_methods.rb

@@ -84,6 +84,73 @@ module RSpec
         ExampleMethods.declare_verifying_double(ObjectVerifyingDouble, ref, *args)
       end
 
+      # @overload spy()
+      # @overload spy(name)
+      #   @param name [String/Symbol] used to clarify intent
+      # @overload spy(stubs)
+      #   @param stubs (Hash) hash of message/return-value pairs
+      # @overload spy(name, stubs)
+      #   @param name [String/Symbol] used to clarify intent
+      #   @param stubs (Hash) hash of message/return-value pairs
+      # @return (Double)
+      #
+      # Constructs a test double that is optimized for use with
+      # `have_received`. With a normal double one has to stub methods in order
+      # to be able to spy them. A spy automatically spies on all methods.
+      def spy(*args)
+        double(*args).as_null_object
+      end
+
+      # @overload instance_spy(doubled_class)
+      #   @param doubled_class [String, Class]
+      # @overload instance_spy(doubled_class, stubs)
+      #   @param doubled_class [String, Class]
+      #   @param stubs [Hash] hash of message/return-value pairs
+      # @return InstanceVerifyingDouble
+      #
+      # Constructs a test double that is optimized for use with `have_received`
+      # against a specific class. If the given class name has been loaded, only
+      # instance methods defined on the class are allowed to be stubbed.  With
+      # a normal double one has to stub methods in order to be able to spy
+      # them. An instance_spy automatically spies on all instance methods to
+      # which the class responds.
+      def instance_spy(*args)
+        instance_double(*args).as_null_object
+      end
+
+      # @overload object_spy(object_or_name)
+      #   @param object_or_name [String, Object]
+      # @overload object_spy(object_or_name, stubs)
+      #   @param object_or_name [String, Object]
+      #   @param stubs [Hash] hash of message/return-value pairs
+      # @return ObjectVerifyingDouble
+      #
+      # Constructs a test double that is optimized for use with `have_received`
+      # against a specific object. Only instance methods defined on the object
+      # are allowed to be stubbed.  With a normal double one has to stub
+      # methods in order to be able to spy them. An object_spy automatically
+      # spies on all methods to which the object responds.
+      def object_spy(*args)
+        object_double(*args).as_null_object
+      end
+
+      # @overload class_spy(doubled_class)
+      #   @param doubled_class [String, Module]
+      # @overload class_spy(doubled_class, stubs)
+      #   @param doubled_class [String, Module]
+      #   @param stubs [Hash] hash of message/return-value pairs
+      # @return ClassVerifyingDouble
+      #
+      # Constructs a test double that is optimized for use with `have_received`
+      # against a specific class. If the given class name has been loaded,
+      # only class methods defined on the class are allowed to be stubbed.
+      # With a normal double one has to stub methods in order to be able to spy
+      # them. An class_spy automatically spies on all class methods to which the
+      # class responds.
+      def class_spy(*args)
+        class_double(*args).as_null_object
+      end
+
       # Disables warning messages about expectations being set on nil.
       #
       # By default warning messages are issued when expectations are set on
@@ -130,7 +197,7 @@ module RSpec
       #   stub_const("CardDeck", Class.new, :transfer_nested_constants => [:SUITS])
       #   CardDeck::SUITS # => our suits array
       #   CardDeck::NUM_CARDS # => uninitialized constant error
-      def stub_const(constant_name, value, options = {})
+      def stub_const(constant_name, value, options={})
         ConstantMutator.stub(constant_name, value, options)
       end
 
@@ -151,8 +218,9 @@ module RSpec
       end
 
       # Verifies that the given object received the expected message during the
-      # course of the test. The method must have previously been stubbed in
-      # order for messages to be verified.
+      # course of the test. On a spy objects or as null object doubles this
+      # works for any method, on other objects the method must have
+      # been stubbed beforehand in order for messages to be verified.
       #
       # Stubbing and verifying messages received in this way implements the
       # Test Spy pattern.
@@ -288,9 +356,9 @@ module RSpec
           !ref.defined?
 
           raise VerifyingDoubleNotDefinedError,
-            "#{ref.description} is not a defined constant. " +
-            "Perhaps you misspelt it? " +
-            "Disable check with verify_doubled_constant_names configuration option."
+                "#{ref.description} is not a defined constant. " \
+                "Perhaps you misspelt it? " \
+                "Disable check with verify_doubled_constant_names configuration option."
         end
 
         declare_double(type, ref, *args)

data/lib/rspec/mocks/instance_method_stasher.rb

@@ -53,7 +53,7 @@ module RSpec
 
         # @private
         def stash
-          return if !method_defined_directly_on_klass?
+          return unless method_defined_directly_on_klass?
           @original_method ||= ::RSpec::Support.method_handle_for(@object, @method)
         end
 
@@ -80,9 +80,9 @@ module RSpec
           yield
         rescue TypeError
           RSpec.warn_with(
-            "RSpec failed to properly restore a partial double (#{@object.inspect}) " +
-            "to its original state due to a known bug in MRI 2.0.0-p195 & p247 " +
-            "(https://bugs.ruby-lang.org/issues/8686). This object may remain " +
+            "RSpec failed to properly restore a partial double (#{@object.inspect}) " \
+            "to its original state due to a known bug in MRI 2.0.0-p195 & p247 " \
+            "(https://bugs.ruby-lang.org/issues/8686). This object may remain " \
             "screwed up for the rest of this process. Please upgrade to 2.0.0-p353 or above.",
             :call_site => nil, :use_spec_location_as_call_site => true
           )
@@ -102,7 +102,7 @@ module RSpec
       end
 
       # @private
-      def method_defined_on_klass?(klass = @klass)
+      def method_defined_on_klass?(klass=@klass)
         MethodReference.method_defined_at_any_visibility?(klass, @method)
       end
 

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

@@ -3,9 +3,9 @@ module RSpec
     module Matchers
       # @private
       class HaveReceived
-        COUNT_CONSTRAINTS = %w(exactly at_least at_most times once twice)
-        ARGS_CONSTRAINTS = %w(with)
-        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS + %w(ordered)
+        COUNT_CONSTRAINTS = %w[exactly at_least at_most times once twice thrice]
+        ARGS_CONSTRAINTS = %w[with]
+        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS + %w[ordered]
 
         def initialize(method_name, &block)
           @method_name = method_name
@@ -71,14 +71,13 @@ module RSpec
         end
 
         def ensure_count_unconstrained
-          if count_constraint
-            raise RSpec::Mocks::MockExpectationError,
-              "can't use #{count_constraint} when negative"
-          end
+          return unless count_constraint
+          raise RSpec::Mocks::MockExpectationError,
+                "can't use #{count_constraint} when negative"
         end
 
         def count_constraint
-          @constraints.map(&:first).detect do |constraint|
+          @constraints.map(&:first).find do |constraint|
             COUNT_CONSTRAINTS.include?(constraint)
           end
         end

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

@@ -61,14 +61,14 @@ module RSpec
       private
 
         def warn_if_any_instance(expression, subject)
-          if AnyInstance::Proxy === 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
+          return unless AnyInstance::Proxy === 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
 
         def setup_mock_proxy_method_substitute(subject, method, block)

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

@@ -44,11 +44,10 @@ module RSpec
           replay_customizations(chain)
         end
 
-        def setup_negative_expectation(*args)
-          raise NegationUnsupportedError.new(
-            "`expect(...).not_to receive_message_chain` is not supported " +
-            "since it doesn't really make sense. What would it even mean?"
-          )
+        def setup_negative_expectation(*_args)
+          raise NegationUnsupportedError,
+                "`expect(...).not_to receive_message_chain` is not supported " \
+                "since it doesn't really make sense. What would it even mean?"
         end
 
         alias matches? setup_expectation

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

@@ -3,7 +3,6 @@ module RSpec
     module Matchers
       # @private
       class ReceiveMessages
-
         def initialize(message_return_value_hash)
           @message_return_value_hash = message_return_value_hash
           @backtrace_line = CallerFilter.first_non_rspec_line
@@ -15,29 +14,29 @@ module RSpec
 
         def setup_expectation(subject)
           warn_about_block if block_given?
-          each_message_on( proxy_on(subject) ) do |host, message, return_value|
+          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)
+        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?"
+                "`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|
+          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|
+          each_message_on(any_instance_of(subject)) do |host, message, return_value|
             host.should_receive(message).and_return(return_value)
           end
         end

data/lib/rspec/mocks/message_chain.rb

@@ -12,10 +12,10 @@ module RSpec
       # @api private
       def setup_chain
         if chain.length > 1
-          if matching_stub = find_matching_stub
+          if (matching_stub = find_matching_stub)
             chain.shift
             chain_on(matching_stub.invoke(nil), *chain, &@block)
-          elsif matching_expectation = find_matching_expectation
+          elsif (matching_expectation = find_matching_expectation)
             chain.shift
             chain_on(matching_expectation.invoke_without_incrementing_received_count(nil), *chain, &@block)
           else
@@ -30,8 +30,8 @@ module RSpec
 
     private
 
-      def expectation(object, message, &return_block)
-        raise NotImplementedError.new
+      def expectation(_object, _message, &_return_block)
+        raise NotImplementedError
       end
 
       def chain_on(object, *chain, &block)
@@ -42,7 +42,7 @@ module RSpec
       def format_chain(*chain, &blk)
         if Hash === chain.last
           hash = chain.pop
-          hash.each do |k,v|
+          hash.each do |k, v|
             chain << k
             blk = Proc.new { v }
           end

data/lib/rspec/mocks/message_expectation.rb

@@ -1,6 +1,5 @@
 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
@@ -8,8 +7,7 @@ module RSpec
     #
     # @private
     class SimpleMessageExpectation
-
-      def initialize(message, response, error_generator, backtrace_line = nil)
+      def initialize(message, response, error_generator, backtrace_line=nil)
         @message, @response, @error_generator, @backtrace_line = message.to_sym, response, error_generator, backtrace_line
         @received = false
       end
@@ -45,6 +43,7 @@ module RSpec
       attr_writer :expected_received_count, :expected_from, :argument_list_matcher
       protected :expected_received_count=, :expected_from=, :error_generator, :error_generator=, :implementation=
 
+      # rubocop:disable Style/ParameterLists
       # @private
       def initialize(error_generator, expectation_ordering, expected_from, method_double,
                      type=:expectation, opts={}, &implementation_block)
@@ -70,6 +69,7 @@ module RSpec
         @implementation = Implementation.new
         self.inner_implementation_action = implementation_block
       end
+      # rubocop:enable Style/ParameterLists
 
       # @private
       def expected_args
@@ -110,7 +110,7 @@ module RSpec
         end
 
         values.unshift(first_value)
-        @expected_received_count = [@expected_received_count, values.size].max unless ignoring_args? || (@expected_received_count == 0 and @at_least)
+        @expected_received_count = [@expected_received_count, values.size].max unless ignoring_args? || (@expected_received_count == 0 && @at_least)
         self.terminal_implementation_action = AndReturnImplementation.new(values)
 
         nil
@@ -137,11 +137,30 @@ module RSpec
       #   counter.increment
       #   expect(counter.count).to eq(original_count + 1)
       def and_call_original
+        and_wrap_original do |original, *args, &block|
+          original.call(*args, &block)
+        end
+      end
+
+      # Decorates the stubbed method with the supplied block. The original
+      # unmodified method is passed to the block along with any method call
+      # arguments so you can delegate to it, whilst still being able to
+      # change what args are passed to it and/or change the return value.
+      #
+      # @note This is only available on partial doubles.
+      #
+      # @example
+      #
+      #   expect(api).to receive(:large_list).and_wrap_original do |original_method, *args, &block|
+      #     original_method.call(*args, &block).first(10)
+      #   end
+      #
+      def and_wrap_original(&block)
         if RSpec::Mocks::TestDouble === @method_double.object
           @error_generator.raise_only_valid_on_a_partial_double(:and_call_original)
         else
           warn_about_stub_override if implementation.inner_action
-          @implementation = AndCallOriginalImplementation.new(@method_double.original_method)
+          @implementation = AndWrapOriginalImplementation.new(@method_double.original_method, block)
           @yield_receiver_to_implementation_block = false
         end
       end
@@ -167,7 +186,7 @@ module RSpec
       #   allow(car).to receive(:go).and_raise(OutOfGas)
       #   allow(car).to receive(:go).and_raise(OutOfGas, "At least 2 oz of gas needed to drive")
       #   allow(car).to receive(:go).and_raise(OutOfGas.new(2, :oz))
-      def and_raise(exception = RuntimeError, message = nil)
+      def and_raise(exception=RuntimeError, message=nil)
         if exception.respond_to?(:exception)
           exception = message ? exception.exception(message) : exception.exception
         end
@@ -234,7 +253,7 @@ module RSpec
 
       # @private
       def matches_name_but_not_args(message, *args)
-        @message == message and not @argument_list_matcher.args_match?(*args)
+        @message == message && !@argument_list_matcher.args_match?(*args)
       end
 
       # @private
@@ -296,7 +315,7 @@ module RSpec
       def expectation_count_type
         return :at_least if @at_least
         return :at_most if @at_most
-        return nil
+        nil
       end
 
       # @private
@@ -335,7 +354,7 @@ module RSpec
       def with(*args, &block)
         if args.empty?
           raise ArgumentError,
-            "`with` must have at least one argument. Use `no_args` matcher to set the expectation of receiving no arguments."
+                "`with` must have at least one argument. Use `no_args` matcher to set the expectation of receiving no arguments."
         end
 
         self.inner_implementation_action = block
@@ -430,6 +449,17 @@ module RSpec
         self
       end
 
+      # Expect a message to be received exactly three times.
+      #
+      # @example
+      #
+      #   expect(car).to receive(:go).thrice
+      def thrice(&block)
+        self.inner_implementation_action = block
+        set_expected_received_count :exactly, 3
+        self
+      end
+
       # Expect messages to be received in a specific order.
       #
       # @example
@@ -452,7 +482,6 @@ module RSpec
         @expected_received_count - 1
       end
 
-
       # @private
       def ordered?
         @ordered
@@ -476,15 +505,13 @@ module RSpec
     private
 
       def invoke_incrementing_actual_calls_by(increment, parent_stub, *args, &block)
-        if yield_receiver_to_implementation_block?
-          args.unshift(orig_object)
-        end
+        args.unshift(orig_object) if yield_receiver_to_implementation_block?
 
         if negative? || ((@exactly || @at_most) && (@actual_received_count == @expected_received_count))
           @actual_received_count += increment
           @failed_fast = true
-          #args are the args we actually received, @argument_list_matcher is the
-          #list of args we were expecting
+          # args are the args we actually received, @argument_list_matcher is the
+          # list of args we were expecting
           @error_generator.raise_expectation_error(@message, @expected_received_count, @argument_list_matcher, @actual_received_count, expectation_count_type, *args)
         end
 
@@ -513,6 +540,7 @@ module RSpec
                                    when Numeric then n
                                    when :once   then 1
                                    when :twice  then 2
+                                   when :thrice then 3
                                    end
       end
 
@@ -532,7 +560,7 @@ module RSpec
 
       def warn_about_stub_override
         RSpec.warning(
-          "You're overriding a previous stub implementation of `#{@message}`. " +
+          "You're overriding a previous stub implementation of `#{@message}`. " \
           "Called from #{CallerFilter.first_non_rspec_line}."
         )
       end
@@ -547,7 +575,7 @@ module RSpec
         @error_generator = error_generator
       end
 
-      def call(*args_to_ignore, &block)
+      def call(*_args_to_ignore, &block)
         return if @args_to_yield.empty? && @eval_context.nil?
 
         @error_generator.raise_missing_block_error @args_to_yield unless block
@@ -555,7 +583,7 @@ module RSpec
         block_signature = Support::BlockSignature.new(block)
 
         @args_to_yield.each do |args|
-          unless Support::MethodSignatureVerifier.new(block_signature, args).valid?
+          unless Support::StrictSignatureVerifier.new(block_signature, args).valid?
             @error_generator.raise_wrong_arity_error(args, block_signature)
           end
 
@@ -572,7 +600,7 @@ module RSpec
         @values_to_return = values_to_return
       end
 
-      def call(*args_to_ignore, &block)
+      def call(*_args_to_ignore, &_block)
         if @values_to_return.size > 1
           @values_to_return.shift
         else
@@ -606,22 +634,23 @@ module RSpec
 
     # Represents an `and_call_original` implementation.
     # @private
-    class AndCallOriginalImplementation
-      def initialize(method)
+    class AndWrapOriginalImplementation
+      def initialize(method, block)
         @method = method
+        @block = block
       end
 
       CannotModifyFurtherError = Class.new(StandardError)
 
-      def initial_action=(value)
+      def initial_action=(_value)
         raise cannot_modify_further_error
       end
 
-      def inner_action=(value)
+      def inner_action=(_value)
         raise cannot_modify_further_error
       end
 
-      def terminal_action=(value)
+      def terminal_action=(_value)
         raise cannot_modify_further_error
       end
 
@@ -634,13 +663,13 @@ module RSpec
       end
 
       def call(*args, &block)
-        @method.call(*args, &block)
+        @block.call(@method, *args, &block)
       end
 
     private
 
       def cannot_modify_further_error
-        CannotModifyFurtherError.new "This method has already been configured " +
+        CannotModifyFurtherError.new "This method has already been configured " \
           "to call the original implementation, and cannot be modified further."
       end
     end
@@ -653,9 +682,8 @@ module RSpec
         yield
       rescue RSpec::Mocks::MockExpectationError => error
         error.backtrace.insert(0, location)
-        Kernel::raise error
+        Kernel.raise error
       end
     end
-
   end
 end