rspec-mocks 3.13.8 → 4.0.0.beta1

data/lib/rspec/mocks/instance_method_stasher.rb

@@ -5,93 +5,36 @@ module RSpec
       def initialize(object, method)
         @object = object
         @method = method
+        # We don't want to create singleton class if it doesn't exist,
+        # so we don't use `object.singleton_class`.
         @klass = (class << object; self; end)
 
         @original_method = nil
-        @method_is_stashed = false
       end
 
       attr_reader :original_method
 
-      if RUBY_VERSION.to_f < 1.9
-        # @private
-        def method_is_stashed?
-          @method_is_stashed
-        end
-
-        # @private
-        def stash
-          return if !method_defined_directly_on_klass? || @method_is_stashed
-
-          @klass.__send__(:alias_method, stashed_method_name, @method)
-          @method_is_stashed = true
-        end
-
-        # @private
-        def stashed_method_name
-          "obfuscated_by_rspec_mocks__#{@method}"
-        end
-
-        # @private
-        def restore
-          return unless @method_is_stashed
-
-          if @klass.__send__(:method_defined?, @method)
-            @klass.__send__(:undef_method, @method)
-          end
-          @klass.__send__(:alias_method, @method, stashed_method_name)
-          @klass.__send__(:remove_method, stashed_method_name)
-          @method_is_stashed = false
-        end
-      else
-
-        # @private
-        def method_is_stashed?
-          !!@original_method
-        end
-
-        # @private
-        def stash
-          return unless method_defined_directly_on_klass?
-          @original_method ||= ::RSpec::Support.method_handle_for(@object, @method)
-          @klass.__send__(:undef_method, @method)
-        end
+      # @private
+      def method_is_stashed?
+        !!@original_method
+      end
 
-        # @private
-        def restore
-          return unless @original_method
+      # @private
+      def stash
+        return unless method_defined_directly_on_klass?
+        @original_method ||= ::RSpec::Support.method_handle_for(@object, @method)
+        @klass.undef_method(@method)
+      end
 
-          if @klass.__send__(:method_defined?, @method)
-            @klass.__send__(:undef_method, @method)
-          end
+      # @private
+      def restore
+        return unless @original_method
 
-          handle_restoration_failures do
-            @klass.__send__(:define_method, @method, @original_method)
-          end
+        @klass.undef_method(@method) if @klass.method_defined?(@method)
 
-          @original_method = nil
-        end
-      end
+        @klass.define_method(@method, @original_method)
 
-      if RUBY_DESCRIPTION.include?('2.0.0p247') || RUBY_DESCRIPTION.include?('2.0.0p195')
-        # ruby 2.0.0-p247 and 2.0.0-p195 both have a bug that we can't work around :(.
-        # https://bugs.ruby-lang.org/issues/8686
-        def handle_restoration_failures
-          yield
-        rescue TypeError
-          RSpec.warn_with(
-            "RSpec failed to properly restore a partial double (#{@object.inspect}) " \
-            "to its original state due to a known bug in MRI 2.0.0-p195 & p247 " \
-            "(https://bugs.ruby-lang.org/issues/8686). This object may remain " \
-            "screwed up for the rest of this process. Please upgrade to 2.0.0-p353 or above.",
-            :call_site => nil, :use_spec_location_as_call_site => true
-          )
-        end
-      else
-        def handle_restoration_failures
-          # No known reasons for restoration to fail on other rubies.
-          yield
-        end
+        @original_method = nil
       end
 
     private
@@ -109,37 +52,17 @@ module RSpec
       def method_owned_by_klass?
         owner = @klass.instance_method(@method).owner
 
-        # On Ruby 2.0.0+ the owner of a method on a class which has been
+        # The owner of a method on a class which has been
         # `prepend`ed may actually be an instance, e.g.
         # `#<MyClass:0x007fbb94e3cd10>`, rather than the expected `MyClass`.
         owner = owner.class unless Module === owner
 
-        # On some 1.9s (e.g. rubinius) aliased methods
-        # can report the wrong owner. Example:
-        # class MyClass
-        #   class << self
-        #     alias alternate_new new
-        #   end
-        # end
-        #
-        # MyClass.owner(:alternate_new) returns `Class` when incorrect,
-        # but we need to consider the owner to be `MyClass` because
-        # it is not actually available on `Class` but is on `MyClass`.
-        # Hence, we verify that the owner actually has the method defined.
-        # If the given owner does not have the method defined, we assume
-        # that the method is actually owned by @klass.
-        #
-        # On 1.8, aliased methods can also report the wrong owner. Example:
-        # module M
-        #   def a; end
-        #   module_function :a
-        #   alias b a
-        #   module_function :b
-        # end
-        # The owner of M.b is the raw Module object, instead of the expected
-        # singleton class of the module
-        return true if RUBY_VERSION < '1.9' && owner == @object
-        owner == @klass || !(method_defined_on_klass?(owner))
+        owner == @klass ||
+          # When `extend self` is used, and not under `allow_any_instance_of`
+          # nor `expect_any_instance_of`.
+          (owner.singleton_class == @klass &&
+            !Mocks.space.any_instance_recorder_for(owner, true)) ||
+          !(method_defined_on_klass?(owner))
       end
     end
   end

data/lib/rspec/mocks/message_expectation.rb

@@ -1,4 +1,4 @@
-RSpec::Support.require_rspec_support 'mutex'
+RSpec::Support.require_rspec_support 'reentrant_mutex'
 
 module RSpec
   module Mocks
@@ -415,7 +415,6 @@ module RSpec
         attr_reader :orig_object
         attr_writer :expected_received_count, :expected_from, :argument_list_matcher
         protected :expected_received_count=, :expected_from=, :error_generator=, :implementation=
-
         # @private
         attr_reader :type
 
@@ -849,7 +848,7 @@ module RSpec
 
       def cannot_modify_further_error
         CannotModifyFurtherError.new "This method has already been configured " \
-          "to call the original implementation, and cannot be modified further."
+                                     "to call the original implementation, and cannot be modified further."
       end
     end
   end

data/lib/rspec/mocks/method_double.rb

@@ -2,9 +2,6 @@ module RSpec
   module Mocks
     # @private
     class MethodDouble
-      # @private TODO: drop in favor of FrozenError in ruby 2.5+
-      FROZEN_ERROR_MSG = /can't modify frozen/
-
       # @private
       attr_reader :method_name, :object, :expectations, :stubs, :method_stasher
 
@@ -24,8 +21,7 @@ module RSpec
       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.
+        # correctly defined `respond_to?`.
         @original_implementation_callable ||= original_method || method_missing_block
       end
 
@@ -54,6 +50,8 @@ module RSpec
 
       # @private
       def object_singleton_class
+        # We can't use @object.singleton_class because this method
+        # creates a new singleton class if the object doesn't have one.
         class << @object; self; end
       end
 
@@ -70,8 +68,19 @@ module RSpec
 
         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)
+          if RUBY_VERSION.to_f > 3 && method_name == :respond_to?
+            define_method(method_name) do |*args, &block|
+              # This is a work around for a respond_to? check within kernel_inspect
+              if caller_locations[0].label == "Kernel#inspect"
+                super(*args, &block)
+              else
+                method_double.proxy_method_invoked(self, *args, &block)
+              end
+            end
+          else
+            define_method(method_name) do |*args, &block|
+              method_double.proxy_method_invoked(self, *args, &block)
+            end
           end
           # This can't be `if respond_to?(:ruby2_keywords, true)`,
           # see https://github.com/rspec/rspec-mocks/pull/1385#issuecomment-755340298
@@ -80,14 +89,8 @@ module RSpec
         end
 
         @method_is_proxied = true
-      rescue RuntimeError, TypeError => e
-        # TODO: drop in favor of FrozenError in ruby 2.5+
-        #  RuntimeError (and FrozenError) for ruby 2.x
-        #  TypeError for ruby 1.x
-        if (defined?(FrozenError) && e.is_a?(FrozenError)) || FROZEN_ERROR_MSG === e.message
-          raise ArgumentError, "Cannot proxy frozen objects, rspec-mocks relies on proxies for method stubbing and expectations."
-        end
-        raise
+      rescue FrozenError
+        raise ArgumentError, "Cannot proxy frozen objects, rspec-mocks relies on proxies for method stubbing and expectations."
       end
 
       # The implementation of the proxied method. Subclasses may override this
@@ -104,18 +107,15 @@ module RSpec
         return unless @method_is_proxied
 
         remove_method_from_definition_target
-        @method_stasher.restore if @method_stasher.method_is_stashed?
-        restore_original_visibility
 
-        @method_is_proxied = false
-      rescue RuntimeError, TypeError => e
-        # TODO: drop in favor of FrozenError in ruby 2.5+
-        #  RuntimeError (and FrozenError) for ruby 2.x
-        #  TypeError for ruby 1.x
-        if (defined?(FrozenError) && e.is_a?(FrozenError)) || FROZEN_ERROR_MSG === e.message
-          return show_frozen_warning
+        if @method_stasher.method_is_stashed?
+          @method_stasher.restore
+          restore_original_visibility
         end
-        raise
+
+        @method_is_proxied = false
+      rescue FrozenError
+        return show_frozen_warning
       end
 
       # @private
@@ -131,10 +131,7 @@ module RSpec
 
       # @private
       def restore_original_visibility
-        return unless @original_visibility &&
-          MethodReference.method_defined_at_any_visibility?(object_singleton_class, @method_name)
-
-        object_singleton_class.__send__(@original_visibility, method_name)
+        method_owner.__send__(@original_visibility, @method_name)
       end
 
       # @private
@@ -234,7 +231,9 @@ module RSpec
         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.
+      private
+
+      # Prepend alters the method lookup chain.
       # We use an object's singleton class to define method doubles upon,
       # however if the object has had its singleton class (as opposed to
       # its actual class) prepended too then the the method lookup chain
@@ -244,54 +243,44 @@ module RSpec
       # 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
+      # We subclass `Module` in order to be able to easily detect our prepended module.
+      RSpecPrependedModule = Class.new(Module)
 
-          nil
-        end
+      def definition_target
+        @definition_target ||= usable_rspec_prepended_module || object_singleton_class
+      end
 
-        def new_rspec_prepended_module
-          RSpecPrependedModule.new.tap do |mod|
-            object_singleton_class.__send__ :prepend, mod
-          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
 
-      else
-
-        private
+        nil
+      end
 
-        def definition_target
-          object_singleton_class
+      def new_rspec_prepended_module
+        RSpecPrependedModule.new.tap do |mod|
+          @object.singleton_class.prepend mod
         end
-
       end
 
-    private
+      def method_owner
+        @method_owner ||=
+          # We do this because object.method might be overridden.
+          ::RSpec::Support.method_handle_for(object, @method_name).owner
+      end
 
       def remove_method_from_definition_target
-        definition_target.__send__(:remove_method, @method_name)
+        definition_target.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
@@ -301,10 +290,11 @@ module RSpec
         # 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.
+        # extremely rare 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. This was originally discovered in the core library of older
+        # unsupported Rubies, (< 3.0) but could happen in code under test
+        # during meta-programming.
         RSpec.warn_with(
           "WARNING: RSpec could not fully restore #{@object.inspect}." \
           "#{@method_name}, possibly because the method has been redefined " \

data/lib/rspec/mocks/method_reference.rb

@@ -1,5 +1,3 @@
-RSpec::Support.require_rspec_support 'comparable_version'
-
 module RSpec
   module Mocks
     # Represents a method on an object that may or may not be defined.
@@ -94,7 +92,7 @@ module RSpec
         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) ||
+        visible = (respond_to && respond_to.original_method.call(method_name)) ||
           object.respond_to?(method_name)
 
         return :public if visible
@@ -124,20 +122,8 @@ module RSpec
       # 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' && RSpec::Support::ComparableVersion.new(JRUBY_VERSION) < '1.7.5'
-        def find_method(mod)
-          mod.dup.instance_method(@method_name)
-        end
-      else
-        def find_method(mod)
-          mod.instance_method(@method_name)
-        end
+      def find_method(mod)
+        mod.instance_method(@method_name)
       end
 
       def visibility_from(mod)
@@ -162,6 +148,8 @@ module RSpec
       end
 
       def method_defined?(object)
+        # We don't want to create singleton class if it doesn't exist,
+        # so we don't use `object.singleton_class`.
         (class << object; self; end).method_defined?(@method_name)
       end
 
@@ -192,16 +180,10 @@ module RSpec
         uses_class_new?(klass)
       end
 
-      if RUBY_VERSION.to_i >= 3
-        CLASS_NEW = ::Class.instance_method(:new)
+      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
+      def self.uses_class_new?(klass)
+        ::RSpec::Support.method_handle_for(klass, :new) == CLASS_NEW.bind(klass)
       end
 
       def with_signature

data/lib/rspec/mocks/minitest_integration.rb

@@ -28,7 +28,7 @@ module RSpec
   end
 end
 
-Minitest::Test.send(:include, RSpec::Mocks::MinitestIntegration)
+Minitest::Test.__send__(:include, RSpec::Mocks::MinitestIntegration)
 
 if defined?(::Minitest::Expectation)
   if defined?(::RSpec::Expectations) && ::Minitest::Expectation.method_defined?(:to)

data/lib/rspec/mocks/mutate_const.rb

@@ -248,7 +248,6 @@ module RSpec
           end
 
           if Array === @transfer_nested_constants
-            @transfer_nested_constants = @transfer_nested_constants.map(&:to_s) if RUBY_VERSION == '1.8.7'
             undefined_constants = @transfer_nested_constants - constants_defined_on(@original_value)
 
             if undefined_constants.any?

data/lib/rspec/mocks/object_reference.rb

@@ -27,14 +27,8 @@ module RSpec
         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
+      def self.anonymous_module?(mod)
+        !name_of(mod)
       end
       private_class_method :anonymous_module?
 

data/lib/rspec/mocks/order_group.rb

@@ -1,5 +1,3 @@
-RSpec::Support.require_rspec_support 'reentrant_mutex'
-
 module RSpec
   module Mocks
     # @private
@@ -7,7 +5,6 @@ module RSpec
       def initialize
         @expectations = []
         @invocation_order = []
-        @invocation_order_mutex = Support::Mutex.new
         @index = 0
       end
 
@@ -17,9 +14,7 @@ module RSpec
       end
 
       def invoked(message)
-        @invocation_order_mutex.synchronize do
-          @invocation_order << message
-        end
+        @invocation_order << message
       end
 
       # @private
@@ -52,9 +47,7 @@ module RSpec
 
       def clear
         @index = 0
-        @invocation_order_mutex.synchronize do
-          @invocation_order.clear
-        end
+        @invocation_order.clear
         @expectations.clear
       end
 
@@ -73,15 +66,11 @@ module RSpec
       end
 
       def invoked_expectations
-        @invocation_order_mutex.synchronize do
-          @expectations.select { |e| e.ordered? && @invocation_order.include?(e) }
-        end
+        @expectations.select { |e| e.ordered? && @invocation_order.include?(e) }
       end
 
       def expected_invocations
-        @invocation_order_mutex.synchronize do
-          @invocation_order.map { |invocation| expectation_for(invocation) }.compact
-        end
+        @invocation_order.map { |invocation| expectation_for(invocation) }.compact
       end
 
       def expectation_for(message)

data/lib/rspec/mocks/proxy.rb

@@ -1,4 +1,4 @@
-RSpec::Support.require_rspec_support 'mutex'
+RSpec::Support.require_rspec_support "reentrant_mutex"
 
 module RSpec
   module Mocks
@@ -240,20 +240,14 @@ module RSpec
         :public
       end
 
-      if Support::RubyFeatures.module_prepends_supported?
-        def self.prepended_modules_of(klass)
-          ancestors = klass.ancestors
-
-          # `|| 0` is necessary for Ruby 2.0, where the singleton class
-          # is only in the ancestor list when there are prepended modules.
-          singleton_index = ancestors.index(klass) || 0
-
-          ancestors[0, singleton_index]
-        end
+      def self.prepended_modules_of(klass)
+        ancestors = klass.ancestors
+        singleton_index = ancestors.index(klass)
+        ancestors[0, singleton_index]
+      end
 
-        def prepended_modules_of_singleton_class
-          @prepended_modules_of_singleton_class ||= RSpec::Mocks::Proxy.prepended_modules_of(@object.singleton_class)
-        end
+      def prepended_modules_of_singleton_class
+        @prepended_modules_of_singleton_class ||= RSpec::Mocks::Proxy.prepended_modules_of(@object.singleton_class)
       end
 
       # @private
@@ -409,19 +403,6 @@ module RSpec
 
         return super unless unbound_method
         unbound_method.bind(object)
-        # :nocov:
-      rescue TypeError
-        if RUBY_VERSION == '1.8.7'
-          # In MRI 1.8.7, a singleton method on a class cannot be rebound to its subclass
-          if unbound_method && unbound_method.owner.ancestors.first != unbound_method.owner
-            # This is a singleton method; we can't do anything with it
-            # But we can work around this using a different implementation
-            double = method_double_from_ancestor_for(message)
-            return object.method(double.method_stasher.stashed_method_name)
-          end
-        end
-        raise
-        # :nocov:
       end
 
     protected

data/lib/rspec/mocks/space.rb

@@ -137,6 +137,8 @@ module RSpec
 
         # We access the ancestors through the singleton class, to avoid calling
         # `class` in case `class` has been stubbed.
+        # We can't use `object.singleton_class` here, as this method creates
+        # a new singleton class for the object if the object doesn't have one.
         (class << object; ancestors; end).map do |klass|
           any_instance_recorders[klass.__id__]
         end.compact
@@ -185,23 +187,8 @@ module RSpec
         any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
       end
 
-      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
-        require 'securerandom'
-
-        def id_for(object)
-          id = object.__id__
-
-          return id if object.equal?(::ObjectSpace._id2ref(id))
-          # this suggests that object.__id__ is proxying through to some wrapped object
-
-          object.instance_exec do
-            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
-          end
-        end
-      else
-        def id_for(object)
-          object.__id__
-        end
+      def id_for(object)
+        object.__id__
       end
     end
 

data/lib/rspec/mocks/standalone.rb

@@ -1,3 +1,5 @@
 require 'rspec/mocks'
+
 extend RSpec::Mocks::ExampleMethods
+
 RSpec::Mocks.setup

data/lib/rspec/mocks/test_double.rb

@@ -87,21 +87,23 @@ module RSpec
           end
         end
 
+        visibility = proxy.visibility_for(message)
+
         # Defined private and protected methods will still trigger `method_missing`
         # when called publicly. We want ruby's method visibility error to get raised,
         # so we simply delegate to `super` in that case.
+        #   return super if visibility == :private || visibility == :protected
         # ...well, we would delegate to `super`, but there's a JRuby
         # bug, so we raise our own visibility error instead:
         # https://github.com/jruby/jruby/issues/1398
-        visibility = proxy.visibility_for(message)
+        # Only works without this workaround with JRuby 9.2
         if visibility == :private || visibility == :protected
           ErrorGenerator.new(self).raise_non_public_error(
             message, visibility
           )
         end
 
-        # Required wrapping doubles in an Array on Ruby 1.9.2
-        raise NoMethodError if [:to_a, :to_ary].include? message
+        raise NoMethodError if message == :to_ary || message == :to_a
         proxy.raise_unexpected_message_error(message, args)
       end