Sketch of fix for delegate private method stubbing

lib/rspec/support.rb

@@ -42,7 +42,42 @@ def self.define_optimized_require_for_rspec(lib, &require_relative)
     #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
     if RUBY_VERSION.to_i >= 2 && RUBY_ENGINE != 'rbx'
       def self.method_handle_for(object, method_name)
-        KERNEL_METHOD_METHOD.bind(object).call(method_name)
+        if object_is_a_delegator?(object) && kernel_has_private_method?(method_name) && !object_has_own_method?(object, method_name)
+          ::Kernel.method(method_name)
+        else
+          KERNEL_METHOD_METHOD.bind(object).call(method_name)
+        end
+      end
+
+      # I came up with two implementations of this, one that does ancestor
+      # checking and one that does respond_to __getobj__ checking. I'm not
+      # sure which is more appropriate
+      def self.object_is_a_delegator?(object)
+        object_has_getobj_method?(object)
+      end
+
+      def self.object_is_a_delegator?(object)
+        object_has_class_method?(object) && object_has_delegator_as_an_ancestor?(object)
+      end
+
+      def self.object_has_getobj_method?(object)
+       ::Kernel.instance_method(:methods).bind(object).call.include?(:__getobj__)
+      end
+
+      def self.object_has_delegator_as_an_ancestor?(object)
+         object.class.ancestors.map(&:name).include?("Delegator")
+      end
+
+      def self.object_has_class_method?(object)
+       ::Kernel.instance_method(:methods).bind(object).call.include?(:class)
+      end
+
+      def self.kernel_has_private_method?(method_name)
+        ::Kernel.private_instance_methods.include?(method_name)
+      end
+
+      def self.object_has_own_method?(object, method_name)
+        object.methods.include?(method_name)
       end
     else
       def self.method_handle_for(object, method_name)

spec/rspec/support_spec.rb

@@ -1,4 +1,5 @@
 require 'rspec/support'
+require "delegate"
 
 module RSpec
   describe Support do
@@ -21,6 +22,84 @@ def foo
         expect(Support.method_handle_for(request, :uri).call).to eq "http://foo.com/"
       end
 
+      context "with a delegator that does not implement a private kernel method" do
+        subject {
+          Class.new(SimpleDelegator) do
+            def foo
+              rand(2)
+            end
+          end
+        }
+
+        it "does not issue a warning when stubbing the private kernel method" do
+          hash = subject.new({})
+          expect(hash).not_to receive(:warn)
+
+          allow(hash).to receive(:rand).and_call_original
+          hash.foo
+        end
+
+        it "replaces the rand method" do
+          hash = subject.new({})
+          expect(hash).not_to receive(:warn)
+
+          allow(hash).to receive(:rand).and_return(3)
+          expect(hash.foo).to eq(3)
+        end
+
+        it "puts the correct rand method back" do
+          hash = subject.new({})
+
+          allow(hash).to receive(:rand).and_call_original
+          RSpec::Mocks.space.reset_all
+          expect(hash.send(:rand)).to be_between(0,1)
+        end
+      end
+      context "with a delegator that does implement a private kernel method" do
+        subject {
+          Class.new(SimpleDelegator) do
+            def rand(n)
+              n
+            end
+
+            def foo
+              rand(2)
+            end
+          end
+        }
+
+        it "does not issue a warning when stubbing the private kernel method" do
+          hash = subject.new({})
+          expect(hash).not_to receive(:warn)
+
+          allow(hash).to receive(:rand).and_call_original
+          hash.foo
+        end
+
+        it "gets the correct method with and_call_original" do
+          hash = subject.new({})
+
+          allow(hash).to receive(:rand).and_call_original
+          expect(hash.foo).to eq(2)
+        end
+
+        it "it gets the correct stub implementation" do
+          hash = subject.new({})
+
+          allow(hash).to receive(:rand).and_return(3)
+          expect(hash.foo).to eq(3)
+        end
+
+        it "puts the correct method back" do
+          hash = subject.new({})
+
+          allow(hash).to receive(:rand).and_return(3)
+          RSpec::Mocks.space.reset_all
+          expect(hash.foo).to eq(2)
+        end
+      end
+
+
       context "for a BasicObject subclass", :if => RUBY_VERSION.to_f > 1.8 do
         let(:basic_class) do
           Class.new(BasicObject) do