rr 0.10.11 → 1.0.0

data/lib/rr/injections/injection.rb

@@ -1,29 +1,27 @@
 module RR
   module Injections
     class Injection
-      class << self
+      extend(Module.new do
         def instances
           @instances ||= HashWithObjectIdKey.new
         end
-      end
+      end)
 
       include Space::Reader
 
-      attr_reader :subject
-
       def subject_has_method_defined?(method_name_in_question)
-        @subject.methods.detect {|method_name| method_name.to_sym == method_name_in_question.to_sym} ||
-          @subject.protected_methods.detect {|method_name| method_name.to_sym == method_name_in_question.to_sym} ||
-          @subject.private_methods.detect {|method_name| method_name.to_sym == method_name_in_question.to_sym}
+        ClassInstanceMethodDefined.call(subject_class, method_name_in_question)
       end
 
       def subject_has_original_method?
-        subject_respond_to_method?(original_method_alias_name)
+        subject_has_method_defined?(original_method_alias_name)
       end
 
       protected
-      def subject_respond_to_method?(method_name)
-        subject_has_method_defined?(method_name) || @subject.respond_to?(method_name)
+      def subject_respond_to_method?(subject, method_name)
+        subject_has_method_defined?(method_name) ||
+          ClassInstanceMethodDefined.call(subject_class, :respond_to?) &&
+          subject.respond_to?(method_name)
       end
     end
   end

data/lib/rr/injections/method_missing_injection.rb

@@ -1,26 +1,27 @@
 module RR
   module Injections
     class MethodMissingInjection < Injection
-      class << self
-        def create(subject)
-          instances[subject] ||= begin
-            new(subject).bind
+      extend(Module.new do
+        def find_or_create(subject_class)
+          instances[subject_class] ||= begin
+            new(subject_class).bind
           end
         end
 
         def exists?(subject)
           instances.include?(subject)
         end
-      end
+      end)
 
-      def initialize(subject)
-        @subject = subject
+      attr_reader :subject_class
+      def initialize(subject_class)
+        @subject_class = subject_class
         @placeholder_method_defined = false
       end
 
       def bind
-        unless subject.respond_to?(original_method_alias_name)
-          unless subject.respond_to?(:method_missing)
+        unless ClassInstanceMethodDefined.call(subject_class, original_method_alias_name)
+          unless ClassInstanceMethodDefined.call(subject_class, :method_missing)
             @placeholder_method_defined = true
             subject_class.class_eval do
               def method_missing(method_name, *args, &block)
@@ -48,22 +49,14 @@ module RR
         end
       end
 
-      def dispatch_method(method_name, args, block)
-        MethodDispatches::MethodMissingDispatch.new(subject, method_name, args, block).call
-      end
-
       protected
-      def subject_class
-        class << subject; self; end
-      end
-
       def bind_method
-        returns_method = <<-METHOD
+        subject_class_object_id = subject_class.object_id
+        subject_class.class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
         def method_missing(method_name, *args, &block)
-          RR::Injections::MethodMissingInjection.create(self).dispatch_method(method_name, args, block)
+          MethodDispatches::MethodMissingDispatch.new(self, ObjectSpace._id2ref(#{subject_class_object_id}), method_name, args, block).call
         end
         METHOD
-        subject_class.class_eval(returns_method, __FILE__, __LINE__ - 4)
       end
 
       def original_method_alias_name

data/lib/rr/injections/singleton_method_added_injection.rb

@@ -1,26 +1,31 @@
 module RR
   module Injections
     class SingletonMethodAddedInjection < Injection
-      class << self
-        def create(subject)
-          instances[subject] ||= begin
-            new(subject).bind
+      extend(Module.new do
+        def find_or_create(subject_class)
+          instances[subject_class] ||= begin
+            new(subject_class).bind
           end
         end
 
+        def find(subject)
+          instances[subject]
+        end
+
         def exists?(subject)
           instances.include?(subject)
         end
-      end
+      end)
 
-      def initialize(subject)
-        @subject = subject
+      attr_reader :subject_class
+      def initialize(subject_class)
+        @subject_class = subject_class
         @placeholder_method_defined = false
       end
 
       def bind
-        unless subject.respond_to?(original_method_alias_name)
-          unless subject.respond_to?(:singleton_method_added)
+        unless ClassInstanceMethodDefined.call(subject_class, original_method_alias_name, false)
+          unless ClassInstanceMethodDefined.call(subject_class, :singleton_method_added, false)
             @placeholder_method_defined = true
             subject_class.class_eval do
               def singleton_method_added(method_name)
@@ -29,14 +34,15 @@ module RR
             end
           end
 
-          memoized_subject = subject
           memoized_original_method_alias_name = original_method_alias_name
           subject_class.__send__(:alias_method, original_method_alias_name, :singleton_method_added)
+          memoized_subject_class = subject_class
+          memoized_original_method_alias_name = original_method_alias_name
           subject_class.__send__(:define_method, :singleton_method_added) do |method_name_arg|
-            if Injections::DoubleInjection.exists?(memoized_subject, method_name_arg)
-              Injections::DoubleInjection.create(memoized_subject, method_name_arg).send(:deferred_bind_method)
+            if Injections::DoubleInjection.exists?(memoized_subject_class, method_name_arg)
+              Injections::DoubleInjection.find_or_create(memoized_subject_class, method_name_arg).send(:deferred_bind_method)
             end
-            send(memoized_original_method_alias_name, method_name_arg)
+            __send__(memoized_original_method_alias_name, method_name_arg)
           end
         end
         self
@@ -57,10 +63,6 @@ module RR
       end
 
       protected
-      def subject_class
-        class << subject; self; end
-      end
-
       def original_method_alias_name
         "__rr__original_singleton_method_added"
       end

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -48,7 +48,7 @@ module RR
       end
 
       def call_original_method_missing
-        subject.__send__(original_method_missing_alias_name, method_name, *args, &block)
+        subject.__send__(MethodMissingDispatch.original_method_missing_alias_name, method_name, *args, &block)
       end
 
       def implementation_is_original_method?

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -1,9 +1,9 @@
 module RR
   module MethodDispatches
     class MethodDispatch < BaseMethodDispatch
-      attr_reader :double_injection
-      def initialize(double_injection, args, block)
-        @double_injection, @args, @block = double_injection, args, block
+      attr_reader :double_injection, :subject
+      def initialize(double_injection, subject, args, block)
+        @double_injection, @subject, @args, @block = double_injection, subject, args, block
         @double = find_double_to_attempt
       end
 
@@ -53,7 +53,7 @@ module RR
       end
 
       def_delegators :definition, :implementation
-      def_delegators :double_injection, :subject_has_original_method?, :subject_has_original_method_missing?, :subject, :method_name, :original_method_alias_name
+      def_delegators :double_injection, :subject_has_original_method?, :subject_has_original_method_missing?, :method_name, :original_method_alias_name
     end
   end
 end

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -1,24 +1,21 @@
 module RR
   module MethodDispatches
     class MethodMissingDispatch < BaseMethodDispatch
-      class << self
+      extend(Module.new do
         def original_method_missing_alias_name
           "__rr__original_method_missing"
         end
-      end
+      end)
 
-      attr_reader :subject, :method_name
-      def initialize(subject, method_name, args, block)
-        @subject, @method_name, @args, @block = subject, method_name, args, block
+      attr_reader :subject, :subject_class, :method_name
+      def initialize(subject, subject_class, method_name, args, block)
+        @subject, @subject_class, @method_name, @args, @block = subject, subject_class, method_name, args, block
       end
 
       def call
-        if Injections::DoubleInjection.exists?(subject, method_name)
-          space.record_call(subject, method_name, args, block)
+        if Injections::DoubleInjection.exists?(subject_class, method_name)
           @double = find_double_to_attempt
-
           if double
-            double.method_call(args)
             call_yields
             return_value = extract_subject_from_return_value(call_implementation)
             if after_call_proc
@@ -35,7 +32,7 @@ module RR
       end
 
       def call_original_method
-        double_injection.bypass_bound_method do
+        Injections::DoubleInjection.find_or_create(subject_class, method_name).dispatch_method_delegates_to_dispatch_original_method do
           call_original_method_missing
         end
       end
@@ -43,17 +40,23 @@ module RR
       protected
       def call_implementation
         if implementation_is_original_method?
+          space.record_call(subject, method_name, args, block)
+          double.method_call(args)
           call_original_method
         else
-          nil
+          if double_injection = Injections::DoubleInjection.find(subject_class, method_name)
+            double_injection.bind_method
+            # The DoubleInjection takes care of calling double.method_call
+            subject.__send__(method_name, *args, &block)
+          else
+            nil
+          end
         end
       end
 
       def double_injection
-        Injections::DoubleInjection.create(subject, method_name)
+        Injections::DoubleInjection.find_or_create(subject_class, method_name)
       end
-
-      def_delegators 'self.class', :original_method_missing_alias_name
     end
   end
 end

data/lib/rr/recorded_calls.rb

@@ -40,7 +40,7 @@ module RR
     attr_accessor :ordered_index
 
     def double_injection_exists_error(spy_verification)
-      unless Injections::DoubleInjection.exists?(spy_verification.subject, spy_verification.method_name)
+      unless Injections::DoubleInjection.exists_by_subject?(spy_verification.subject, spy_verification.method_name)
         RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError.new(
           "A Double Injection for the subject and method call:\n" <<
           "#{spy_verification.subject.inspect}\n" <<

data/lib/rr/space.rb

@@ -67,12 +67,12 @@ module RR
 
     # Verifies the DoubleInjection for the passed in subject and method_name.
     def verify_double(subject, method_name)
-      Injections::DoubleInjection.verify_double(subject, method_name)
+      Injections::DoubleInjection.verify_double(class << subject; self; end, method_name)
     end
 
     # Resets the DoubleInjection for the passed in subject and method_name.
     def reset_double(subject, method_name)
-      Injections::DoubleInjection.reset_double(subject, method_name)
+      Injections::DoubleInjection.reset_double(class << subject; self; end, method_name)
     end
 
     def record_call(subject, method_name, arguments, block)
@@ -81,7 +81,7 @@ module RR
 
     def blank_slate_whitelist
       @blank_slate_whitelist ||= [
-        "object_id", "respond_to?", "method_missing", "instance_eval", "instance_exec", "class_eval"
+        "object_id", "respond_to?", "respond_to_missing?", "method_missing", "instance_eval", "instance_exec", "class_eval"
       ]
     end
 
@@ -92,7 +92,7 @@ module RR
     end
 
     def reset_method_missing_injections
-      Injections::MethodMissingInjection.instances.each do |subject, injection|
+      Injections::MethodMissingInjection.instances.each do |subject_class, injection|
         injection.reset
       end
       Injections::MethodMissingInjection.instances.clear
@@ -104,9 +104,9 @@ module RR
       end
       Injections::SingletonMethodAddedInjection.instances.clear
     end
-    
+
     def reset_recorded_calls
       @recorded_calls.clear
     end
   end
-end
+end

data/lib/rr/times_called_matchers/times_called_matcher.rb

@@ -1,7 +1,7 @@
 module RR
   module TimesCalledMatchers
     class TimesCalledMatcher #:nodoc:
-      class << self
+      extend(Module.new do
         def create(value)
           return value if value.is_a?(TimesCalledMatcher)
           return IntegerMatcher.new(value) if value.is_a?(Integer)
@@ -9,7 +9,7 @@ module RR
           return ProcMatcher.new(value) if value.is_a?(Proc)
           raise ArgumentError, "There is no TimesCalledMatcher for #{value.inspect}."
         end
-      end
+      end)
 
       attr_reader :times
 

data/scratch.rb

@@ -0,0 +1,118 @@
+o = Object.new
+#p (class << o; self; end).singleton_methods
+#p (class << o; self; end).superclass
+
+klass = Class.new
+p klass
+p klass.superclass
+p (class << klass; self; end).superclass
+p (class << Class; self; end)
+
+p Class.new
+
+##any_instance_of(Person, :id => 111, :to_s => "Joe Smith")
+##
+##any_instance_of(Person) do |person|
+##  person.id {111}
+##  person.to_s {"Joe Smith"}
+##end
+##
+##new_instance_of(Person, :id => 111, :to_s => "Joe Smith")
+##new_instance_of(Person) do |person|
+##  person.id {111}
+##  person.to_s {"Joe Smith"}
+##end
+#
+#class Sut
+#  def existing_method
+#    "existing_method"
+#  end
+#end
+#
+#class Dispatcher
+#  def self.call(subject, method_name, *args, &block)
+#    new(subject, method_name, *args, &block).call
+#  end
+#
+#  attr_reader :method_name
+#  def initialize(subject, method_name, *args, &block)
+#    @subject, @method_name, @args, @block = subject, method_name, args, block
+#  end
+#
+#  def call
+#
+#  end
+#end
+#
+#Sut.class_eval do
+#  alias_method :existing_method_without_rr, :existing_method
+#
+#  def existing_method(*args, &block)
+#    Dispatcher.call(self, :existing_method, *args, &block)
+#  end
+#end
+
+#class SubjectClass
+#  def foo
+#    :foo_original
+#  end
+#
+#  def _dump(arg)
+#    ""
+#  end
+#end
+#subject = SubjectClass.new
+#
+#class << subject
+#  p self.class
+#  class << self
+#    def foobar
+#      :baz
+#    end
+#  end
+#  p foobar
+#end
+#
+#Foo = Module.new do
+#  def foo
+#    :foo_module
+#  end
+#end
+#Bar = Module.new do
+#  def foo
+#    :bar_module
+#  end
+#end
+##module Foo
+##  def foo
+##  end
+##end
+#
+#subject.extend Foo
+#end
+#p subject.foo
+#p Marshal.dump(subject)
+
+
+class Super
+
+end
+class Sub < Super
+
+end
+
+def Super.foo
+  :bar
+end
+
+def Sub.foo
+  super
+end
+
+s = Super.new
+p s.object_id
+p (class << s; self; end).object_id
+p s.class
+#subject.extend Bar
+#def subject.foo
+#  :singleton_foo