rr 0.10.2 → 0.10.4

data/CHANGES

@@ -1,3 +1,6 @@
+- Handle lazily defined methods (where respond_to? returns true yet the method is not yet defined and the first call to method_missing defines the method). This pattern is used in ActiveRecord and ActionMailer.
+- Fixed warning about aliasing #instance_exec in jruby. http://github.com/btakita/rr/issues#issue/9 (Patch by Nathan Sobo)
+
 0.10.2
 - RR properly proxies subjects with private methods [http://github.com/btakita/rr/issues/#issue/7]. Identified by Matthew O'Connor.
 

data/README.rdoc

@@ -322,6 +322,7 @@ With any development effort, there are countless people who have contributed
 to making it possible. We all are standing on the shoulders of giants.
 * Andreas Haller for patches
 * Aslak Hellesoy for Developing Rspec
+* Christopher Redinger for patches
 * 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, syntax ideas, and patches

data/Rakefile

@@ -47,7 +47,11 @@ begin
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
-RUBYFORGE_PACKAGE_NAME = "rr (Double R)"
+RUBYFORGE_PACKAGE_NAME = "rr (Double Ruby)"
+# The package was renamed from "rr (Double R)" to "rr (Double Ruby)".
+# When this was last run, the script did not work for the new name but it did work for the old name.
+# Perhaps more time was needed for the name change to propagate?
+#RUBYFORGE_PACKAGE_NAME = "rr (Double R)"
 
 # This is hacked to get around the 3 character limitation for package names on Rubyforge.
 # http://rubyforge.org/tracker/index.php?func=detail&aid=27026&group_id=5&atid=102

data/VERSION.yml

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

data/lib/rr.rb

@@ -1,5 +1,6 @@
 dir = File.dirname(__FILE__)
 require 'rubygems'
+require 'forwardable'
 
 require "#{dir}/rr/errors/rr_error"
 require "#{dir}/rr/errors/subject_does_not_implement_method_error"
@@ -14,7 +15,13 @@ require "#{dir}/rr/errors/spy_verification_errors/double_injection_not_found_err
 require "#{dir}/rr/errors/spy_verification_errors/invocation_count_error"
 
 require "#{dir}/rr/space"
-require "#{dir}/rr/double_injection"
+require "#{dir}/rr/injections/injection"
+require "#{dir}/rr/injections/double_injection"
+require "#{dir}/rr/injections/method_missing_injection"
+require "#{dir}/rr/injections/singleton_method_added_injection"
+require "#{dir}/rr/method_dispatches/base_method_dispatch"
+require "#{dir}/rr/method_dispatches/method_dispatch"
+require "#{dir}/rr/method_dispatches/method_missing_dispatch"
 require "#{dir}/rr/hash_with_object_id_key"
 require "#{dir}/rr/recorded_calls"
 require "#{dir}/rr/proc_from_block"

data/lib/rr/double.rb

@@ -28,22 +28,6 @@ module RR
       verify_method_signature if definition.verify_method_signature?
       double_injection.register_double self
     end
-    
-    # Double#call calls the Double's implementation. The return
-    # value of the implementation is returned.
-    #
-    # A TimesCalledError is raised when the times called
-    # exceeds the expected TimesCalledExpectation.
-    def call(double_injection, *args, &block)
-      if verbose?
-        puts Double.formatted_name(double_injection.method_name, args)
-      end
-      times_called_expectation.attempt if definition.times_matcher
-      space.verify_ordered_double(self) if ordered?
-      yields!(block)
-      return_value = call_implementation(double_injection, *args, &block)
-      definition.after_call_proc ? extract_subject_from_return_value(definition.after_call_proc.call(return_value)) : return_value
-    end
 
     # Double#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityExpectation arguments.
@@ -98,6 +82,18 @@ module RR
       self.class.formatted_name(method_name, expected_arguments)
     end
 
+    def method_call(args)
+      if verbose?
+        puts Double.formatted_name(method_name, args)
+      end
+      times_called_expectation.attempt if definition.times_matcher
+      space.verify_ordered_double(self) if ordered?
+    end
+
+    def implementation_is_original_method?
+      definition.implementation_is_original_method?
+    end
+
     protected
     def ordered?
       definition.ordered?
@@ -106,21 +102,6 @@ module RR
     def verbose?
       definition.verbose?
     end
-    
-    def yields!(block)
-      if definition.yields_value
-        if block
-          block.call(*definition.yields_value)
-        else
-          raise ArgumentError, "A Block must be passed into the method call when using yields"
-        end
-      end
-    end
-
-    def call_implementation(double_injection, *args, &block)
-      return_value = do_call_implementation_and_get_return_value(double_injection, *args, &block)
-      extract_subject_from_return_value(return_value)
-    end
 
     def verify_times_matcher_is_set
       unless definition.times_matcher
@@ -138,19 +119,19 @@ module RR
       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_alias_name)).arity
     end
-    
+
     def subject_accepts_only_varargs?
       subject_arity == -1
     end
-    
+
     def subject_accepts_varargs?
       subject_arity < 0
     end
-    
+
     def arity_matches?
       return true if subject_accepts_only_varargs?
       if subject_accepts_varargs?
@@ -159,54 +140,13 @@ module RR
         return subject_arity == args.size
       end
     end
-    
+
     def args
       definition.argument_expectation.expected_arguments
     end
-    
-    def do_call_implementation_and_get_return_value(double_injection, *args, &block)
-      if definition.implementation_is_original_method?
-        if double_injection.object_has_original_method?
-          double_injection.call_original_method(*args, &block)
-        else
-          double_injection.subject.__send__(
-            :method_missing,
-            method_name,
-            *args,
-            &block
-          )
-        end
-      else
-        if implementation
-          if implementation.is_a?(Method)
-            implementation.call(*args, &block)
-          else
-            args << ProcFromBlock.new(&block) if block
-            implementation.call(*args)
-          end
-        else
-          nil
-        end
-      end
-    end
-
-    def extract_subject_from_return_value(return_value)
-      case return_value
-      when DoubleDefinitions::DoubleDefinition
-        return_value.root_subject
-      when DoubleDefinitions::DoubleDefinitionCreatorProxy
-        return_value.__creator__.root_subject
-      else
-        return_value
-      end
-    end
-
-    def implementation
-      definition.implementation
-    end
 
     def argument_expectation
       definition.argument_expectation
-    end    
+    end
   end
 end

data/lib/rr/double_definitions/double_definition_creator_proxy.rb

@@ -4,7 +4,7 @@ module RR
       class << self
         def blank_slate_methods
           instance_methods.each do |m|
-            unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'respond_to?' || m.to_s == 'method_missing'
+            unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'respond_to?' || m.to_s == 'method_missing' || m.to_s == 'instance_eval' || m.to_s == 'instance_exec'
               alias_method "__blank_slated_#{m}", m
               undef_method m
             end

data/lib/rr/hash_with_object_id_key.rb

@@ -3,9 +3,7 @@ module RR
   class HashWithObjectIdKey < ::Hash #:nodoc:
     def initialize
       @keys = {}
-      super do |hash, subject_object|
-        hash.set_with_object_id(subject_object, {})
-      end
+      super
     end
 
     alias_method :get_with_object_id, :[]

data/lib/rr/injections/double_injection.rb

@@ -0,0 +1,119 @@
+module RR
+  module Injections
+    # RR::DoubleInjection is the binding of an subject and a method.
+    # A double_injection has 0 to many Double objects. Each Double
+    # has Argument Expectations and Times called Expectations.
+    class DoubleInjection < Injection
+      attr_reader :subject_class, :method_name, :doubles
+
+      MethodArguments = Struct.new(:arguments, :block)
+
+      def initialize(subject, method_name, subject_class)
+        @subject = subject
+        @subject_class = subject_class
+        @method_name = method_name.to_sym
+        @doubles = []
+      end
+
+      # RR::DoubleInjection#register_double adds the passed in Double
+      # into this DoubleInjection's list of Double objects.
+      def register_double(double)
+        @doubles << double
+      end
+
+      # RR::DoubleInjection#bind injects a method that acts as a dispatcher
+      # that dispatches to the matching Double when the method
+      # is called.
+      def bind
+        if subject_respond_to_method?(method_name)
+          if subject_has_method_defined?(method_name)
+            bind_method_with_alias
+          else
+            space.method_missing_injection(subject)
+            space.singleton_method_added_injection(subject)
+          end
+        else
+          bind_method
+        end
+        self
+      end
+
+      # RR::DoubleInjection#verify verifies each Double
+      # TimesCalledExpectation are met.
+      def verify
+        @doubles.each do |double|
+          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
+        if subject_has_original_method?
+          subject_class.__send__(:alias_method, method_name, original_method_alias_name)
+          subject_class.__send__(:remove_method, original_method_alias_name)
+        else
+          if subject_has_method_defined?(method_name)
+            subject_class.__send__(:remove_method, method_name)
+          end
+        end
+      end
+
+      def dispatch_method(args, block)
+        dispatch = MethodDispatches::MethodDispatch.new(self, args, block)
+        if @bypass_bound_method
+          dispatch.call_original_method
+        else
+          dispatch.call
+        end
+      end
+
+      def dispatch_method_missing(method_name, args, block)
+        MethodDispatches::MethodMissingDispatch.new(subject, method_name, args, block).call
+      end
+
+      def subject_has_original_method_missing?
+        subject_respond_to_method?(original_method_missing_alias_name)
+      end
+
+      def original_method_alias_name
+        "__rr__original_#{@method_name}"
+      end
+
+      def original_method_missing_alias_name
+        MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name
+      end
+
+      def bypass_bound_method
+        @bypass_bound_method = true
+        yield
+      ensure
+        @bypass_bound_method = nil
+      end
+
+      protected
+      def deferred_bind_method
+        unless subject_has_method_defined?(original_method_alias_name)
+          bind_method_with_alias
+        end
+        @performed_deferred_bind = true
+      end
+
+      def bind_method_with_alias
+        subject_class.__send__(:alias_method, original_method_alias_name, method_name)
+        bind_method
+      end
+
+      def bind_method
+        returns_method = <<-METHOD
+        def #{@method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          RR::Space.double_injection(self, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
+        end
+        METHOD
+        subject_class.class_eval(returns_method, __FILE__, __LINE__ - 5)
+      end
+    end
+  end
+end

data/lib/rr/injections/injection.rb

@@ -0,0 +1,22 @@
+module RR
+  module Injections
+    class Injection
+      include Space::Reader
+
+      attr_reader :subject
+
+      def subject_has_method_defined?(method_name)
+        @subject.methods.include?(method_name.to_s) || @subject.protected_methods.include?(method_name.to_s) || @subject.private_methods.include?(method_name.to_s)
+      end
+
+      def subject_has_original_method?
+        subject_respond_to_method?(original_method_alias_name)
+      end
+
+      protected
+      def subject_respond_to_method?(method_name)
+        subject_has_method_defined?(method_name) || @subject.respond_to?(method_name)
+      end
+    end
+  end
+end

data/lib/rr/injections/method_missing_injection.rb

@@ -0,0 +1,62 @@
+module RR
+  module Injections
+    class MethodMissingInjection < Injection
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def bind
+        unless subject.respond_to?(original_method_alias_name)
+          unless subject.respond_to?(:method_missing)
+            @placeholder_method_defined = true
+            subject_class.class_eval do
+              def method_missing(method_name, *args, &block)
+                super
+              end
+            end
+          end
+          subject_class.__send__(:alias_method, original_method_alias_name, :method_missing)
+          bind_method
+        end
+        self
+      end
+
+      def reset
+        if subject_has_method_defined?(original_method_alias_name)
+          memoized_original_method_alias_name = original_method_alias_name
+          placeholder_method_defined = @placeholder_method_defined
+          subject_class.class_eval do
+            if placeholder_method_defined
+              remove_method :method_missing
+            else
+              alias_method :method_missing, memoized_original_method_alias_name
+            end
+            remove_method memoized_original_method_alias_name
+          end
+        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
+        def method_missing(method_name, *args, &block)
+          RR::Space.method_missing_injection(self).dispatch_method(method_name, args, block)
+        end
+        METHOD
+        subject_class.class_eval(returns_method, __FILE__, __LINE__ - 4)
+      end
+
+      def original_method_alias_name
+        MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name
+      end
+    end
+  end
+end

data/lib/rr/injections/singleton_method_added_injection.rb

@@ -0,0 +1,58 @@
+module RR
+  module Injections
+    class SingletonMethodAddedInjection < Injection
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def bind
+        unless subject.respond_to?(original_method_alias_name)
+          unless subject.respond_to?(:singleton_method_added)
+            @placeholder_method_defined = true
+            subject_class.class_eval do
+              def singleton_method_added(method_name)
+                super
+              end
+            end
+          end
+
+          memoized_subject = subject
+          memoized_space = space
+          memoized_original_method_alias_name = original_method_alias_name
+          subject_class.__send__(:alias_method, original_method_alias_name, :singleton_method_added)
+          subject_class.__send__(:define_method, :singleton_method_added) do |method_name_arg|
+            if memoized_space.double_injection_exists?(memoized_subject, method_name_arg)
+              memoized_space.double_injection(memoized_subject, method_name_arg).send(:deferred_bind_method)
+            end
+            send(memoized_original_method_alias_name, method_name_arg)
+          end
+        end
+        self
+      end
+
+      def reset
+        if subject_has_method_defined?(original_method_alias_name)
+          memoized_original_method_alias_name = original_method_alias_name
+          placeholder_method_defined = @placeholder_method_defined
+          subject_class.class_eval do
+            if placeholder_method_defined
+              remove_method :singleton_method_added
+            else
+              alias_method :singleton_method_added, memoized_original_method_alias_name
+            end
+            remove_method memoized_original_method_alias_name
+          end
+        end
+      end
+
+      protected
+      def subject_class
+        class << subject; self; end
+      end
+
+      def original_method_alias_name
+        "__rr__original_singleton_method_added"
+      end
+    end
+  end
+end