rr 0.10.10 → 0.10.11

data/lib/rr/double_definitions/strategies/verification/mock.rb

@@ -12,7 +12,7 @@ module RR
         #   or
         #   proxy.mock(subject).method_name_1
         #
-        # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
+        # When passed the subject, a DoubleDefinitionCreateBlankSlate is returned. Passing
         # a method with arguments to the proxy will set up expectations that
         # the a call to the subject's method with the arguments will happen,
         # and return the prescribed value.

data/lib/rr/double_definitions/strategies/verification/stub.rb

@@ -12,7 +12,7 @@ module RR
         #   or
         #   proxy.stub(subject).method_name_1
         #
-        # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
+        # When passed the subject, a DoubleDefinitionCreateBlankSlate is returned. Passing
         # a method with arguments to the proxy will set up expectations that
         # the a call to the subject's method with the arguments will happen,
         # and return the prescribed value.

data/lib/rr/double_definitions/strategies/verification/verification_strategy.rb

@@ -4,8 +4,8 @@ module RR
       module Verification
         class VerificationStrategy < Strategy
           class << self
-            def register_self_at_double_definition_creator(domain_name)
-              DoubleDefinitionCreator.register_verification_strategy_class(self, domain_name)
+            def register_self_at_double_definition_create(strategy_method_name)
+              DoubleDefinitionCreate.register_verification_strategy_class(self, strategy_method_name)
             end
           end
         end

data/lib/rr/injections/double_injection.rb

@@ -4,6 +4,57 @@ module RR
     # A double_injection has 0 to many Double objects. Each Double
     # has Argument Expectations and Times called Expectations.
     class DoubleInjection < Injection
+      class << self
+        def create(subject, method_name)
+          instances[subject][method_name.to_sym] ||= begin
+            new(subject, method_name.to_sym, (class << subject; self; end)).bind
+          end
+        end
+
+        def exists?(subject, method_name)
+          instances.include?(subject) && instances[subject].include?(method_name.to_sym)
+        end
+
+        def reset
+          instances.each do |subject, method_double_map|
+            method_double_map.keys.each do |method_name|
+              reset_double(subject, method_name)
+            end
+          end
+        end
+
+        def verify(*subjects)
+          subjects = Injections::DoubleInjection.instances.keys if subjects.empty?
+          subjects.each do |subject|
+            instances.include?(subject) &&
+              instances[subject].keys.each do |method_name|
+                verify_double(subject, method_name)
+              end &&
+              instances.delete(subject)
+          end
+        end
+
+        # Verifies the DoubleInjection for the passed in subject and method_name.
+        def verify_double(subject, method_name)
+          Injections::DoubleInjection.instances[subject][method_name].verify
+        ensure
+          reset_double subject, method_name
+        end
+
+        # Resets the DoubleInjection for the passed in subject and method_name.
+        def reset_double(subject, method_name)
+          double_injection = Injections::DoubleInjection.instances[subject].delete(method_name)
+          Injections::DoubleInjection.instances.delete(subject) if Injections::DoubleInjection.instances[subject].empty?
+          double_injection.reset
+        end
+
+        def instances
+          @instances ||= HashWithObjectIdKey.new do |hash, subject_object|
+            hash.set_with_object_id(subject_object, {})
+          end
+        end
+      end
+
       attr_reader :subject_class, :method_name, :doubles
 
       MethodArguments = Struct.new(:arguments, :block)
@@ -34,8 +85,8 @@ module RR
               bind_method_with_alias
             end
           else
-            space.method_missing_injection(subject)
-            space.singleton_method_added_injection(subject)
+            Injections::MethodMissingInjection.create(subject)
+            Injections::SingletonMethodAddedInjection.create(subject)
           end
         else
           bind_method
@@ -50,6 +101,7 @@ module RR
           double.verify
         end
       end
+
       # RR::DoubleInjection#reset removes the injected dispatcher method.
 
       # It binds the original method implementation on the subject
@@ -100,7 +152,10 @@ module RR
 
       protected
       def subject_is_proxy_for_method?(method_name_in_question)
-        !(class << @subject; self; end).
+        !(
+        class << @subject;
+          self;
+        end).
           instance_methods.
           detect {|method_name| method_name.to_sym == method_name_in_question.to_sym}
       end
@@ -122,7 +177,7 @@ module RR
         subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
         def #{@method_name}(*args, &block)
           arguments = MethodArguments.new(args, block)
-          RR::Space.double_injection(#{subject}, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
+          RR::Injections::DoubleInjection.create(#{subject}, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
         end
         METHOD
       end

data/lib/rr/injections/injection.rb

@@ -1,6 +1,12 @@
 module RR
   module Injections
     class Injection
+      class << self
+        def instances
+          @instances ||= HashWithObjectIdKey.new
+        end
+      end
+
       include Space::Reader
 
       attr_reader :subject

data/lib/rr/injections/method_missing_injection.rb

@@ -1,6 +1,18 @@
 module RR
   module Injections
     class MethodMissingInjection < Injection
+      class << self
+        def create(subject)
+          instances[subject] ||= begin
+            new(subject).bind
+          end
+        end
+
+        def exists?(subject)
+          instances.include?(subject)
+        end
+      end
+
       def initialize(subject)
         @subject = subject
         @placeholder_method_defined = false
@@ -48,7 +60,7 @@ module RR
       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)
+          RR::Injections::MethodMissingInjection.create(self).dispatch_method(method_name, args, block)
         end
         METHOD
         subject_class.class_eval(returns_method, __FILE__, __LINE__ - 4)

data/lib/rr/injections/singleton_method_added_injection.rb

@@ -1,6 +1,18 @@
 module RR
   module Injections
     class SingletonMethodAddedInjection < Injection
+      class << self
+        def create(subject)
+          instances[subject] ||= begin
+            new(subject).bind
+          end
+        end
+
+        def exists?(subject)
+          instances.include?(subject)
+        end
+      end
+
       def initialize(subject)
         @subject = subject
         @placeholder_method_defined = false
@@ -18,12 +30,11 @@ module RR
           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)
+            if Injections::DoubleInjection.exists?(memoized_subject, method_name_arg)
+              Injections::DoubleInjection.create(memoized_subject, method_name_arg).send(:deferred_bind_method)
             end
             send(memoized_original_method_alias_name, method_name_arg)
           end

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -59,8 +59,8 @@ module RR
         case return_value
           when DoubleDefinitions::DoubleDefinition
             return_value.root_subject
-          when DoubleDefinitions::DoubleDefinitionCreatorProxy
-            return_value.__creator__.root_subject
+          when DoubleDefinitions::DoubleDefinitionCreateBlankSlate
+            return_value.__double_definition_create__.root_subject
           else
             return_value
         end

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -13,7 +13,7 @@ module RR
       end
 
       def call
-        if space.double_injection_exists?(subject, method_name)
+        if Injections::DoubleInjection.exists?(subject, method_name)
           space.record_call(subject, method_name, args, block)
           @double = find_double_to_attempt
 
@@ -50,7 +50,7 @@ module RR
       end
 
       def double_injection
-        space.double_injection(subject, method_name)
+        Injections::DoubleInjection.create(subject, method_name)
       end
 
       def_delegators 'self.class', :original_method_missing_alias_name

data/lib/rr/recorded_calls.rb

@@ -40,7 +40,7 @@ module RR
     attr_accessor :ordered_index
 
     def double_injection_exists_error(spy_verification)
-      unless space.double_injection_exists?(spy_verification.subject, spy_verification.method_name)
+      unless Injections::DoubleInjection.exists?(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

@@ -19,53 +19,14 @@ module RR
       end
     end
 
-    attr_reader :double_injections, :method_missing_injections, :ordered_doubles, :recorded_calls
+    attr_reader :ordered_doubles, :recorded_calls
     attr_accessor :trim_backtrace
     def initialize
-      @double_injections = HashWithObjectIdKey.new do |hash, subject_object|
-        hash.set_with_object_id(subject_object, {})
-      end
-      @method_missing_injections = HashWithObjectIdKey.new
-      @singleton_method_added_injections = HashWithObjectIdKey.new
       @ordered_doubles = []
       @trim_backtrace = false
       @recorded_calls = RR::RecordedCalls.new
     end
 
-    # Reuses or creates, if none exists, a DoubleInjection for the passed
-    # in subject and method_name.
-    # When a DoubleInjection is created, it binds the dispatcher to the
-    # subject.
-    def double_injection(subject, method_name)
-      @double_injections[subject][method_name.to_sym] ||= begin
-        Injections::DoubleInjection.new(subject, method_name.to_sym, (class << subject; self; end)).bind
-      end
-    end
-
-    def double_injection_exists?(subject, method_name)
-      @double_injections.include?(subject) && @double_injections[subject].include?(method_name.to_sym)
-    end
-
-    def method_missing_injection(subject)
-      @method_missing_injections[subject] ||= begin
-        Injections::MethodMissingInjection.new(subject).bind
-      end
-    end
-
-    def method_missing_injection_exists?(subject)
-      @method_missing_injections.include?(subject)
-    end
-
-    def singleton_method_added_injection(subject)
-      @singleton_method_added_injections[subject] ||= begin
-        Injections::SingletonMethodAddedInjection.new(subject).bind
-      end
-    end
-
-    def singleton_method_added_injection_exists?(subject)
-      @singleton_method_added_injections.include?(subject)
-    end
-
     # Registers the ordered Double to be verified.
     def register_ordered_double(double)
       @ordered_doubles << double unless ordered_doubles.include?(double)
@@ -90,20 +51,15 @@ module RR
 
     # Verifies all the DoubleInjection objects have met their
     # TimesCalledExpectations.
-    def verify_doubles(*objects)
-      objects = @double_injections.keys if objects.empty?
-      objects.each do |subject|
-        @double_injections[subject].keys.each do |method_name|
-          verify_double(subject, method_name)
-        end
-      end
+    def verify_doubles(*subjects)
+      Injections::DoubleInjection.verify(*subjects)
     end
     alias_method :verify, :verify_doubles
 
     # Resets the registered Doubles and ordered Doubles
     def reset
       reset_ordered_doubles
-      reset_double_injections
+      Injections::DoubleInjection.reset
       reset_method_missing_injections
       reset_singleton_method_added_injections
       reset_recorded_calls
@@ -111,49 +67,42 @@ module RR
 
     # Verifies the DoubleInjection for the passed in subject and method_name.
     def verify_double(subject, method_name)
-      @double_injections[subject][method_name].verify
-    ensure
-      reset_double subject, method_name
+      Injections::DoubleInjection.verify_double(subject, method_name)
     end
 
     # Resets the DoubleInjection for the passed in subject and method_name.
     def reset_double(subject, method_name)
-      double_injection = @double_injections[subject].delete(method_name)
-      @double_injections.delete(subject) if @double_injections[subject].empty?
-      double_injection.reset
+      Injections::DoubleInjection.reset_double(subject, method_name)
     end
-    
+
     def record_call(subject, method_name, arguments, block)
       @recorded_calls << [subject, method_name, arguments, block]
     end
 
+    def blank_slate_whitelist
+      @blank_slate_whitelist ||= [
+        "object_id", "respond_to?", "method_missing", "instance_eval", "instance_exec", "class_eval"
+      ]
+    end
+
     protected
     # Removes the ordered Doubles from the list
     def reset_ordered_doubles
       @ordered_doubles.clear
     end
 
-    # Resets the registered Doubles for the next test run.
-    def reset_double_injections
-      @double_injections.each do |subject, method_double_map|
-        method_double_map.keys.each do |method_name|
-          reset_double(subject, method_name)
-        end
-      end
-    end
-
     def reset_method_missing_injections
-      @method_missing_injections.each do |subject, injection|
+      Injections::MethodMissingInjection.instances.each do |subject, injection|
         injection.reset
       end
-      @method_missing_injections.clear
+      Injections::MethodMissingInjection.instances.clear
     end
 
     def reset_singleton_method_added_injections
-      @singleton_method_added_injections.each do |subject, injection|
+      Injections::SingletonMethodAddedInjection.instances.each do |subject, injection|
         injection.reset
       end
-      @singleton_method_added_injections.clear
+      Injections::SingletonMethodAddedInjection.instances.clear
     end
     
     def reset_recorded_calls

data/lib/rr/spy_verification_proxy.rb

@@ -1,11 +1,6 @@
 module RR
   class SpyVerificationProxy
-    instance_methods.each do |m|
-      unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == "instance_eval" || m.to_s == "instance_exec" || m.to_s == 'respond_to?'
-        alias_method "__blank_slated_#{m}", m
-        undef_method m
-      end
-    end
+    BlankSlate.call(self)
 
     def initialize(subject)
       @subject = subject

data/spec/rr/adapters/rr_methods_creator_spec.rb

@@ -23,11 +23,9 @@ module RR
             @strategy_method_name = :mock
           end
 
-          send("normal strategy definition")
-
           context "when passing no args" do
-            it "returns a DoubleDefinitionCreator" do
-              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreator
+            it "returns a DoubleDefinitionCreate" do
+              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreate
             end
           end
 
@@ -47,11 +45,9 @@ module RR
             @strategy_method_name = :stub
           end
 
-          send("normal strategy definition")
-
           context "when passing no args" do
-            it "returns a DoubleDefinitionCreator" do
-              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreator
+            it "returns a DoubleDefinitionCreate" do
+              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreate
             end
           end
 
@@ -70,11 +66,9 @@ module RR
             @strategy_method_name = :dont_allow
           end
 
-          send("normal strategy definition")
-
           context "when passing no args" do
-            it "returns a DoubleDefinitionCreator" do
-              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreator
+            it "returns a DoubleDefinitionCreate" do
+              call_strategy.class.should == RR::DoubleDefinitions::DoubleDefinitionCreate
             end
           end
 
@@ -104,12 +98,10 @@ module RR
             @strategy_method_name = :mock!
           end
 
-          send("! strategy definition")
-
           context "when passed a method_name argument" do
             it "sets #verification_strategy to Mock" do
               proxy = mock!(:foobar)
-              proxy.double_definition_creator.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::Mock
+              proxy.double_definition_create.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::Mock
             end
           end
         end
@@ -119,12 +111,10 @@ module RR
             @strategy_method_name = :stub!
           end
 
-          send("! strategy definition")
-
           context "when passed a method_name argument" do
             it "sets #verification_strategy to Stub" do
               proxy = stub!(:foobar)
-              proxy.double_definition_creator.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::Stub
+              proxy.double_definition_create.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::Stub
             end
           end
         end
@@ -134,12 +124,10 @@ module RR
             @strategy_method_name = :dont_allow!
           end
 
-          send("! strategy definition")
-
           context "when passed a method_name argument" do
             it "sets #verification_strategy to DontAllow" do
               proxy = dont_allow!(:foobar)
-              proxy.double_definition_creator.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::DontAllow
+              proxy.double_definition_create.verification_strategy.class.should == RR::DoubleDefinitions::Strategies::Verification::DontAllow
             end
           end
         end