rspec-mocks 2.11.3 → 2.12.0

data/lib/rspec/mocks/method_double.rb

@@ -3,7 +3,7 @@ module RSpec
     # @private
     class MethodDouble < Hash
       # @private
-      attr_reader :method_name
+      attr_reader :method_name, :object
 
       # @private
       def initialize(object, method_name, proxy)
@@ -11,7 +11,7 @@ module RSpec
         @object = object
         @proxy = proxy
 
-        @stashed_method = StashedInstanceMethod.new(object_singleton_class, @method_name)
+        @method_stasher = InstanceMethodStasher.new(object_singleton_class, @method_name)
         @method_is_proxied = false
         store(:expectations, [])
         store(:stubs, [])
@@ -40,6 +40,80 @@ module RSpec
         end
       end
 
+      # @private
+      def original_method
+        if @method_stasher.method_is_stashed?
+          # Example: a singleton method defined on @object
+          method_handle_for(@object, @method_stasher.stashed_method_name)
+        else
+          begin
+            # Example: an instance method defined on @object's class.
+            @object.class.instance_method(@method_name).bind(@object)
+          rescue NameError
+            raise unless @object.respond_to?(:superclass)
+
+            # Example: a singleton method defined on @object's superclass.
+            #
+            # Note: we have to give precedence to instance methods
+            # defined on @object's class, because in a case like:
+            #
+            # `klass.should_receive(:new).and_call_original`
+            #
+            # ...we want `Class#new` bound to `klass` (which will return
+            # an instance of `klass`), not `klass.superclass.new` (which
+            # would return an instance of `klass.superclass`).
+            original_method_from_superclass
+          end
+        end
+      rescue NameError
+        # We have no way of knowing if the object's method_missing
+        # will handle this message or not...but we can at least try.
+        # If it's not handled, a `NoMethodError` will be raised, just
+        # like normally.
+        Proc.new do |*args, &block|
+          @object.__send__(:method_missing, @method_name, *args, &block)
+        end
+      end
+
+      if RUBY_VERSION.to_f > 1.8
+        # @private
+        def original_method_from_superclass
+          @object.superclass.
+                  singleton_class.
+                  instance_method(@method_name).
+                  bind(@object)
+        end
+      else
+        # Our implementation for 1.9 (above) causes an error on 1.8:
+        # TypeError: singleton method bound for a different object
+        #
+        # This doesn't work quite right in all circumstances but it's the
+        # best we can do.
+        # @private
+        def original_method_from_superclass
+          ::Kernel.warn <<-WARNING.gsub(/^ +\|/, '')
+            |
+            |WARNING: On ruby 1.8, rspec-mocks is unable to bind the original
+            |`#{@method_name}` method to your partial mock object (#{@object})
+            |for `and_call_original`. The superclass's `#{@method_name}` is being
+            |used instead; however, it may not work correctly when executed due
+            |to the fact that `self` will be #{@object.superclass}, not #{@object}.
+            |
+            |Called from: #{caller[2]}
+          WARNING
+
+          @object.superclass.method(@method_name)
+        end
+      end
+
+      # @private
+      OBJECT_METHOD_METHOD = ::Object.instance_method(:method)
+
+      # @private
+      def method_handle_for(object, method_name)
+        OBJECT_METHOD_METHOD.bind(object).call(method_name)
+      end
+
       # @private
       def object_singleton_class
         class << @object; self; end
@@ -49,7 +123,7 @@ module RSpec
       def configure_method
         RSpec::Mocks::space.add(@object) if RSpec::Mocks::space
         warn_if_nil_class
-        @stashed_method.stash unless @method_is_proxied
+        @method_stasher.stash unless @method_is_proxied
         define_proxy_method
       end
 
@@ -76,7 +150,7 @@ module RSpec
         return unless @method_is_proxied
 
         object_singleton_class.__send__(:remove_method, @method_name)
-        @stashed_method.restore
+        @method_stasher.restore
         @method_is_proxied = false
       end
 
@@ -104,7 +178,8 @@ module RSpec
         expectation = if existing_stub = stubs.first
                         existing_stub.build_child(expected_from, 1, opts, &implementation)
                       else
-                        MessageExpectation.new(error_generator, expectation_ordering, expected_from, @method_name, 1, opts, &implementation)
+                        MessageExpectation.new(error_generator, expectation_ordering,
+                                               expected_from, self, 1, opts, &implementation)
                       end
         expectations << expectation
         expectation
@@ -113,7 +188,8 @@ module RSpec
       # @private
       def add_negative_expectation(error_generator, expectation_ordering, expected_from, &implementation)
         configure_method
-        expectation = NegativeMessageExpectation.new(error_generator, expectation_ordering, expected_from, @method_name, &implementation)
+        expectation = NegativeMessageExpectation.new(error_generator, expectation_ordering,
+                                                     expected_from, self, &implementation)
         expectations.unshift expectation
         expectation
       end
@@ -121,7 +197,8 @@ module RSpec
       # @private
       def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)
         configure_method
-        stub = MessageExpectation.new(error_generator, expectation_ordering, expected_from, @method_name, :any, opts, &implementation)
+        stub = MessageExpectation.new(error_generator, expectation_ordering, expected_from,
+                                      self, :any, opts, &implementation)
         stubs.unshift stub
         stub
       end

data/lib/rspec/mocks/{stub_const.rb → mutate_const.rb}

@@ -17,14 +17,14 @@ module RSpec
       # On 1.8:
       #   - C.const_get("Hash") # => ::Hash
       #   - C.const_defined?("Hash") # => false
-      #   - C.constants # => ["A"]
+      #   - C.constants # => ["B"]
       #   - None of these methods accept the extra `inherit` argument
       # On 1.9:
       #   - C.const_get("Hash") # => ::Hash
       #   - C.const_defined?("Hash") # => true
       #   - C.const_get("Hash", false) # => raises NameError
       #   - C.const_defined?("Hash", false) # => false
-      #   - C.constants # => [:A]
+      #   - C.constants # => [:B]
       #   - C.constants(false) #=> []
       if Module.method(:const_defined?).arity == 1
         def const_defined_on?(mod, const_name)
@@ -70,7 +70,7 @@ module RSpec
     end
 
     # Provides information about constants that may (or may not)
-    # have been stubbed by rspec-mocks.
+    # have been mutated by rspec-mocks.
     class Constant
       extend RecursiveConstMethods
 
@@ -83,12 +83,12 @@ module RSpec
       attr_reader :name
 
       # @return [Object, nil] The original value (e.g. before it
-      #   was stubbed by rspec-mocks) of the constant, or
+      #   was mutated by rspec-mocks) of the constant, or
       #   nil if the constant was not previously defined.
       attr_accessor :original_value
 
       # @api private
-      attr_writer :previously_defined, :stubbed
+      attr_writer :previously_defined, :stubbed, :hidden
 
       # @return [Boolean] Whether or not the constant was defined
       #   before the current example.
@@ -96,27 +96,40 @@ module RSpec
         @previously_defined
       end
 
+      # @return [Boolean] Whether or not rspec-mocks has mutated
+      #   (stubbed or hidden) this constant.
+      def mutated?
+        @stubbed || @hidden
+      end
+
       # @return [Boolean] Whether or not rspec-mocks has stubbed
       #   this constant.
       def stubbed?
         @stubbed
       end
 
+      # @return [Boolean] Whether or not rspec-mocks has hidden
+      #   this constant.
+      def hidden?
+        @hidden
+      end
+
       def to_s
         "#<#{self.class.name} #{name}>"
       end
       alias inspect to_s
 
       # @api private
-      def self.unstubbed(name)
+      def self.unmutated(name)
         const = new(name)
         const.previously_defined = recursive_const_defined?(name)
         const.stubbed = false
+        const.hidden = false
         const.original_value = recursive_const_get(name) if const.previously_defined?
 
         const
       end
-      private_class_method :unstubbed
+      private_class_method :unmutated
 
       # Queries rspec-mocks to find out information about the named constant.
       #
@@ -124,13 +137,13 @@ module RSpec
       # @return [Constant] an object contaning information about the named
       #   constant.
       def self.original(name)
-        stubber = ConstantStubber.find(name)
-        stubber ? stubber.to_constant : unstubbed(name)
+        mutator = ConstantMutator.find(name)
+        mutator ? mutator.to_constant : unmutated(name)
       end
     end
 
     # Provides a means to stub constants.
-    class ConstantStubber
+    class ConstantMutator
       extend RecursiveConstMethods
 
       # Stubs a constant.
@@ -145,31 +158,43 @@ module RSpec
       #  so you can stub constants in other contexts (e.g. helper
       #  classes).
       def self.stub(constant_name, value, options = {})
-        stubber = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
+        mutator = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
           DefinedConstantReplacer
         else
           UndefinedConstantSetter
         end
 
-        stubber = stubber.new(constant_name, value, options[:transfer_nested_constants])
-        stubbers << stubber
-
-        stubber.stub
-        ensure_registered_with_mocks_space
+        mutate(mutator.new(constant_name, value, options[:transfer_nested_constants]))
         value
       end
 
-      # Contains common functionality used by both of the constant stubbers.
+      # Hides a constant.
+      #
+      # @param (see ExampleMethods#hide_const)
+      #
+      # @see ExampleMethods#hide_const
+      # @note It's recommended that you use `hide_const` in your
+      #  examples. This is an alternate public API that is provided
+      #  so you can hide constants in other contexts (e.g. helper
+      #  classes).
+      def self.hide(constant_name)
+        return unless recursive_const_defined?(constant_name)
+
+        mutate(ConstantHider.new(constant_name, nil, { }))
+        nil
+      end
+
+      # Contains common functionality used by all of the constant mutators.
       #
       # @api private
-      class BaseStubber
+      class BaseMutator
         include RecursiveConstMethods
 
         attr_reader :original_value, :full_constant_name
 
-        def initialize(full_constant_name, stubbed_value, transfer_nested_constants)
+        def initialize(full_constant_name, mutated_value, transfer_nested_constants)
           @full_constant_name        = full_constant_name
-          @stubbed_value             = stubbed_value
+          @mutated_value             = mutated_value
           @transfer_nested_constants = transfer_nested_constants
           @context_parts             = @full_constant_name.split('::')
           @const_name                = @context_parts.pop
@@ -177,32 +202,58 @@ module RSpec
 
         def to_constant
           const = Constant.new(full_constant_name)
-          const.stubbed = true
-          const.previously_defined = previously_defined?
           const.original_value = original_value
 
           const
         end
       end
 
+      # Hides a defined constant for the duration of an example.
+      #
+      # @api private
+      class ConstantHider < BaseMutator
+        def mutate
+          @context = recursive_const_get(@context_parts.join('::'))
+          @original_value = get_const_defined_on(@context, @const_name)
+
+          @context.send(:remove_const, @const_name)
+        end
+
+        def to_constant
+          const = super
+          const.hidden = true
+          const.previously_defined = true
+
+          const
+        end
+
+        def rspec_reset
+          @context.const_set(@const_name, @original_value)
+        end
+      end
+
       # Replaces a defined constant for the duration of an example.
       #
       # @api private
-      class DefinedConstantReplacer < BaseStubber
-        def stub
+      class DefinedConstantReplacer < BaseMutator
+        def mutate
           @context = recursive_const_get(@context_parts.join('::'))
           @original_value = get_const_defined_on(@context, @const_name)
 
           constants_to_transfer = verify_constants_to_transfer!
 
           @context.send(:remove_const, @const_name)
-          @context.const_set(@const_name, @stubbed_value)
+          @context.const_set(@const_name, @mutated_value)
 
           transfer_nested_constants(constants_to_transfer)
         end
 
-        def previously_defined?
-          true
+        def to_constant
+          const = super
+          const.stubbed = true
+          const.previously_defined = true
+
+          const
         end
 
         def rspec_reset
@@ -212,14 +263,14 @@ module RSpec
 
         def transfer_nested_constants(constants)
           constants.each do |const|
-            @stubbed_value.const_set(const, get_const_defined_on(original_value, const))
+            @mutated_value.const_set(const, get_const_defined_on(original_value, const))
           end
         end
 
         def verify_constants_to_transfer!
           return [] unless @transfer_nested_constants
 
-          { @original_value => "the original value", @stubbed_value => "the stubbed value" }.each do |value, description|
+          { @original_value => "the original value", @mutated_value => "the stubbed value" }.each do |value, description|
             unless value.respond_to?(:constants)
               raise ArgumentError,
                 "Cannot transfer nested constants for #{@full_constant_name} " +
@@ -250,8 +301,8 @@ module RSpec
       # Sets an undefined constant for the duration of an example.
       #
       # @api private
-      class UndefinedConstantSetter < BaseStubber
-        def stub
+      class UndefinedConstantSetter < BaseMutator
+        def mutate
           remaining_parts = @context_parts.dup
           @deepest_defined_const = @context_parts.inject(Object) do |klass, name|
             break klass unless const_defined_on?(klass, name)
@@ -264,11 +315,15 @@ module RSpec
           end
 
           @const_to_remove = remaining_parts.first || @const_name
-          context.const_set(@const_name, @stubbed_value)
+          context.const_set(@const_name, @mutated_value)
         end
 
-        def previously_defined?
-          false
+        def to_constant
+          const = super
+          const.stubbed = true
+          const.previously_defined = false
+
+          const
         end
 
         def rspec_reset
@@ -276,6 +331,17 @@ module RSpec
         end
       end
 
+      # Uses the mutator to mutate (stub or hide) a constant. Ensures that
+      # the mutator is correctly registered so it can be backed out at the end
+      # of the test.
+      #
+      # @api private
+      def self.mutate(mutator)
+        register_mutator(mutator)
+        mutator.mutate
+        ensure_registered_with_mocks_space
+      end
+
       # Ensures the constant stubbing is registered with
       # rspec-mocks space so that stubbed constants can
       # be restored when examples finish.
@@ -297,21 +363,26 @@ module RSpec
         # We use reverse order so that if the same constant
         # was stubbed multiple times, the original value gets
         # properly restored.
-        stubbers.reverse.each { |s| s.rspec_reset }
+        mutators.reverse.each { |s| s.rspec_reset }
 
-        stubbers.clear
+        mutators.clear
       end
 
-      # The list of constant stubbers that have been used for
+      # The list of constant mutators that have been used for
       # the current example.
       #
       # @api private
-      def self.stubbers
-        @stubbers ||= []
+      def self.mutators
+        @mutators ||= []
+      end
+
+      # @api private
+      def self.register_mutator(mutator)
+        mutators << mutator
       end
 
       def self.find(name)
-        stubbers.find { |s| s.full_constant_name == name }
+        mutators.find { |s| s.full_constant_name == name }
       end
 
       # Used internally by the constant stubbing to raise a helpful
@@ -327,6 +398,12 @@ module RSpec
         end
       end
     end
+
+    # Keeps backwards compatibility since we had released an rspec-mocks that
+    # only supported stubbing. Later, we released the hide_const feature and
+    # decided that the term "mutator" was a better term to wrap up the concept
+    # of both stubbing and hiding.
+    ConstantStubber = ConstantMutator
   end
 end