rr 0.9.0 → 0.10.0

data/CHANGES

@@ -1,3 +1,7 @@
+* 0.10.0
+- Method is no longer invoked if respond_to? returns false. This was in place to support ActiveRecord association proxies, and is no longer needed. 
+
+* 0.9.0
 - instance_of Doubles now apply to methods invoked in the subject's #initialize method.
 
 * 0.8.1

data/README.rdoc

@@ -32,7 +32,7 @@ Currently RR implements mocks, stubs, proxies, and spies. Fakes usually require
   end
 
 === rspec
-  Spec::Runners.configure do |config|
+  Spec::Runner.configure do |config|
     config.mock_with :rr
     # or if that doesn't work due to a version incompatibility
     # config.mock_with RR::Adapters::Rspec
@@ -316,7 +316,7 @@ to making it possible. We all are standing on the shoulders of giants.
 * Aslak Hellesoy for Developing Rspec
 * Dan North for syntax ideas
 * Dave Astels for some BDD inspiration
-* David Chelimsky for encouragement to make the RR framework, for developing the Rspec mock framework, and syntax ideas
+* David Chelimsky for encouragement to make the RR framework, for developing the Rspec mock framework, syntax ideas, and patches
 * Daniel Sudol for identifing performance issues with RR
 * Felix Morio for pairing with me
 * Gerard Meszaros for his excellent book "xUnit Test Patterns"
@@ -324,7 +324,7 @@ to making it possible. We all are standing on the shoulders of giants.
 * Jeff Whitmire for documentation suggestions
 * Jim Weirich for developing Flexmock, the first Terse ruby mock framework in Ruby
 * Joe Ferris for patches
-* Matthew O'Conner for patches
+* Matthew O'Connor for patches and pairing with me
 * Michael Niessner for patches and pairing with me
 * Mike Mangino (from Elevated Rails) for patches and pairing with me
 * Nick Kallen for documentation suggestions, bug reports, and patches

data/VERSION.yml

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

data/lib/rr/adapters/rr_methods.rb

@@ -50,7 +50,7 @@ module RR
       # that succeeds when passed an argument of a certain type.
       #   mock(object).method_name(is_a(String)) {return_value}
       #   object.method_name("A String") # passes
-      def is_a(klass)
+          def is_a(klass)
         RR::WildcardMatchers::IsA.new(klass)
       end
 

data/lib/rr/double.rb

@@ -135,12 +135,12 @@ module RR
     end
 
     def verify_method_signature
-      raise RR::Errors::SubjectDoesNotImplementMethodError unless definition.subject.respond_to?(double_injection.send(:original_method_name))
+      raise RR::Errors::SubjectDoesNotImplementMethodError unless definition.subject.respond_to?(double_injection.send(:original_method_alias_name))
       raise RR::Errors::SubjectHasDifferentArityError unless arity_matches?
     end
     
     def subject_arity
-      definition.subject.method(double_injection.send(:original_method_name)).arity
+      definition.subject.method(double_injection.send(:original_method_alias_name)).arity
     end
     
     def subject_accepts_only_varargs?

data/lib/rr/double_injection.rb

@@ -5,21 +5,14 @@ module RR
   class DoubleInjection
     include Space::Reader
     MethodArguments = Struct.new(:arguments, :block)
-    attr_reader :subject, :method_name, :doubles
-
-    def initialize(subject, method_name)
+    attr_reader :subject, :method_name, :doubles, :subject_class
+    
+    def initialize(subject, method_name, subject_class)
       @subject = subject
+      @subject_class = subject_class
       @method_name = method_name.to_sym
       if object_has_method?(method_name)
-        begin
-          meta.__send__(:alias_method, original_method_name, method_name)
-        rescue NameError => e
-          begin
-            subject.send(method_name)
-            meta.__send__(:alias_method, original_method_name, method_name)
-          rescue NameError => e
-          end
-        end
+        subject_class.__send__(:alias_method, original_method_alias_name, method_name)
       end
       @doubles = []
     end
@@ -34,14 +27,13 @@ module RR
     # that dispatches to the matching Double when the method
     # is called.
     def bind
-      define_implementation_placeholder
       returns_method = <<-METHOD
         def #{@method_name}(*args, &block)
           arguments = MethodArguments.new(args, block)
-          __send__('#{placeholder_name}', arguments)
+          RR::Space.double_injection(self, :#{@method_name}).call_method(arguments.arguments, arguments.block)
         end
       METHOD
-      meta.class_eval(returns_method, __FILE__, __LINE__ - 5)
+      subject_class.class_eval(returns_method, __FILE__, __LINE__ - 5)
       self
     end
 
@@ -57,29 +49,20 @@ module RR
     # It binds the original method implementation on the subject
     # if one exists.
     def reset
-      meta.__send__(:remove_method, placeholder_name)
       if object_has_original_method?
-        meta.__send__(:alias_method, @method_name, original_method_name)
-        meta.__send__(:remove_method, original_method_name)
+        subject_class.__send__(:alias_method, @method_name, original_method_alias_name)
+        subject_class.__send__(:remove_method, original_method_alias_name)
       else
-        meta.__send__(:remove_method, @method_name)
+        subject_class.__send__(:remove_method, @method_name)
       end
     end
 
     def call_original_method(*args, &block)
-      @subject.__send__(original_method_name, *args, &block)
+      @subject.__send__(original_method_alias_name, *args, &block)
     end
 
     def object_has_original_method?
-      object_has_method?(original_method_name)
-    end
-
-    protected
-    def define_implementation_placeholder
-      me = self
-      meta.__send__(:define_method, placeholder_name) do |arguments|
-        me.__send__(:call_method, arguments.arguments, arguments.block)
-      end
+      object_has_method?(original_method_alias_name)
     end
 
     def call_method(args, block)
@@ -90,7 +73,8 @@ module RR
         double_not_found_error(*args)
       end
     end
-
+    
+    protected
     def find_double_to_attempt(args)
       matches = DoubleMatches.new(@doubles).find_all_matches(args)
 
@@ -127,20 +111,12 @@ module RR
       raise Errors::DoubleNotFoundError, message
     end
 
-    def placeholder_name
-      "__rr__#{@method_name}"
-    end
-
-    def original_method_name
+    def original_method_alias_name
       "__rr__original_#{@method_name}"
     end
 
     def object_has_method?(method_name)
       @subject.methods.include?(method_name.to_s) || @subject.respond_to?(method_name)
     end
-
-    def meta
-      (class << @subject; self; end)
-    end
   end
 end

data/lib/rr/space.rb

@@ -34,7 +34,7 @@ module RR
     # subject.
     def double_injection(subject, method_name)
       @double_injections[subject][method_name.to_sym] ||= begin
-        DoubleInjection.new(subject, method_name.to_sym).bind
+        DoubleInjection.new(subject, method_name.to_sym, (class << subject; self; end)).bind
       end
     end
 

data/spec/rr/double_injection/double_injection_bind_spec.rb

@@ -3,40 +3,31 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 module RR
   module DoubleDefinitions
     describe DoubleInjection do
+      attr_reader :subject, :method_name, :double_injection, :original_method
       describe "#bind" do
         context "with an existing method" do
           before do
             @subject = Object.new
             @method_name = :foobar
-            def @subject.foobar;
+            def subject.foobar;
               :original_foobar;
             end
-            @original_method = @subject.method(@method_name)
-            @subject.methods.should include(@method_name.to_s)
-            @double_injection = DoubleInjection.new(@subject, @method_name)
-          end
+            @original_method = @subject.method(method_name)
+            @subject.methods.should include(method_name.to_s)
 
-          it "overrides the original method with the double_injection's dispatching methods" do
-            @subject.respond_to?(:__rr__foobar).should == false
-            @double_injection.bind
-            @subject.respond_to?(:__rr__foobar).should == true
+            subject.method(:foobar).should == original_method
 
-            rr_foobar_called = false
-            (class << @subject; self; end).class_eval do
-              define_method :__rr__foobar do
-                rr_foobar_called = true
-              end
-            end
+            @double_injection = RR::Space.double_injection(subject, method_name)
+          end
 
-            rr_foobar_called.should == false
-            @subject.foobar
-            rr_foobar_called.should == true
+          it "overrides the original method with the double_injection's dispatching methods" do
+            double_injection.bind
+            subject.method(:foobar).should_not == original_method
           end
 
-          it "stores original method in __rr__original_method_name" do
-            @double_injection.bind
-            @subject.respond_to?(:__rr__original_foobar).should == true
-            @subject.method(:__rr__original_foobar).should == @original_method
+          it "stores original method in __rr__original_method_alias_name" do
+            subject.respond_to?(:__rr__original_foobar).should == true
+            subject.method(:__rr__original_foobar).should == original_method
           end
         end
 
@@ -44,30 +35,16 @@ module RR
           before do
             @subject = Object.new
             @method_name = :foobar
-            @subject.methods.should_not include(@method_name.to_s)
-            @double_injection = DoubleInjection.new(@subject, @method_name)
+            subject.methods.should_not include(method_name.to_s)
+            RR::Space.double_injection(subject, method_name)
           end
 
           it "creates a new method with the double_injection's dispatching methods" do
-            @subject.respond_to?(:__rr__foobar).should == false
-            @double_injection.bind
-            @subject.respond_to?(:__rr__foobar).should == true
-
-            rr_foobar_called = false
-            (class << @subject; self; end).class_eval do
-              define_method :__rr__foobar do
-                rr_foobar_called = true
-              end
-            end
-
-            rr_foobar_called.should == false
-            @subject.foobar
-            rr_foobar_called.should == true
+            subject.method(method_name).should_not be_nil
           end
 
-          it "does not create method __rr__original_method_name" do
-            @double_injection.bind
-            @subject.respond_to?(:__rr__original_foobar).should == false
+          it "does not create method __rr__original_method_alias_name" do
+            subject.respond_to?(:__rr__original_foobar).should == false
           end
         end
 
@@ -75,34 +52,19 @@ module RR
           before do
             @subject = Object.new
             @method_name = :'=='
-            @subject.should respond_to(@method_name)
-            @original_method = @subject.method(@method_name)
-            @subject.methods.should include(@method_name.to_s)
-            @double_injection = DoubleInjection.new(@subject, @method_name)
+            subject.should respond_to(method_name)
+            @original_method = subject.method(method_name)
+            subject.methods.should include(method_name.to_s)
+            @double_injection = RR::Space.double_injection(subject, method_name)
           end
 
           it "overrides the original method with the double_injection's dispatching methods" do
-            @subject.respond_to?(:"__rr__#{@method_name}").should == false
-            @double_injection.bind
-            @subject.respond_to?(:"__rr__#{@method_name}").should == true
-
-            override_called = false
-            method_name = @method_name
-            (class << @subject; self; end).class_eval do
-              define_method :"__rr__#{method_name}" do
-                override_called = true
-              end
-            end
-
-            override_called.should == false
-            @subject == 1
-            override_called.should == true
+            subject.method(method_name).should_not == original_method
           end
 
-          it "stores original method in __rr__original_method_name" do
-            @double_injection.bind
-            @subject.respond_to?(:"__rr__original_#{@method_name}").should == true
-            @subject.method(:"__rr__original_#{@method_name}").should == @original_method
+          it "stores original method in __rr__original_method_alias_name" do
+            subject.respond_to?(:"__rr__original_#{method_name}").should == true
+            subject.method(:"__rr__original_#{method_name}").should == original_method
           end
         end        
       end

data/spec/rr/double_injection/double_injection_has_original_method_spec.rb

@@ -1,55 +1,58 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
-  describe DoubleInjection, "#object_has_original_method?" do
-    before do
-      @subject = Object.new
-      @method_name = :to_s
-      @double_injection = DoubleInjection.new(@subject, @method_name)
-      class << @double_injection
-        public :original_method_name
+  describe DoubleInjection do
+    describe "#object_has_original_method?" do
+      attr_reader :subject, :method_name, :double_injection
+      before do
+        @subject = Object.new
+        @method_name = :to_s
+        @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
+        class << double_injection
+          public :original_method_alias_name
+        end
       end
-    end
-
-    it "returns true when method is still in object" do
-      @double_injection.bind
-      @double_injection.object_has_original_method?.should be_true
-    end
 
-    it "returns true when respond_to is true and methods include method" do
-      @double_injection.bind
-      def @subject.methods
-        [:__rr_original_to_s]
-      end
-      def @subject.respond_to?(value)
-        true
+      it "returns true when method is still in object" do
+        double_injection.bind
+        double_injection.object_has_original_method?.should be_true
       end
 
-      @double_injection.object_has_original_method?.should be_true
-    end
+      it "returns true when respond_to is true and methods include method" do
+        double_injection.bind
+        def subject.methods
+          [:__rr_original_to_s]
+        end
+        def subject.respond_to?(value)
+          true
+        end
 
-    it "returns true when respond_to is true and methods do not include method" do
-      @double_injection.bind
-      def @subject.methods
-        []
-      end
-      def @subject.respond_to?(value)
-        true
+        double_injection.object_has_original_method?.should be_true
       end
 
-      @double_injection.object_has_original_method?.should be_true
-    end
+      it "returns true when respond_to is true and methods do not include method" do
+        double_injection.bind
+        def subject.methods
+          []
+        end
+        def subject.respond_to?(value)
+          true
+        end
 
-    it "returns false when respond_to is false and methods do not include method" do
-      @double_injection.bind
-      def @subject.methods
-        []
-      end
-      def @subject.respond_to?(value)
-        false
+        double_injection.object_has_original_method?.should be_true
       end
 
-      @double_injection.object_has_original_method?.should be_false
+      it "returns false when respond_to is false and methods do not include method" do
+        double_injection.bind
+        def subject.methods
+          []
+        end
+        def subject.respond_to?(value)
+          false
+        end
+
+        double_injection.object_has_original_method?.should be_false
+      end
     end
   end
 end

data/spec/rr/double_injection/double_injection_reset_spec.rb

@@ -2,84 +2,66 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   describe DoubleInjection do
-    macro("cleans up by removing the __rr__method") do
-      it "cleans up by removing the __rr__method" do
-        @double_injection.bind
-        @subject.methods.should include("__rr__foobar")
-
-        @double_injection.reset
-        @subject.methods.should_not include("__rr__foobar")
-      end
-    end
-
     describe "#reset" do
+      attr_reader :subject, :method_name, :double_injection
       context "when method does not exist" do
-        send("cleans up by removing the __rr__method")
-
         before do
           @subject = Object.new
           @method_name = :foobar
-          @subject.methods.should_not include(@method_name.to_s)
-          @double_injection = DoubleInjection.new(@subject, @method_name)
+          subject.methods.should_not include(method_name.to_s)
+          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
         end
 
         it "removes the method" do
-          @double_injection.bind
-          @subject.methods.should include(@method_name.to_s)
+          double_injection.bind
+          subject.methods.should include(method_name.to_s)
 
-          @double_injection.reset
-          @subject.methods.should_not include(@method_name.to_s)
-          lambda {@subject.foobar}.should raise_error(NoMethodError)
+          double_injection.reset
+          subject.methods.should_not include(method_name.to_s)
+          lambda {subject.foobar}.should raise_error(NoMethodError)
         end
       end
 
       context "when method exists" do
-        send("cleans up by removing the __rr__method")
-
         before do
           @subject = Object.new
           @method_name = :foobar
-          def @subject.foobar
+          def subject.foobar
             :original_foobar
           end
-          @subject.methods.should include(@method_name.to_s)
-          @original_method = @subject.method(@method_name)
-          @double_injection = DoubleInjection.new(@subject, @method_name)
-
-          @double_injection.bind
-          @subject.methods.should include(@method_name.to_s)
+          subject.methods.should include(method_name.to_s)
+          @original_method = subject.method(method_name)
+          @double_injection = RR::Space.double_injection(subject, method_name)
+          subject.methods.should include(method_name.to_s)
         end
 
         it "rebind original method" do
-          @double_injection.reset
-          @subject.methods.should include(@method_name.to_s)
-          @subject.foobar.should == :original_foobar
+          double_injection.reset
+          subject.methods.should include(method_name.to_s)
+          subject.foobar.should == :original_foobar
         end
       end
 
       context "when method with block exists" do
-        send("cleans up by removing the __rr__method")
-
         before do
           @subject = Object.new
           @method_name = :foobar
-          def @subject.foobar
+          def subject.foobar
             yield(:original_argument)
           end
-          @subject.methods.should include(@method_name.to_s)
-          @original_method = @subject.method(@method_name)
-          @double_injection = DoubleInjection.new(@subject, @method_name)
+          subject.methods.should include(method_name.to_s)
+          @original_method = subject.method(method_name)
+          @double_injection = RR::Space.double_injection(subject, method_name)
 
-          @double_injection.bind
-          @subject.methods.should include(@method_name.to_s)
+          subject.methods.should include(method_name.to_s)
         end
 
         it "rebinds original method with block" do
-          @double_injection.reset
-          @subject.methods.should include(@method_name.to_s)
+          double_injection.reset
+          subject.methods.should include(method_name.to_s)
 
           original_argument = nil
-          @subject.foobar do |arg|
+          subject.foobar do |arg|
             original_argument = arg
           end
           original_argument.should == :original_argument

data/spec/rr/double_injection/double_injection_spec.rb

@@ -18,7 +18,7 @@ module RR
           @subject = Object.new
           @method_name = :foobar
           subject.methods.should_not include(method_name.to_s)
-          @double_injection = DoubleInjection.new(subject, method_name)
+          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
         end
       end
 
@@ -29,7 +29,7 @@ module RR
           @subject = Object.new
           @method_name = 'foobar'
           subject.methods.should_not include(method_name)
-          @double_injection = DoubleInjection.new(subject, method_name)
+          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
         end
       end
 
@@ -42,7 +42,7 @@ module RR
 
         context "and invoking the method for the first time does not add the method" do
           before do
-            @double_injection = DoubleInjection.new(subject, method_name)
+            @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
           end
           send("sets up object and method_name")
 
@@ -50,29 +50,6 @@ module RR
             double_injection.object_has_original_method?.should be_false
           end
         end
-
-
-        context "and invoking the method for the first time adds the method" do
-          before do
-            class << subject
-              def respond_to?(method_name)
-                true
-              end
-
-              def method_missing(method_name, *args, &block)
-                (class << self; self; end).class_eval do
-                  define_method(method_name) {}
-                end
-              end
-            end
-            @double_injection = DoubleInjection.new(subject, method_name)
-          end
-          send("sets up object and method_name")
-
-          example "object has original method" do
-            double_injection.object_has_original_method?.should be_true
-          end
-        end
       end
 
       context "when method exists on object" do
@@ -82,7 +59,7 @@ module RR
           @subject = Object.new
           @method_name = :to_s
           subject.methods.should include(method_name.to_s)
-          @double_injection = DoubleInjection.new(subject, method_name)
+          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
         end
 
         it "has a original_method" do
@@ -96,7 +73,7 @@ module RR
         before do
           @subject = Object.new
           @method_name = '=='
-          @double_injection = DoubleInjection.new(subject, method_name)
+          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
         end
       end
     end

data/spec/rr/space/space_spec.rb

@@ -74,8 +74,9 @@ module RR
         end
 
         it "overrides the method when passing a block" do
-          @double_injection = space.double_injection(subject, method_name)
-          subject.methods.should include("__rr__#{method_name}")
+          original_method = subject.method(:foobar)
+          double_injection = space.double_injection(subject, method_name)
+          subject.method(:foobar).should_not == original_method
         end
       end
 
@@ -166,16 +167,20 @@ module RR
     describe "#reset_double" do
       before do
         @method_name = :foobar
+        def subject.foobar
+        end
       end
 
-      it "resets the double_injections" do
+      it "resets the double_injections and restores the original method" do
+        original_method = subject.method(method_name)
+
         @double_injection = space.double_injection(subject, method_name)
         space.double_injections[subject][method_name].should === double_injection
-        subject.methods.should include("__rr__#{method_name}")
+        subject.method(method_name).should_not == original_method
 
         space.reset_double(subject, method_name)
         space.double_injections[subject][method_name].should be_nil
-        subject.methods.should_not include("__rr__#{method_name}")
+        subject.method(method_name).should == original_method
       end
 
       context "when it has no double_injections" do
@@ -421,12 +426,13 @@ module RR
     describe "#verify_double" do
       before do
         @method_name = :foobar
+        def subject.foobar
+        end
       end
 
       it "verifies and deletes the double_injection" do
         @double_injection = space.double_injection(subject, method_name)
         space.double_injections[subject][method_name].should === double_injection
-        subject.methods.should include("__rr__#{method_name}")
 
         verify_call_count = 0
         (class << double_injection; self; end).class_eval do
@@ -438,14 +444,16 @@ module RR
         verify_call_count.should == 1
 
         space.double_injections[subject][method_name].should be_nil
-        subject.methods.should_not include("__rr__#{method_name}")
       end
 
       context "when verifying the double_injection raises an error" do
-        it "deletes the double_injection" do
+        it "deletes the double_injection and restores the original method" do
+          original_method = subject.method(method_name)
+
           @double_injection = space.double_injection(subject, method_name)
+          subject.method(method_name).should_not == original_method
+
           space.double_injections[subject][method_name].should === double_injection
-          subject.methods.should include("__rr__#{method_name}")
 
           verify_called = true
           (class << double_injection; self; end).class_eval do
@@ -458,7 +466,7 @@ module RR
           verify_called.should be_true
 
           space.double_injections[subject][method_name].should be_nil
-          subject.methods.should_not include("__rr__#{method_name}")
+          subject.method(method_name).should == original_method
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Brian Takita
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-25 00:00:00 -07:00
+date: 2009-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: []