rspec-mocks 3.0.4 → 3.12.6

data/lib/rspec/mocks/mutate_const.rb

@@ -1,85 +1,11 @@
+RSpec::Support.require_rspec_support 'recursive_const_methods'
+
 module RSpec
   module Mocks
-    # Provides recursive constant lookup methods useful for
-    # constant stubbing.
-    #
-    # @private
-    module RecursiveConstMethods
-      # We only want to consider constants that are defined directly on a
-      # particular module, and not include top-level/inherited constants.
-      # Unfortunately, the constant API changed between 1.8 and 1.9, so
-      # we need to conditionally define methods to ignore the top-level/inherited
-      # constants.
-      #
-      # Given:
-      #   class A; B = 1; end
-      #   class C < A; end
-      #
-      # On 1.8:
-      #   - C.const_get("Hash") # => ::Hash
-      #   - C.const_defined?("Hash") # => false
-      #   - 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 # => [:B]
-      #   - C.constants(false) #=> []
-      if Module.method(:const_defined?).arity == 1
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          if const_defined_on?(mod, const_name)
-            return mod.const_get(const_name)
-          end
-
-          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
-        end
-
-        def constants_defined_on(mod)
-          mod.constants.select { |c| const_defined_on?(mod, c) }
-        end
-      else
-        def const_defined_on?(mod, const_name)
-          mod.const_defined?(const_name, false)
-        end
-
-        def get_const_defined_on(mod, const_name)
-          mod.const_get(const_name, false)
-        end
-
-        def constants_defined_on(mod)
-          mod.constants(false)
-        end
-      end
-
-      def recursive_const_get(const_name)
-        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
-          get_const_defined_on(mod, name)
-        end
-      end
-
-      def recursive_const_defined?(const_name)
-        normalize_const_name(const_name).split('::').inject([Object, '']) do |(mod, full_name), name|
-          yield(full_name, name) if block_given? && !(Module === mod)
-          return false unless const_defined_on?(mod, name)
-          [get_const_defined_on(mod, name), [mod, name].join('::')]
-        end
-      end
-
-      def normalize_const_name(const_name)
-        const_name.sub(/\A::/, '')
-      end
-    end
-
     # Provides information about constants that may (or may not)
     # have been mutated by rspec-mocks.
     class Constant
-      extend RecursiveConstMethods
+      extend Support::RecursiveConstMethods
 
       # @api private
       def initialize(name)
@@ -87,6 +13,8 @@ module RSpec
         @previously_defined = false
         @stubbed = false
         @hidden = false
+        @valid_name = true
+        yield self if block_given?
       end
 
       # @return [String] The fully qualified name of the constant.
@@ -98,7 +26,7 @@ module RSpec
       attr_accessor :original_value
 
       # @private
-      attr_writer :previously_defined, :stubbed, :hidden
+      attr_writer :previously_defined, :stubbed, :hidden, :valid_name
 
       # @return [Boolean] Whether or not the constant was defined
       #   before the current example.
@@ -124,6 +52,12 @@ module RSpec
         @hidden
       end
 
+      # @return [Boolean] Whether or not the provided constant name
+      #   is a valid Ruby constant name.
+      def valid_name?
+        @valid_name
+      end
+
       # The default `to_s` isn't very useful, so a custom version is provided.
       def to_s
         "#<#{self.class.name} #{name}>"
@@ -132,19 +66,22 @@ module RSpec
 
       # @private
       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
+        previously_defined = !!recursive_const_defined?(name)
+      rescue NameError
+        new(name) do |c|
+          c.valid_name = false
+        end
+      else
+        new(name) do |const|
+          const.previously_defined = previously_defined
+          const.original_value = recursive_const_get(name) if previously_defined
+        end
       end
 
       # Queries rspec-mocks to find out information about the named constant.
       #
       # @param [String] name the name of the constant
-      # @return [Constant] an object contaning information about the named
+      # @return [Constant] an object containing information about the named
       #   constant.
       def self.original(name)
         mutator = ::RSpec::Mocks.space.constant_mutator_for(name)
@@ -154,7 +91,7 @@ module RSpec
 
     # Provides a means to stub constants.
     class ConstantMutator
-      extend RecursiveConstMethods
+      extend Support::RecursiveConstMethods
 
       # Stubs a constant.
       #
@@ -167,13 +104,17 @@ module RSpec
       #  examples. This is an alternate public API that is provided
       #  so you can stub constants in other contexts (e.g. helper
       #  classes).
-      def self.stub(constant_name, value, options = {})
-        mutator = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
-          DefinedConstantReplacer
-        else
-          UndefinedConstantSetter
+      def self.stub(constant_name, value, options={})
+        unless String === constant_name
+          raise ArgumentError, "`stub_const` requires a String, but you provided a #{constant_name.class.name}"
         end
 
+        mutator = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
+                    DefinedConstantReplacer
+                  else
+                    UndefinedConstantSetter
+                  end
+
         mutate(mutator.new(constant_name, value, options[:transfer_nested_constants]))
         value
       end
@@ -188,7 +129,7 @@ module RSpec
       #  so you can hide constants in other contexts (e.g. helper
       #  classes).
       def self.hide(constant_name)
-        mutate(ConstantHider.new(constant_name, nil, { }))
+        mutate(ConstantHider.new(constant_name, nil, {}))
         nil
       end
 
@@ -196,7 +137,7 @@ module RSpec
       #
       # @private
       class BaseMutator
-        include RecursiveConstMethods
+        include Support::RecursiveConstMethods
 
         attr_reader :original_value, :full_constant_name
 
@@ -227,7 +168,7 @@ module RSpec
       # @private
       class ConstantHider < BaseMutator
         def mutate
-          return unless @defined = recursive_const_defined?(full_constant_name)
+          return unless (@defined = recursive_const_defined?(full_constant_name))
           @context = recursive_const_get(@context_parts.join('::'))
           @original_value = get_const_defined_on(@context, @const_name)
 
@@ -298,12 +239,12 @@ module RSpec
           return [] unless should_transfer_nested_constants?
 
           { @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} " +
-                "since #{description} is not a class or module and only classes " +
-                "and modules support nested constants."
-            end
+            next if value.respond_to?(:constants)
+
+            raise ArgumentError,
+                  "Cannot transfer nested constants for #{@full_constant_name} " \
+                  "since #{description} is not a class or module and only classes " \
+                  "and modules support nested constants."
           end
 
           if Array === @transfer_nested_constants
@@ -313,9 +254,9 @@ module RSpec
             if undefined_constants.any?
               available_constants = constants_defined_on(@original_value) - @transfer_nested_constants
               raise ArgumentError,
-                "Cannot transfer nested constant(s) #{undefined_constants.join(' and ')} " +
-                "for #{@full_constant_name} since they are not defined. Did you mean " +
-                "#{available_constants.join(' or ')}?"
+                    "Cannot transfer nested constant(s) #{undefined_constants.join(' and ')} " \
+                    "for #{@full_constant_name} since they are not defined. Did you mean " \
+                    "#{available_constants.join(' or ')}?"
             end
 
             @transfer_nested_constants
@@ -363,10 +304,10 @@ module RSpec
 
         def name_for(parent, name)
           root = if parent == Object
-            ''
-          else
-            parent.name
-          end
+                   ''
+                 else
+                   parent.name
+                 end
           root + '::' + name
         end
       end
@@ -389,7 +330,7 @@ module RSpec
       # @api private
       def self.raise_on_invalid_const
         lambda do |const_name, failed_name|
-          raise "Cannot stub constant #{failed_name} on #{const_name} " +
+          raise "Cannot stub constant #{failed_name} on #{const_name} " \
                 "since #{const_name} is not a module."
         end
       end

data/lib/rspec/mocks/object_reference.rb

@@ -1,91 +1,148 @@
 module RSpec
   module Mocks
-
     # @private
     class ObjectReference
       # Returns an appropriate Object or Module reference based
       # on the given argument.
-      def self.for(object_module_or_name, allow_direct_object_refs = false)
+      def self.for(object_module_or_name, allow_direct_object_refs=false)
         case object_module_or_name
-          when Module then DirectModuleReference.new(object_module_or_name)
-          when String then NamedObjectReference.new(object_module_or_name)
+        when Module
+          if anonymous_module?(object_module_or_name)
+            DirectObjectReference.new(object_module_or_name)
+          else
+            # Use a `NamedObjectReference` if it has a name because this
+            # will use the original value of the constant in case it has
+            # been stubbed.
+            NamedObjectReference.new(name_of(object_module_or_name))
+          end
+        when String
+          NamedObjectReference.new(object_module_or_name)
+        else
+          if allow_direct_object_refs
+            DirectObjectReference.new(object_module_or_name)
           else
-            if allow_direct_object_refs
-              DirectObjectReference.new(object_module_or_name)
-            else
-              raise ArgumentError,
-                "Module or String expected, got #{object_module_or_name.inspect}"
-            end
+            raise ArgumentError,
+                  "Module or String expected, got #{object_module_or_name.inspect}"
+          end
+        end
+      end
+
+      if Module.new.name.nil?
+        def self.anonymous_module?(mod)
+          !name_of(mod)
+        end
+      else # 1.8.7
+        def self.anonymous_module?(mod)
+          name_of(mod) == ""
         end
       end
+      private_class_method :anonymous_module?
+
+      def self.name_of(mod)
+        MODULE_NAME_METHOD.bind(mod).call
+      end
+      private_class_method :name_of
+
+      # @private
+      MODULE_NAME_METHOD = Module.instance_method(:name)
     end
 
-    # Used when an object is passed to `object_double`.
+    # An implementation of rspec-mocks' reference interface.
+    # Used when an object is passed to {ExampleMethods#object_double}, or
+    # an anonymous class or module is passed to {ExampleMethods#instance_double}
+    # or {ExampleMethods#class_double}.
     # Represents a reference to that object.
-    #
-    # @private
+    # @see NamedObjectReference
     class DirectObjectReference
+      # @param object [Object] the object to which this refers
       def initialize(object)
         @object = object
       end
 
+      # @return [String] the object's description (via `#inspect`).
       def description
         @object.inspect
       end
 
+      # Defined for interface parity with the other object reference
+      # implementations. Raises an `ArgumentError` to indicate that `as_stubbed_const`
+      # is invalid when passing an object argument to `object_double`.
       def const_to_replace
         raise ArgumentError,
-          "Can not perform constant replacement with an object."
+              "Can not perform constant replacement with an anonymous object."
+      end
+
+      # The target of the verifying double (the object itself).
+      #
+      # @return [Object]
+      def target
+        @object
       end
 
+      # Always returns true for an object as the class is defined.
+      #
+      # @return [true]
       def defined?
         true
       end
 
+      # Yields if the reference target is loaded, providing a generic mechanism
+      # to optionally run a bit of code only when a reference's target is
+      # loaded.
+      #
+      # This specific implementation always yields because direct references
+      # are always loaded.
+      #
+      # @yield [Object] the target of this reference.
       def when_loaded
         yield @object
       end
     end
 
-    # Used when a module is passed to `class_double` or `instance_double`.
-    # Represents a reference to that module.
-    #
-    # @private
-    class DirectModuleReference < DirectObjectReference
-      def const_to_replace
-        @object.name
-      end
-      alias description const_to_replace
-    end
-
-    # Used when a string is passed to `class_double`, `instance_double`
-    # or `object_double`.
+    # An implementation of rspec-mocks' reference interface.
+    # Used when a string is passed to {ExampleMethods#object_double},
+    # and when a string, named class or named module is passed to
+    # {ExampleMethods#instance_double}, or {ExampleMethods#class_double}.
     # Represents a reference to the object named (via a constant lookup)
     # by the string.
-    #
-    # @private
+    # @see DirectObjectReference
     class NamedObjectReference
+      # @param const_name [String] constant name
       def initialize(const_name)
         @const_name = const_name
       end
 
+      # @return [Boolean] true if the named constant is defined, false otherwise.
       def defined?
         !!object
       end
 
+      # @return [String] the constant name to replace with a double.
       def const_to_replace
         @const_name
       end
       alias description const_to_replace
 
-      def when_loaded(&block)
+      # @return [Object, nil] the target of the verifying double (the named object), or
+      #   nil if it is not defined.
+      def target
+        object
+      end
+
+      # Yields if the reference target is loaded, providing a generic mechanism
+      # to optionally run a bit of code only when a reference's target is
+      # loaded.
+      #
+      # @yield [Object] the target object
+      def when_loaded
         yield object if object
       end
 
-   private
+    private
 
       def object
-        @object ||= Constant.original(@const_name).original_value
+        return @object if defined?(@object)
+        @object = Constant.original(@const_name).original_value
       end
     end
   end

data/lib/rspec/mocks/order_group.rb

@@ -25,10 +25,10 @@ module RSpec
       # @private
       def consume
         remaining_expectations.each_with_index do |expectation, index|
-          if expectation.ordered?
-            @index += index + 1
-            return expectation
-          end
+          next unless expectation.ordered?
+
+          @index += index + 1
+          return expectation
         end
         nil
       end
@@ -76,7 +76,6 @@ module RSpec
       def expectation_for(message)
         @expectations.find { |e| message == e }
       end
-
     end
   end
 end