rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

data/lib/rspec/mocks/method_double.rb

@@ -35,15 +35,7 @@ module RSpec
 
       # @private
       def visibility
-        if TestDouble === @object
-          'public'
-        elsif object_singleton_class.private_method_defined?(@method_name)
-          'private'
-        elsif object_singleton_class.protected_method_defined?(@method_name)
-          'protected'
-        else
-          'public'
-        end
+        @proxy.visibility_for(@method_name)
       end
 
       # @private
@@ -98,8 +90,7 @@ module RSpec
       # @private
       def restore_original_visibility
         return unless @original_visibility &&
-          (object_singleton_class.method_defined?(@method_name) ||
-           object_singleton_class.private_method_defined?(@method_name))
+          MethodReference.method_defined_at_any_visibility?(object_singleton_class, @method_name)
 
         object_singleton_class.__send__(*@original_visibility)
       end

data/lib/rspec/mocks/method_reference.rb

@@ -1,11 +1,13 @@
 module RSpec
   module Mocks
-    # Represents a method on a module that may or may not be defined.
+    # Represents a method on an object that may or may not be defined.
+    # The method may be an instance method on a module or a method on
+    # any object.
     #
     # @private
     class MethodReference
-      def initialize(module_reference, method_name)
-        @module_reference = module_reference
+      def initialize(object_reference, method_name)
+        @object_reference = object_reference
         @method_name = method_name
       end
 
@@ -13,43 +15,92 @@ module RSpec
       # a `NoMethodError`. It might be dynamically implemented by
       # `method_missing`.
       def implemented?
-        @module_reference.when_loaded do |m|
+        @object_reference.when_loaded do |m|
           method_implemented?(m)
         end
       end
 
+      # Returns true if we definitively know that sending the method
+      # will result in a `NoMethodError`.
+      #
+      # This is not simply the inverse of `implemented?`: there are
+      # cases when we don't know if a method is implemented and
+      # both `implemented?` and `unimplemented?` will return false.
+      def unimplemented?
+        @object_reference.when_loaded do |m|
+          return !implemented?
+        end
+
+        # If it's not loaded, then it may be implemented but we can't check.
+        false
+      end
+
       # A method is defined if we are able to get a `Method` object for it.
       # In that case, we can assert against metadata like the arity.
       def defined?
-        @module_reference.when_loaded do |m|
+        @object_reference.when_loaded do |m|
           method_defined?(m)
         end
       end
 
-      def when_defined
+      def with_signature
         if original = original_method
-          yield original
+          yield MethodSignature.new(original)
         end
       end
 
-      # Yields to the block if the method is not implemented.
-      def when_unimplemented
-        yield unless implemented?
+      def visibility
+        @object_reference.when_loaded do |m|
+          return visibility_from(m)
+        end
+
+        # When it's not loaded, assume it's public. We don't want to
+        # wrongly treat the method as private.
+        :public
       end
 
       private
+
       def original_method
-        @module_reference.when_loaded do |m|
+        @object_reference.when_loaded do |m|
           self.defined? && find_method(m)
         end
       end
+
+      def self.instance_method_visibility_for(klass, method_name)
+        if klass.public_method_defined?(method_name)
+          :public
+        elsif klass.private_method_defined?(method_name)
+          :private
+        elsif klass.protected_method_defined?(method_name)
+          :protected
+        end
+      end
+
+      class << self
+        alias method_defined_at_any_visibility? instance_method_visibility_for
+      end
+
+      def self.method_visibility_for(object, method_name)
+        instance_method_visibility_for(class << object; self; end, method_name).tap do |vis|
+          # If the method is not defined on the class, `instance_method_visibility_for`
+          # returns `nil`. However, it may be handled dynamically by `method_missing`,
+          # so here we check `respond_to` (passing false to not check private methods).
+          #
+          # This only considers the public case, but I don't think it's possible to
+          # write `method_missing` in such a way that it handles a dynamic message
+          # with private or protected visibility. Ruby doesn't provide you with
+          # the caller info.
+          return :public if vis.nil? && object.respond_to?(method_name, false)
+        end
+      end
     end
 
     # @private
     class InstanceMethodReference < MethodReference
       private
-      def method_implemented?(m)
-        m.method_defined?(@method_name)
+      def method_implemented?(mod)
+        MethodReference.method_defined_at_any_visibility?(mod, @method_name)
       end
 
       # Ideally, we'd use `respond_to?` for `method_implemented?` but we need a
@@ -66,29 +117,37 @@ module RSpec
       # This is necessary due to a bug in JRuby prior to 1.7.5 fixed in:
       # https://github.com/jruby/jruby/commit/99a0613fe29935150d76a9a1ee4cf2b4f63f4a27
       if RUBY_PLATFORM == 'java' && JRUBY_VERSION.split('.')[-1].to_i < 5
-        def find_method(m)
-          m.dup.instance_method(@method_name)
+        def find_method(mod)
+          mod.dup.instance_method(@method_name)
         end
       else
-        def find_method(m)
-          m.instance_method(@method_name)
+        def find_method(mod)
+          mod.instance_method(@method_name)
         end
       end
+
+      def visibility_from(mod)
+        MethodReference.instance_method_visibility_for(mod, @method_name)
+      end
     end
 
     # @private
     class ObjectMethodReference < MethodReference
       private
-      def method_implemented?(m)
-        m.respond_to?(@method_name)
+      def method_implemented?(object)
+        object.respond_to?(@method_name, true)
+      end
+
+      def method_defined?(object)
+        (class << object; self; end).method_defined?(@method_name)
       end
 
-      def method_defined?(m)
-        (class << m; self; end).method_defined?(@method_name)
+      def find_method(object)
+        object.method(@method_name)
       end
 
-      def find_method(m)
-        m.method(@method_name)
+      def visibility_from(object)
+        MethodReference.method_visibility_for(object, @method_name)
       end
     end
   end

data/lib/rspec/mocks/method_signature_verifier.rb

@@ -0,0 +1,207 @@
+require 'rspec/mocks/ruby_features'
+
+module RSpec
+  module Mocks
+    # Extracts info about the number of arguments and allowed/required
+    # keyword args of a given method.
+    #
+    # @api private
+    class MethodSignature
+      attr_reader :min_non_kw_args, :max_non_kw_args
+
+      def initialize(method)
+        @method = method
+        classify_parameters
+      end
+
+      def non_kw_args_arity_description
+        case max_non_kw_args
+          when min_non_kw_args then min_non_kw_args.to_s
+          when INFINITY then "#{min_non_kw_args} or more"
+          else "#{min_non_kw_args} to #{max_non_kw_args}"
+        end
+      end
+
+      if RubyFeatures.optional_and_splat_args_supported?
+        def description
+          @description ||= begin
+            parts = []
+
+            unless non_kw_args_arity_description == "0"
+              parts << "arity of #{non_kw_args_arity_description}"
+            end
+
+            if @optional_kw_args.any?
+              parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
+            end
+
+            if @required_kw_args.any?
+              parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
+            end
+
+            if @allows_any_kw_args
+              parts << "any additional keyword args"
+            end
+
+            parts.join(" and ")
+          end
+        end
+
+        def missing_kw_args_from(given_kw_args)
+          @required_kw_args - given_kw_args
+        end
+
+        def invalid_kw_args_from(given_kw_args)
+          return [] if @allows_any_kw_args
+          given_kw_args - @allowed_kw_args
+        end
+
+        def has_kw_args_in?(args)
+          return false unless Hash === args.last
+          return false if args.count <= min_non_kw_args
+
+          @allows_any_kw_args || @allowed_kw_args.any?
+        end
+
+        def classify_parameters
+          optional_non_kw_args = @min_non_kw_args = 0
+          @optional_kw_args, @required_kw_args = [], []
+          @allows_any_kw_args = false
+
+          @method.parameters.each do |(type, name)|
+            case type
+              # def foo(a:)
+              when :keyreq  then @required_kw_args << name
+              # def foo(a: 1)
+              when :key     then @optional_kw_args << name
+              # def foo(**kw_args)
+              when :keyrest then @allows_any_kw_args = true
+              # def foo(a)
+              when :req     then @min_non_kw_args += 1
+              # def foo(a = 1)
+              when :opt     then optional_non_kw_args += 1
+              # def foo(*a)
+              when :rest    then optional_non_kw_args = INFINITY
+            end
+          end
+
+          @max_non_kw_args = @min_non_kw_args  + optional_non_kw_args
+          @allowed_kw_args = @required_kw_args + @optional_kw_args
+        end
+      else
+        def description
+          "arity of #{non_kw_args_arity_description}"
+        end
+
+        def missing_kw_args_from(given_kw_args)
+          []
+        end
+
+        def invalid_kw_args_from(given_kw_args)
+          []
+        end
+
+        def has_kw_args_in?(args)
+          false
+        end
+
+        def classify_parameters
+          arity = @method.arity
+          if arity < 0
+            # `~` inverts the one's complement and gives us the
+            # number of required args
+            @min_non_kw_args = ~arity
+            @max_non_kw_args = INFINITY
+          else
+            @min_non_kw_args = arity
+            @max_non_kw_args = arity
+          end
+        end
+      end
+
+      INFINITY = 1/0.0
+    end
+
+    # Deals with the slightly different semantics of block arguments.
+    # For methods, arguments are required unless a default value is provided.
+    # For blocks, arguments are optional, even if no default value is provided.
+    #
+    # However, we want to treat block args as required since you virtually always
+    # want to pass a value for each received argument and our `and_yield` has
+    # treated block args as required for many years.
+    #
+    # @api private
+    class BlockSignature < MethodSignature
+      if RubyFeatures.optional_and_splat_args_supported?
+        def classify_parameters
+          super
+          @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
+        end
+      end
+    end
+
+    # Figures out wheter a given method can accept various arguments.
+    # Surprisingly non-trivial.
+    #
+    # @api private
+    class MethodSignatureVerifier
+      # @api private
+      attr_reader :non_kw_args, :kw_args
+
+      def initialize(signature, args)
+        @signature = signature
+        @non_kw_args, @kw_args = split_args(*args)
+      end
+
+      # @api private
+      def valid?
+         missing_kw_args.empty? &&
+          invalid_kw_args.empty? &&
+          valid_non_kw_args?
+      end
+
+      # @api private
+      def error_message
+        if missing_kw_args.any?
+          "Missing required keyword arguments: %s" % [
+            missing_kw_args.join(", ")
+          ]
+        elsif invalid_kw_args.any?
+          "Invalid keyword arguments provided: %s" % [
+            invalid_kw_args.join(", ")
+          ]
+        elsif !valid_non_kw_args?
+          "Wrong number of arguments. Expected %s, got %s." % [
+            @signature.non_kw_args_arity_description,
+            non_kw_args.length
+          ]
+        end
+      end
+
+    private
+
+      def valid_non_kw_args?
+        actual = non_kw_args.length
+        @signature.min_non_kw_args <= actual && actual <= @signature.max_non_kw_args
+      end
+
+      def missing_kw_args
+        @signature.missing_kw_args_from(kw_args)
+      end
+
+      def invalid_kw_args
+        @signature.invalid_kw_args_from(kw_args)
+      end
+
+      def split_args(*args)
+        kw_args = if @signature.has_kw_args_in?(args)
+          args.pop.keys
+        else
+          []
+        end
+
+        [args, kw_args]
+      end
+    end
+  end
+end

data/lib/rspec/mocks/mutate_const.rb

@@ -138,7 +138,6 @@ module RSpec
 
         const
       end
-      private_class_method :unmutated
 
       # Queries rspec-mocks to find out information about the named constant.
       #
@@ -146,7 +145,7 @@ module RSpec
       # @return [Constant] an object contaning information about the named
       #   constant.
       def self.original(name)
-        mutator = ConstantMutator.find(name)
+        mutator = ::RSpec::Mocks.space.constant_mutator_for(name)
         mutator ? mutator.to_constant : unmutated(name)
       end
     end
@@ -190,8 +189,6 @@ module RSpec
       #  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
@@ -210,6 +207,7 @@ module RSpec
           @transfer_nested_constants = transfer_nested_constants
           @context_parts             = @full_constant_name.split('::')
           @const_name                = @context_parts.pop
+          @reset_performed           = false
         end
 
         def to_constant
@@ -218,6 +216,11 @@ module RSpec
 
           const
         end
+
+        def idempotently_reset
+          reset unless @reset_performed
+          @reset_performed = true
+        end
       end
 
       # Hides a defined constant for the duration of an example.
@@ -225,6 +228,7 @@ module RSpec
       # @api private
       class ConstantHider < BaseMutator
         def mutate
+          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)
 
@@ -232,6 +236,8 @@ module RSpec
         end
 
         def to_constant
+          return Constant.unmutated(full_constant_name) unless @defined
+
           const = super
           const.hidden = true
           const.previously_defined = true
@@ -239,7 +245,8 @@ module RSpec
           const
         end
 
-        def rspec_reset
+        def reset
+          return unless @defined
           @context.const_set(@const_name, @original_value)
         end
       end
@@ -268,7 +275,7 @@ module RSpec
           const
         end
 
-        def rspec_reset
+        def reset
           @context.__send__(:remove_const, @const_name)
           @context.const_set(@const_name, @original_value)
         end
@@ -315,19 +322,15 @@ module RSpec
       # @api private
       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)
-            remaining_parts.shift
-            get_const_defined_on(klass, name)
-          end
-
-          context = remaining_parts.inject(@deepest_defined_const) do |klass, name|
-            klass.const_set(name, Module.new)
+          @parent = @context_parts.inject(Object) do |klass, name|
+            if const_defined_on?(klass, name)
+              get_const_defined_on(klass, name)
+            else
+              ConstantMutator.stub(name_for(klass, name), Module.new)
+            end
           end
 
-          @const_to_remove = remaining_parts.first || @const_name
-          context.const_set(@const_name, @mutated_value)
+          @parent.const_set(@const_name, @mutated_value)
         end
 
         def to_constant
@@ -338,8 +341,19 @@ module RSpec
           const
         end
 
-        def rspec_reset
-          @deepest_defined_const.__send__(:remove_const, @const_to_remove)
+        def reset
+          @parent.__send__(:remove_const, @const_name)
+        end
+
+      private
+
+        def name_for(parent, name)
+          root = if parent == Object
+            ''
+          else
+            parent.name
+          end
+          root + '::' + name
         end
       end
 
@@ -349,40 +363,10 @@ module RSpec
       #
       # @api private
       def self.mutate(mutator)
-        register_mutator(mutator)
+        ::RSpec::Mocks.space.register_constant_mutator(mutator)
         mutator.mutate
       end
 
-      # Resets all stubbed constants. This is called automatically
-      # by rspec-mocks when an example finishes.
-      #
-      # @api private
-      def self.reset_all
-        # We use reverse order so that if the same constant
-        # was stubbed multiple times, the original value gets
-        # properly restored.
-        mutators.reverse.each { |s| s.rspec_reset }
-
-        mutators.clear
-      end
-
-      # The list of constant mutators that have been used for
-      # the current example.
-      #
-      # @api private
-      def self.mutators
-        @mutators ||= []
-      end
-
-      # @api private
-      def self.register_mutator(mutator)
-        mutators << mutator
-      end
-
-      def self.find(name)
-        mutators.find { |s| s.full_constant_name == name }
-      end
-
       # Used internally by the constant stubbing to raise a helpful
       # error when a constant like "A::B::C" is stubbed and A::B is
       # not a module (and thus, it's impossible to define "A::B::C"