redinger-rr 0.10.3 → 0.10.4

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 10
-:patch: 3
+:patch: 4
 :major: 0

data/lib/rr/double_injection.rb

@@ -31,17 +31,35 @@ module RR
         else
           me = self
 
-          subject_class.__send__(:alias_method, original_method_missing_alias_name, :method_missing)
-          bind_method_missing
+          unless subject.respond_to?(original_method_missing_alias_name)
+            unless subject.respond_to?(:method_missing)
+              subject_class.class_eval do
+                def method_missing(method_name, *args, &block)
+                  super
+                end
+              end
+            end
+            subject_class.__send__(:alias_method, original_method_missing_alias_name, :method_missing)
+            bind_method_missing
+          end
+
+          unless subject.respond_to?(original_singleton_method_added_alias_name)
+            unless subject.respond_to?(:singleton_method_added)
+              subject_class.class_eval do
+                def singleton_method_added(method_name)
+                  super
+                end
+              end
+            end
 
-          subject_class.__send__(:alias_method, original_singleton_method_added_alias_name, :singleton_method_added)
-          subject_class.__send__(:define_method, :singleton_method_added) do |method_name_arg|
-            if method_name_arg.to_sym == me.method_name.to_sym
-              me.send(:deferred_bind_method)
+            subject_class.__send__(:alias_method, original_singleton_method_added_alias_name, :singleton_method_added)
+            subject_class.__send__(:define_method, :singleton_method_added) do |method_name_arg|
+              if me.space.double_injection_exists?(me.subject, method_name_arg)
+                me.space.double_injection(me.subject, method_name_arg).send(:deferred_bind_method)
+              end
+              send(me.send(:original_singleton_method_added_alias_name), method_name_arg)
             end
-            send(me.send(:original_singleton_method_added_alias_name), method_name_arg)
           end
-          @deferred_bind = true
         end
       else
         bind_method
@@ -56,8 +74,8 @@ module RR
         double.verify
       end
     end
-
     # RR::DoubleInjection#reset removes the injected dispatcher method.
+
     # It binds the original method implementation on the subject
     # if one exists.
     def reset
@@ -88,7 +106,7 @@ module RR
     end
 
     def reset_singleton_method_added
-      if @deferred_bind
+      if subject.respond_to?(original_singleton_method_added_alias_name)
         me = self
         subject_class.class_eval do
           alias_method :singleton_method_added, me.send(:original_singleton_method_added_alias_name)
@@ -107,7 +125,7 @@ module RR
     end
 
     def dispatch_method_missing(method_name, args, block)
-      MethodDispatches::MethodMissingDispatch.new(self, method_name, args, block).call
+      MethodDispatches::MethodMissingDispatch.new(subject, method_name, args, block).call
     end
 
     def subject_has_original_method?
@@ -123,7 +141,7 @@ module RR
     end
 
     def original_method_missing_alias_name
-      "__rr__original_method_missing"
+      MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name
     end
 
     def subject_has_method_defined?(method_name)

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -3,7 +3,7 @@ module RR
     class BaseMethodDispatch
       include Space::Reader
 
-      attr_reader :double_injection, :args, :block, :double
+      attr_reader :args, :block, :double
 
       def call
         raise NotImplementedError
@@ -50,7 +50,7 @@ module RR
         if implementation_is_original_method?
           call_original_method
         else
-          if implementation
+          if defined?(implementation) && implementation
             if implementation.is_a?(Method)
               implementation.call(*args, &block)
             else

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -1,6 +1,7 @@
 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
         @double = find_double_to_attempt

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -1,14 +1,19 @@
 module RR
   module MethodDispatches
     class MethodMissingDispatch < BaseMethodDispatch
-      attr_reader :method_name
-      def initialize(double_injection, method_name, args, block)
-        @double_injection, @args, @block = double_injection, args, block
-        @method_name = method_name
+      class << self
+        def original_method_missing_alias_name
+          "__rr__original_method_missing"
+        end
+      end
+
+      attr_reader :subject, :method_name
+      def initialize(subject, method_name, args, block)
+        @subject, @method_name, @args, @block = subject, method_name, args, block
       end
 
       def call
-        if double_injection.method_name == method_name
+        if space.double_injection_exists?(subject, method_name)
           space.record_call(subject, method_name, args, block)
           @double = find_double_to_attempt
 
@@ -36,13 +41,12 @@ module RR
       end
 
       protected
-
-      def original_method_missing_alias_name
-        double_injection.original_method_missing_alias_name
+      def double_injection
+        space.double_injection(subject, method_name)
       end
 
-      def subject
-        double_injection.subject
+      def original_method_missing_alias_name
+        self.class.original_method_missing_alias_name
       end
     end
   end

data/spec/rr/double_injection/double_injection_spec.rb

@@ -93,6 +93,18 @@ module RR
           end
         end
       end
+
+      context "when the subject redefines respond_to?" do
+        it "does not try to call the implementation" do
+          class << subject
+            def respond_to?(method_symbol, include_private = false)
+              method_symbol == :foobar
+            end
+          end
+          mock(@subject).foobar
+          @subject.foobar.should == nil
+        end
+      end
     end
 
     describe "mock/stub + proxy" do
@@ -146,90 +158,44 @@ module RR
 
         context "when the subject does not have the method defined" do
           describe "being bound" do
-            before do
-              @subject = Object.new
-              setup_subject
-
-              subject.should respond_to(:foobar)
-              stub.proxy(subject).foobar {:new_foobar}
-            end
+            context "when the subject has not been previously bound to" do
+              before do
+                @subject = Object.new
+                setup_subject
 
-            def setup_subject
-              def subject.respond_to?(method_name)
-                if method_name.to_sym == :foobar
-                  true
-                else
-                  super
-                end
+                subject.should respond_to(:foobar)
+                stub.proxy(subject).foobar {:new_foobar}
               end
-            end
 
-            it "does not define __rr__original_{method_name}" do
-              subject.methods.should_not include("__rr__original_foobar")
-            end
-
-            context "when method is defined after being bound and before being called" do
               def setup_subject
-                super
-                def subject.foobar
-                  :original_foobar
+                def subject.respond_to?(method_name)
+                  if method_name.to_sym == :foobar
+                    true
+                  else
+                    super
+                  end
                 end
               end
 
-              describe "being called" do
-                it "defines __rr__original_{method_name} to be the lazily created method" do
-                  subject.methods.should include("__rr__original_foobar")
-                  subject.__rr__original_foobar.should == :original_foobar
-                end
-
-                it "calls the original method first and sends it into the block" do
-                  original_return_value = nil
-                  stub.proxy(subject).foobar {|original_return_value| :new_foobar}
-                  subject.foobar.should == :new_foobar
-                  original_return_value.should == :original_foobar
-                end
+              it "does not define __rr__original_{method_name}" do
+                subject.methods.should_not include("__rr__original_foobar")
               end
 
-              describe "being reset" do
-                before do
-                  RR::Space.reset_double(subject, :foobar)
-                end
-
-                it "rebinds the original method" do
-                  subject.foobar.should == :original_foobar
-                end
-
-                it "removes __rr__original_{method_name}" do
-                  subject.should_not respond_to(:__rr__original_foobar)
-                end
-              end
-            end
-
-            context "when method is still not defined" do
-              context "when the method is lazily created" do
+              context "when method is defined after being bound and before being called" do
                 def setup_subject
                   super
-                  def subject.method_missing(method_name, *args, &block)
-                    if method_name.to_sym == :foobar
-                      def self.foobar
-                        :original_foobar
-                      end
-
-                      foobar
-                    else
-                      super
-                    end
+                  def subject.foobar
+                    :original_foobar
                   end
                 end
 
                 describe "being called" do
                   it "defines __rr__original_{method_name} to be the lazily created method" do
-                    subject.foobar
                     subject.methods.should include("__rr__original_foobar")
                     subject.__rr__original_foobar.should == :original_foobar
                   end
 
-                  it "calls the lazily created method and returns the injected method return value" do
+                  it "calls the original method first and sends it into the block" do
                     original_return_value = nil
                     stub.proxy(subject).foobar {|original_return_value| :new_foobar}
                     subject.foobar.should == :new_foobar
@@ -238,7 +204,96 @@ module RR
                 end
 
                 describe "being reset" do
-                  context "when reset before being called" do
+                  before do
+                    RR::Space.reset_double(subject, :foobar)
+                  end
+
+                  it "rebinds the original method" do
+                    subject.foobar.should == :original_foobar
+                  end
+
+                  it "removes __rr__original_{method_name}" do
+                    subject.should_not respond_to(:__rr__original_foobar)
+                  end
+                end
+              end
+
+              context "when method is still not defined" do
+                context "when the method is lazily created" do
+                  def setup_subject
+                    super
+                    def subject.method_missing(method_name, *args, &block)
+                      if method_name.to_sym == :foobar
+                        def self.foobar
+                          :original_foobar
+                        end
+
+                        foobar
+                      else
+                        super
+                      end
+                    end
+                  end
+
+                  describe "being called" do
+                    it "defines __rr__original_{method_name} to be the lazily created method" do
+                      subject.foobar
+                      subject.methods.should include("__rr__original_foobar")
+                      subject.__rr__original_foobar.should == :original_foobar
+                    end
+
+                    it "calls the lazily created method and returns the injected method return value" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    context "when reset before being called" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        subject.foobar.should == :original_foobar
+                      end
+
+                      it "removes __rr__original_{method_name}" do
+                        subject.should_not respond_to(:__rr__original_foobar)
+                      end
+                    end
+                  end
+                end
+
+                context "when the method is not lazily created (handled in method_missing)" do
+                  def setup_subject
+                    super
+                    def subject.method_missing(method_name, *args, &block)
+                      if method_name.to_sym == :foobar
+                        :original_foobar
+                      else
+                        super
+                      end
+                    end
+                  end
+
+                  describe "being called" do
+                    it "does not define the __rr__original_{method_name}" do
+                      subject.foobar
+                      subject.methods.should_not include("__rr__original_foobar")
+                    end
+
+                    it "calls the lazily created method and returns the injected method return value" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
                     before do
                       RR::Space.reset_double(subject, :foobar)
                     end
@@ -253,26 +308,47 @@ module RR
                   end
                 end
               end
+            end
+
+            context "when the subject has been previously bound to" do
+              before do
+                @subject = Object.new
+                setup_subject
+
+                subject.should respond_to(:foobar)
+                stub.proxy(subject).baz {:new_baz}
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              def setup_subject
+                def subject.respond_to?(method_name)
+                  if method_name.to_sym == :foobar || method_name.to_sym == :baz
+                    true
+                  else
+                    super
+                  end
+                end
+              end
 
-              context "when the method is not lazily created (handled in method_missing)" do
+              it "does not define __rr__original_{method_name}" do
+                subject.methods.should_not include("__rr__original_foobar")
+              end
+
+              context "when method is defined after being bound and before being called" do
                 def setup_subject
                   super
-                  def subject.method_missing(method_name, *args, &block)
-                    if method_name.to_sym == :foobar
-                      :original_foobar
-                    else
-                      super
-                    end
+                  def subject.foobar
+                    :original_foobar
                   end
                 end
 
                 describe "being called" do
-                  it "does not define the __rr__original_{method_name}" do
-                    subject.foobar
-                    subject.methods.should_not include("__rr__original_foobar")
+                  it "defines __rr__original_{method_name} to be the lazily created method" do
+                    subject.methods.should include("__rr__original_foobar")
+                    subject.__rr__original_foobar.should == :original_foobar
                   end
 
-                  it "calls the lazily created method and returns the injected method return value" do
+                  it "calls the original method first and sends it into the block" do
                     original_return_value = nil
                     stub.proxy(subject).foobar {|original_return_value| :new_foobar}
                     subject.foobar.should == :new_foobar
@@ -294,46 +370,183 @@ module RR
                   end
                 end
               end
+
+              context "when method is still not defined" do
+                context "when the method is lazily created" do
+                  def setup_subject
+                    super
+                    def subject.method_missing(method_name, *args, &block)
+                      if method_name.to_sym == :foobar
+                        def self.foobar
+                          :original_foobar
+                        end
+
+                        foobar
+                      else
+                        super
+                      end
+                    end
+                  end
+
+                  describe "being called" do
+                    it "defines __rr__original_{method_name} to be the lazily created method" do
+                      subject.foobar
+                      subject.methods.should include("__rr__original_foobar")
+                      subject.__rr__original_foobar.should == :original_foobar
+                    end
+
+                    it "calls the lazily created method and returns the injected method return value" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    context "when reset before being called" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        subject.foobar.should == :original_foobar
+                      end
+
+                      it "removes __rr__original_{method_name}" do
+                        subject.should_not respond_to(:__rr__original_foobar)
+                      end
+                    end
+                  end
+                end
+
+                context "when the method is not lazily created (handled in method_missing)" do
+                  def setup_subject
+                    super
+                    def subject.method_missing(method_name, *args, &block)
+                      if method_name.to_sym == :foobar
+                        :original_foobar
+                      else
+                        super
+                      end
+                    end
+                  end
+
+                  describe "being called" do
+                    it "does not define the __rr__original_{method_name}" do
+                      subject.foobar
+                      subject.methods.should_not include("__rr__original_foobar")
+                    end
+
+                    it "calls the lazily created method and returns the injected method return value" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      subject.foobar.should == :original_foobar
+                    end
+
+                    it "removes __rr__original_{method_name}" do
+                      subject.should_not respond_to(:__rr__original_foobar)
+                    end
+                  end
+                end
+              end
             end
           end
         end
       end
 
       context "when the subject does not respond to the injected method" do
-        describe "being bound" do
-          before do
-            @subject = Object.new
-            subject.should_not respond_to(:foobar)
-            subject.methods.should_not include('foobar')
-            stub.proxy(subject).foobar {:new_foobar}
-          end
+        context "when the subject responds to the method via method_missing" do
+          describe "being bound" do
+            before do
+              @subject = Object.new
+              subject.should_not respond_to(:foobar)
+              subject.methods.should_not include('foobar')
+              class << subject
+                def method_missing(method_name, *args, &block)
+                  if method_name == :foobar
+                    :original_foobar
+                  else
+                    super
+                  end
+                end
+              end
+              stub.proxy(subject).foobar {:new_foobar}
+            end
 
-          it "adds the method to the subject" do
-            subject.should respond_to(:foobar)
-            subject.methods.should include('foobar')
-          end
+            it "adds the method to the subject" do
+              subject.should respond_to(:foobar)
+              subject.methods.should include('foobar')
+            end
 
-          describe "being called" do
-            it "raises a NoMethodError" do
-              lambda do
-                subject.foobar
-              end.should raise_error(NoMethodError)
+            describe "being called" do
+              it "calls the original method first and sends it into the block" do
+                original_return_value = nil
+                stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                subject.foobar.should == :new_foobar
+                original_return_value.should == :original_foobar
+              end
             end
-          end
 
-          describe "being reset" do
-            before do
-              RR::Space.reset_double(subject, :foobar)
+            describe "being reset" do
+              before do
+                RR::Space.reset_double(subject, :foobar)
+              end
+
+              it "unsets the foobar method" do
+                subject.should_not respond_to(:foobar)
+                subject.methods.should_not include('foobar')
+              end
             end
+          end
+        end
 
-            it "unsets the foobar method" do
+        context "when the subject would raise a NoMethodError when the method is called" do
+          describe "being bound" do
+            before do
+              @subject = Object.new
               subject.should_not respond_to(:foobar)
               subject.methods.should_not include('foobar')
+              stub.proxy(subject).foobar {:new_foobar}
+            end
+
+            it "adds the method to the subject" do
+              subject.should respond_to(:foobar)
+              subject.methods.should include('foobar')
+            end
+
+            describe "being called" do
+              it "raises a NoMethodError" do
+                lambda do
+                  subject.foobar
+                end.should raise_error(NoMethodError)
+              end
+            end
+
+            describe "being reset" do
+              before do
+                RR::Space.reset_double(subject, :foobar)
+              end
+
+              it "unsets the foobar method" do
+                subject.should_not respond_to(:foobar)
+                subject.methods.should_not include('foobar')
+              end
             end
           end
         end
       end
-
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: redinger-rr
 version: !ruby/object:Gem::Version 
-  version: 0.10.3
+  version: 0.10.4
 platform: ruby
 authors: 
 - Brian Takita
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-30 00:00:00 -04:00
+date: 2009-09-19 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -64,10 +64,10 @@ files:
 - lib/rr/expectations/any_argument_expectation.rb
 - lib/rr/expectations/argument_equality_expectation.rb
 - lib/rr/expectations/times_called_expectation.rb
+- lib/rr/hash_with_object_id_key.rb
 - lib/rr/method_dispatches/base_method_dispatch.rb
 - lib/rr/method_dispatches/method_dispatch.rb
 - lib/rr/method_dispatches/method_missing_dispatch.rb
-- lib/rr/hash_with_object_id_key.rb
 - lib/rr/proc_from_block.rb
 - lib/rr/recorded_calls.rb
 - lib/rr/space.rb
@@ -155,10 +155,9 @@ files:
 - spec/spec_suite.rb
 - spec/spy_verification_spec.rb
 - spec/test_unit_spec_suite.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://pivotallabs.com
-licenses: []
-
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --main
@@ -187,7 +186,7 @@ signing_key:
 specification_version: 3
 summary: RR (Double Ruby) is a double framework that features a rich selection of double techniques and a terse syntax. http://xunitpatterns.com/Test%20Double.html
 test_files: 
-- spec/spy_verification_spec.rb
 - spec/high_level_spec.rb
-- spec/rr_spec.rb
 - spec/proc_from_block_spec.rb
+- spec/rr_spec.rb
+- spec/spy_verification_spec.rb