opal-rspec 0.4.3 → 0.5.0.beta1

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/method_double.rb

@@ -25,7 +25,7 @@ module RSpec
         # method handles for missing methods even if `respond_to?` is correct.
         @original_method ||=
           @method_stasher.original_method ||
-          @proxy.method_handle_for(method_name) ||
+          @proxy.original_method_handle_for(method_name) ||
           Proc.new do |*args, &block|
             @object.__send__(:method_missing, @method_name, *args, &block)
           end
@@ -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
@@ -63,12 +55,11 @@ module RSpec
         return if @method_is_proxied
 
         save_original_method!
-
-        object_singleton_class.class_exec(self, method_name, visibility) do |method_double, method_name, visibility|
+        definition_target.class_exec(self, method_name, visibility) do |method_double, method_name, visibility|
           define_method(method_name) do |*args, &block|
             method_double.proxy_method_invoked(self, *args, &block)
           end
-          self.__send__ visibility, method_name
+          __send__(visibility, method_name)
         end
 
         @method_is_proxied = true
@@ -78,35 +69,45 @@ module RSpec
       # method to perform additional operations.
       #
       # @private
-      def proxy_method_invoked(obj, *args, &block)
+      def proxy_method_invoked(_obj, *args, &block)
         @proxy.message_received method_name, *args, &block
       end
 
       # @private
       def restore_original_method
+        return show_frozen_warning if object_singleton_class.frozen?
         return unless @method_is_proxied
 
-        object_singleton_class.__send__(:remove_method, @method_name)
-        if @method_stasher.method_is_stashed?
-          @method_stasher.restore
-        end
+        definition_target.__send__(:remove_method, @method_name)
+
+        @method_stasher.restore if @method_stasher.method_is_stashed?
         restore_original_visibility
 
         @method_is_proxied = false
       end
 
+      # @private
+      def show_frozen_warning
+        RSpec.warn_with(
+          "WARNING: rspec-mocks was unable to restore the original `#{@method_name}` " \
+          "method on #{@object.inspect} because it has been frozen.  If you reuse this " \
+          "object, `#{@method_name}` will continue to respond with its stub implementation.",
+          :call_site                      => nil,
+          :use_spec_location_as_call_site => true
+        )
+      end
+
       # @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
 
       # @private
       def verify
-        expectations.each {|e| e.verify_messages_received}
+        expectations.each { |e| e.verify_messages_received }
       end
 
       # @private
@@ -133,7 +134,7 @@ module RSpec
       def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation)
         configure_method
         expectation = message_expectation_class.new(error_generator, expectation_ordering,
-                                             expected_from, self, 1, opts, &implementation)
+                                                    expected_from, self, :expectation, opts, &implementation)
         expectations << expectation
         expectation
       end
@@ -148,7 +149,7 @@ module RSpec
       def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)
         configure_method
         stub = message_expectation_class.new(error_generator, expectation_ordering, expected_from,
-                                      self, :any, opts, &implementation)
+                                             self, :stub, opts, &implementation)
         stubs.unshift stub
         stub
       end
@@ -171,7 +172,7 @@ module RSpec
       end
 
       # @private
-      def setup_simple_method_double(method_name, response, collection, error_generator = nil, backtrace_line = nil)
+      def setup_simple_method_double(method_name, response, collection, error_generator=nil, backtrace_line=nil)
         define_proxy_method
 
         me = SimpleMessageExpectation.new(method_name, response, error_generator, backtrace_line)
@@ -188,13 +189,12 @@ module RSpec
       # @private
       def remove_stub
         raise_method_not_stubbed_error if stubs.empty?
-        expectations.empty? ? reset : stubs.clear
+        remove_stub_if_present
       end
 
       # @private
-      def remove_single_stub(stub)
-        stubs.delete(stub)
-        restore_original_method if stubs.empty? && expectations.empty?
+      def remove_stub_if_present
+        expectations.empty? ? reset : stubs.clear
       end
 
       # @private
@@ -202,8 +202,59 @@ module RSpec
         raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
       end
 
-      # @private
-      IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
+      # 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
+      # will look in the prepended module first, **before** the singleton
+      # class.
+      #
+      # This code works around that by providing a mock definition target
+      # that is either the singleton class, or if necessary, a prepended module
+      # of our own.
+      #
+      if Support::RubyFeatures.module_prepends_supported?
+
+        private
+
+        # We subclass `Module` in order to be able to easily detect our prepended module.
+        RSpecPrependedModule = Class.new(Module)
+
+        def definition_target
+          @definition_target ||= usable_rspec_prepended_module || object_singleton_class
+        end
+
+        def usable_rspec_prepended_module
+          @proxy.prepended_modules_of_singleton_class.each do |mod|
+            # If we have one of our modules prepended before one of the user's
+            # modules that defines the method, use that, since our module's
+            # definition will take precedence.
+            return mod if RSpecPrependedModule === mod
+
+            # If we hit a user module with the method defined first,
+            # we must create a new prepend module, even if one exists later,
+            # because ours will only take precedence if it comes first.
+            return new_rspec_prepended_module if mod.method_defined?(method_name)
+          end
+
+          nil
+        end
+
+        def new_rspec_prepended_module
+          RSpecPrependedModule.new.tap do |mod|
+            object_singleton_class.__send__ :prepend, mod
+          end
+        end
+
+      else
+
+        private
+
+        def definition_target
+          object_singleton_class
+        end
+
+      end
     end
   end
 end

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

@@ -0,0 +1,155 @@
+module RSpec
+  module Mocks
+    # 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(object_reference, method_name)
+        @object_reference = object_reference
+        @method_name = method_name
+      end
+
+      # A method is implemented if sending the message does not result in
+      # a `NoMethodError`. It might be dynamically implemented by
+      # `method_missing`.
+      def implemented?
+        @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?
+        @object_reference.when_loaded do |m|
+          method_defined?(m)
+        end
+      end
+
+      def with_signature
+        return unless (original = original_method)
+        yield Support::MethodSignature.new(original)
+      end
+
+      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
+        @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?(mod)
+        MethodReference.method_defined_at_any_visibility?(mod, @method_name)
+      end
+
+      # Ideally, we'd use `respond_to?` for `method_implemented?` but we need a
+      # reference to an instance to do that and we don't have one.  Note that
+      # we may get false negatives: if the method is implemented via
+      # `method_missing`, we'll return `false` even though it meets our
+      # definition of "implemented". However, it's the best we can do.
+      alias method_defined? method_implemented?
+
+      # works around the fact that repeated calls for method parameters will
+      # falsely return empty arrays on JRuby in certain circumstances, this
+      # is necessary here because we can't dup/clone UnboundMethods.
+      #
+      # 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(mod)
+          mod.dup.instance_method(@method_name)
+        end
+      else
+        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?(object)
+        object.respond_to?(@method_name, true)
+      end
+
+      def method_defined?(object)
+        (class << object; self; end).method_defined?(@method_name)
+      end
+
+      def find_method(object)
+        object.method(@method_name)
+      end
+
+      def visibility_from(object)
+        MethodReference.method_visibility_for(object, @method_name)
+      end
+    end
+  end
+end