opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-mocks/upstream/lib/rspec/mocks/method_double.rb

@@ -3,7 +3,7 @@ module RSpec
     # @private
     class MethodDouble
       # @private
-      attr_reader :method_name, :object, :expectations, :stubs
+      attr_reader :method_name, :object, :expectations, :stubs, :method_stasher
 
       # @private
       def initialize(object, method_name, proxy)
@@ -18,20 +18,24 @@ module RSpec
         @stubs = []
       end
 
-      def original_method
+      def original_implementation_callable
         # If original method is not present, uses the `method_missing`
         # handler of the object. This accounts for cases where the user has not
         # correctly defined `respond_to?`, and also 1.8 which does not provide
         # method handles for missing methods even if `respond_to?` is correct.
-        @original_method ||=
-          @method_stasher.original_method ||
-          @proxy.original_method_handle_for(method_name) ||
+        @original_implementation_callable ||= original_method ||
           Proc.new do |*args, &block|
             @object.__send__(:method_missing, @method_name, *args, &block)
           end
       end
 
-      alias_method :save_original_method!, :original_method
+      alias_method :save_original_implementation_callable!, :original_implementation_callable
+
+      def original_method
+        @original_method ||=
+          @method_stasher.original_method ||
+          @proxy.original_method_handle_for(method_name)
+      end
 
       # @private
       def visibility
@@ -45,7 +49,7 @@ module RSpec
 
       # @private
       def configure_method
-        @original_visibility = [visibility, method_name]
+        @original_visibility = visibility
         @method_stasher.stash unless @method_is_proxied
         define_proxy_method
       end
@@ -54,11 +58,14 @@ module RSpec
       def define_proxy_method
         return if @method_is_proxied
 
-        save_original_method!
-        definition_target.class_exec(self, method_name, visibility) do |method_double, method_name, visibility|
+        save_original_implementation_callable!
+        definition_target.class_exec(self, method_name, @original_visibility || visibility) do |method_double, method_name, visibility|
           define_method(method_name) do |*args, &block|
             method_double.proxy_method_invoked(self, *args, &block)
           end
+          # This can't be `if respond_to?(:ruby2_keywords, true)`,
+          # see https://github.com/rspec/rspec-mocks/pull/1385#issuecomment-755340298
+          ruby2_keywords(method_name) if Module.private_method_defined?(:ruby2_keywords)
           __send__(visibility, method_name)
         end
 
@@ -72,14 +79,14 @@ module RSpec
       def proxy_method_invoked(_obj, *args, &block)
         @proxy.message_received method_name, *args, &block
       end
+      ruby2_keywords :proxy_method_invoked if respond_to?(:ruby2_keywords, true)
 
       # @private
       def restore_original_method
         return show_frozen_warning if object_singleton_class.frozen?
         return unless @method_is_proxied
 
-        definition_target.__send__(:remove_method, @method_name)
-
+        remove_method_from_definition_target
         @method_stasher.restore if @method_stasher.method_is_stashed?
         restore_original_visibility
 
@@ -102,7 +109,7 @@ module RSpec
         return unless @original_visibility &&
           MethodReference.method_defined_at_any_visibility?(object_singleton_class, @method_name)
 
-        object_singleton_class.__send__(*@original_visibility)
+        object_singleton_class.__send__(@original_visibility, method_name)
       end
 
       # @private
@@ -199,13 +206,13 @@ module RSpec
 
       # @private
       def raise_method_not_stubbed_error
-        raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+        RSpec::Mocks.error_generator.raise_method_not_stubbed_error(method_name)
       end
 
       # In Ruby 2.0.0 and above prepend will alter the method lookup chain.
       # We use an object's singleton class to define method doubles upon,
-      # however if the object has had it's singleton class (as opposed to
-      # it's actual class) prepended too then the the method lookup chain
+      # however if the object has had its singleton class (as opposed to
+      # its actual class) prepended too then the the method lookup chain
       # will look in the prepended module first, **before** the singleton
       # class.
       #
@@ -255,6 +262,30 @@ module RSpec
         end
 
       end
+
+    private
+
+      def remove_method_from_definition_target
+        definition_target.__send__(:remove_method, @method_name)
+      rescue NameError
+        # This can happen when the method has been monkeyed with by
+        # something outside RSpec. This happens, for example, when
+        # `file.write` has been stubbed, and then `file.reopen(other_io)`
+        # is later called, as `File#reopen` appears to redefine `write`.
+        #
+        # Note: we could avoid rescuing this by checking
+        # `definition_target.instance_method(@method_name).owner == definition_target`,
+        # saving us from the cost of the expensive exception, but this error is
+        # extremely rare (it was discovered on 2014-12-30, only happens on
+        # RUBY_VERSION < 2.0 and our spec suite only hits this condition once),
+        # so we'd rather avoid the cost of that check for every method double,
+        # and risk the rare situation where this exception will get raised.
+        RSpec.warn_with(
+          "WARNING: RSpec could not fully restore #{@object.inspect}." \
+          "#{@method_name}, possibly because the method has been redefined " \
+          "by something outside of RSpec."
+        )
+      end
     end
   end
 end

data/rspec-mocks/upstream/lib/rspec/mocks/method_reference.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_support 'comparable_version'
+
 module RSpec
   module Mocks
     # Represents a method on an object that may or may not be defined.
@@ -6,6 +8,10 @@ module RSpec
     #
     # @private
     class MethodReference
+      def self.for(object_reference, method_name)
+        new(object_reference, method_name)
+      end
+
       def initialize(object_reference, method_name)
         @object_reference = object_reference
         @method_name = method_name
@@ -58,14 +64,6 @@ module RSpec
         :public
       end
 
-    private
-
-      def original_method
-        @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
@@ -81,16 +79,32 @@ module RSpec
       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)
+        vis = instance_method_visibility_for(class << object; self; end, method_name)
+
+        # 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 vis unless vis.nil?
+
+        proxy = RSpec::Mocks.space.proxy_for(object)
+        respond_to = proxy.method_double_if_exists_for_message(:respond_to?)
+
+        visible = respond_to && respond_to.original_method.call(method_name) ||
+          object.respond_to?(method_name)
+
+        return :public if visible
+      end
+
+    private
+
+      def original_method
+        @object_reference.when_loaded do |m|
+          self.defined? && find_method(m)
         end
       end
     end
@@ -116,7 +130,7 @@ 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
+      if RUBY_PLATFORM == 'java' && RSpec::Support::ComparableVersion.new(JRUBY_VERSION) < '1.7.5'
         def find_method(mod)
           mod.dup.instance_method(@method_name)
         end
@@ -133,6 +147,14 @@ module RSpec
 
     # @private
     class ObjectMethodReference < MethodReference
+      def self.for(object_reference, method_name)
+        if ClassNewMethodReference.applies_to?(method_name) { object_reference.when_loaded { |o| o } }
+          ClassNewMethodReference.new(object_reference, method_name)
+        else
+          super
+        end
+      end
+
     private
 
       def method_implemented?(object)
@@ -151,5 +173,42 @@ module RSpec
         MethodReference.method_visibility_for(object, @method_name)
       end
     end
+
+    # When a class's `.new` method is stubbed, we want to use the method
+    # signature from `#initialize` because `.new`'s signature is a generic
+    # `def new(*args)` and it simply delegates to `#initialize` and forwards
+    # all args...so the method with the actually used signature is `#initialize`.
+    #
+    # This method reference implementation handles that specific case.
+    # @private
+    class ClassNewMethodReference < ObjectMethodReference
+      def self.applies_to?(method_name)
+        return false unless method_name == :new
+        klass = yield
+        return false unless ::Class === klass && klass.respond_to?(:new, true)
+
+        # We only want to apply our special logic to normal `new` methods.
+        # Methods that the user has monkeyed with should be left as-is.
+        uses_class_new?(klass)
+      end
+
+      if RUBY_VERSION.to_i >= 3
+        CLASS_NEW = ::Class.instance_method(:new)
+
+        def self.uses_class_new?(klass)
+          ::RSpec::Support.method_handle_for(klass, :new) == CLASS_NEW.bind(klass)
+        end
+      else # Ruby 2's Method#== is too strict
+        def self.uses_class_new?(klass)
+          ::RSpec::Support.method_handle_for(klass, :new).owner == ::Class
+        end
+      end
+
+      def with_signature
+        @object_reference.when_loaded do |klass|
+          yield Support::MethodSignature.new(klass.instance_method(:initialize))
+        end
+      end
+    end
   end
 end

data/rspec-mocks/upstream/lib/rspec/mocks/minitest_integration.rb

@@ -0,0 +1,68 @@
+require 'rspec/mocks'
+
+module RSpec
+  module Mocks
+    # @private
+    module MinitestIntegration
+      include ::RSpec::Mocks::ExampleMethods
+
+      def before_setup
+        ::RSpec::Mocks.setup
+        super
+      end
+
+      def after_teardown
+        super
+
+        # Only verify if there's not already an error. Otherwise
+        # we risk getting the same failure twice, since negative
+        # expectation violations raise both when the message is
+        # unexpectedly received, and also during `verify` (in case
+        # the first failure was caught by user code via a
+        # `rescue Exception`).
+        ::RSpec::Mocks.verify unless failures.any?
+      ensure
+        ::RSpec::Mocks.teardown
+      end
+    end
+  end
+end
+
+Minitest::Test.send(:include, RSpec::Mocks::MinitestIntegration)
+
+if defined?(::Minitest::Expectation)
+  if defined?(::RSpec::Expectations) && ::Minitest::Expectation.method_defined?(:to)
+    # rspec/expectations/minitest_integration has already been loaded and
+    # has defined `to`/`not_to`/`to_not` on `Minitest::Expectation` so we do
+    # not want to here (or else we would interfere with rspec-expectations' definition).
+  else
+    # ...otherwise, define those methods now. If `rspec/expectations/minitest_integration`
+    # is loaded after this file, it'll overide the defintion here.
+    Minitest::Expectation.class_eval do
+      include RSpec::Mocks::ExpectationTargetMethods
+
+      def to(*args)
+        ctx.assertions += 1
+        super
+      end
+
+      def not_to(*args)
+        ctx.assertions += 1
+        super
+      end
+
+      def to_not(*args)
+        ctx.assertions += 1
+        super
+      end
+    end
+  end
+end
+
+module RSpec
+  module Mocks
+    remove_const :MockExpectationError
+    # Raised when a message expectation is not satisfied.
+    MockExpectationError = ::Minitest::Assertion
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/mutate_const.rb

@@ -13,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.
@@ -24,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.
@@ -50,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}>"
@@ -58,13 +66,16 @@ 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.
@@ -94,6 +105,10 @@ module RSpec
       #  so you can stub constants in other contexts (e.g. helper
       #  classes).
       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

data/rspec-mocks/upstream/lib/rspec/mocks/object_reference.rb

@@ -6,8 +6,17 @@ module RSpec
       # on the given argument.
       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)
@@ -17,74 +26,123 @@ module RSpec
           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
 
       def object
-        @object ||= Constant.original(@const_name).original_value
+        return @object if defined?(@object)
+        @object = Constant.original(@const_name).original_value
       end
     end
   end