rr 0.10.11 → 1.0.0

data/lib/rr/double_definitions/double_injections/any_instance_of.rb

@@ -0,0 +1,28 @@
+module RR
+  module DoubleDefinitions
+    module DoubleInjections
+      class AnyInstanceOf
+        extend(Module.new do
+          include RR::Adapters::RRMethods
+
+          def call(subject_class, stubbed_methods=nil, &block)
+            ::RR::DoubleDefinitions::DoubleDefinitionCreate.set_default_double_injection_strategy(lambda do |double_definition_create|
+              ::RR::DoubleDefinitions::Strategies::DoubleInjection::AnyInstanceOf.new(double_definition_create)
+            end) do
+              if stubbed_methods
+                subject_class.class_eval do
+                  stubbed_methods.each do |name, value|
+                    value_proc = value.is_a?(Proc) ? value : lambda {value}
+                    RR.stub(subject_class, name).returns(&value_proc)
+                  end
+                end
+              else
+                block.call(subject_class)
+              end
+            end
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/double_injections/instance.rb

@@ -0,0 +1,16 @@
+module RR
+  module DoubleDefinitions
+    module DoubleInjections
+      class Instance
+        extend(Module.new do
+          include ::RR::Adapters::RRMethods
+
+          def call(double_method_name, *args, &definition_eval_block)
+            double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+            double_definition_create.send(double_method_name, *args, &definition_eval_block)
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/double_injections/new_instance_of.rb

@@ -0,0 +1,53 @@
+module RR
+  module DoubleDefinitions
+    module DoubleInjections
+      class NewInstanceOf
+        extend(Module.new do
+          include RR::Adapters::RRMethods
+          def call(subject, stubbed_methods={})
+            double_definition_create = DoubleDefinitionCreate.new.stub
+            stub.proxy(subject).allocate do |instance|
+              add_stubbed_methods(instance, stubbed_methods)
+              add_method_chain_definition(instance, double_definition_create)
+              yield(instance) if block_given?
+              instance
+            end
+            stub(subject).new do |*args|
+              instance = subject.allocate
+              initialize_subject_instance(instance, args)
+            end
+            DoubleDefinitionCreateBlankSlate.new(double_definition_create)
+          end
+
+          protected
+          def add_stubbed_methods(subject_instance, stubbed_methods)
+            stubbed_methods.each do |name, value|
+              value_proc = value.is_a?(Proc) ? value : lambda {value}
+              stub(subject_instance, name).returns(&value_proc)
+            end
+          end
+
+          def add_method_chain_definition(subject_instance, double_definition_create)
+            implementation_strategy = double_definition_create.implementation_strategy
+            if implementation_strategy.method_name
+              stub(subject_instance).method_missing(
+                implementation_strategy.method_name,
+                *implementation_strategy.args,
+                &implementation_strategy.handler
+              )
+            end
+          end
+
+          def initialize_subject_instance(subject_instance, args)
+            if args.last.is_a?(ProcFromBlock)
+              subject_instance.__send__(:initialize, *args[0..(args.length-2)], &args.last)
+            else
+              subject_instance.__send__(:initialize, *args)
+            end
+            subject_instance
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/double_injection/any_instance_of.rb

@@ -0,0 +1,31 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module DoubleInjection
+        # This class is Deprecated.
+        # Calling instance_of will cause all instances of the passed in Class
+        # to have the Double defined.
+        #
+        # The following example mocks all User's valid? method and return false.
+        #   mock.instance_of(User).valid? {false}
+        #
+        # The following example mocks and proxies User#projects and returns the
+        # first 3 projects.
+        #   mock.instance_of(User).projects do |projects|
+        #     projects[0..2]
+        #   end        
+        class AnyInstanceOf < DoubleInjectionStrategy
+          protected
+          def do_call
+            if !double_definition_create.no_subject? && !double_definition_create.subject.is_a?(Class)
+              raise ArgumentError, "instance_of only accepts class objects"
+            end
+#            subject, method_name
+            double_injection = Injections::DoubleInjection.find_or_create(subject, method_name)
+            Double.new(double_injection, definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/double_injection/double_injection_strategy.rb

@@ -0,0 +1,10 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module DoubleInjection
+        class DoubleInjectionStrategy < Strategy
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/double_injection/instance.rb

@@ -0,0 +1,17 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module DoubleInjection
+        class Instance < DoubleInjectionStrategy
+          protected
+          def do_call
+            double_injection = Injections::DoubleInjection.find_or_create(
+              (class << subject; self; end), method_name
+            )
+            Double.new(double_injection, definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/double_injection/new_instance_of.rb

@@ -0,0 +1,37 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module DoubleInjection
+        # This class is Deprecated.
+        # Calling instance_of will cause all instances of the passed in Class
+        # to have the Double defined.
+        #
+        # The following example mocks all User's valid? method and return false.
+        #   mock.instance_of(User).valid? {false}
+        #
+        # The following example mocks and proxies User#projects and returns the
+        # first 3 projects.
+        #   mock.instance_of(User).projects do |projects|
+        #     projects[0..2]
+        #   end        
+        class NewInstanceOf < DoubleInjectionStrategy
+          protected
+          def do_call
+            if !double_definition_create.no_subject? && !double_definition_create.subject.is_a?(Class)
+              raise ArgumentError, "instance_of only accepts class objects"
+            end
+            DoubleDefinitions::DoubleInjections::NewInstanceOf.call(subject) do |subject|
+              add_double_to_instance(subject)
+            end
+          end
+          
+          def add_double_to_instance(instance)
+            double_injection = Injections::DoubleInjection.find_or_create((class << instance; self; end), method_name)
+            Double.new(double_injection, definition)
+            instance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/implementation/implementation_strategy.rb

@@ -3,11 +3,6 @@ module RR
     module Strategies
       module Implementation
         class ImplementationStrategy < Strategy
-          class << self
-            def register_self_at_double_definition_create(strategy_method_name)
-              DoubleDefinitionCreate.register_implementation_strategy_class(self, strategy_method_name)
-            end
-          end
         end
       end
     end

data/lib/rr/double_definitions/strategies/implementation/proxy.rb

@@ -48,8 +48,6 @@ module RR
         #     "My new return value"
         #   end        
         class Proxy < ImplementationStrategy
-          register("proxy", :probe)
-
           protected
           def do_call
             definition.implemented_by_original_method

data/lib/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation.rb

@@ -3,8 +3,6 @@ module RR
     module Strategies
       module Implementation
         class StronglyTypedReimplementation < Reimplementation
-          register("strong")
-
           protected
           def do_call
             super

data/lib/rr/double_definitions/strategies/strategy.rb

@@ -2,29 +2,6 @@ module RR
   module DoubleDefinitions
     module Strategies
       class Strategy
-        class << self
-          attr_reader :strategy_method_name
-          def register(strategy_method_name, *alias_method_names)
-            @strategy_method_name = strategy_method_name
-            register_self_at_double_definition_create(strategy_method_name)
-            DoubleDefinitionCreate.class_eval do
-              alias_method_names.each do |alias_method_name|
-                alias_method alias_method_name, strategy_method_name
-              end
-            end
-            RR::Adapters::RRMethods.register_strategy_class(self, strategy_method_name)
-            DoubleDefinition.register_strategy_class(self, strategy_method_name)
-            RR::Adapters::RRMethods.class_eval do
-              alias_method_names.each do |alias_method_name|
-                alias_method alias_method_name, strategy_method_name
-              end
-            end
-          end
-
-          def register_self_at_double_definition_create(strategy_method_name)
-          end
-        end
-
         attr_reader :double_definition_create, :definition, :method_name, :args, :handler
         include Space::Reader
 
@@ -37,10 +14,6 @@ module RR
           do_call
         end
 
-        def name
-          self.class.strategy_method_name
-        end
-
         def verify_subject(subject)
         end  
 

data/lib/rr/double_definitions/strategies/strategy_methods.rb

@@ -0,0 +1,53 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module StrategyMethods
+        extend(Module.new do
+          def lately_bound_alias_method(target_method_name, source_method_name)
+            module_eval((<<-METHOD), __FILE__, __LINE__+1)
+            def #{target_method_name}(*args, &block)
+              #{source_method_name}(*args, &block)
+            end
+            METHOD
+          end
+        end)
+
+        def mock!(method_name=nil, &definition_eval_block)
+          mock(Object.new, method_name, &definition_eval_block)
+        end
+
+        def stub!(method_name=nil, &definition_eval_block)
+          stub(Object.new, method_name, &definition_eval_block)
+        end
+
+        def dont_allow!(method_name=nil, &definition_eval_block)
+          dont_allow(Object.new, method_name, &definition_eval_block)
+        end
+        lately_bound_alias_method :do_not_allow, :dont_allow
+        lately_bound_alias_method :do_not_allow!, :dont_allow!
+
+        def proxy!(method_name=nil, &definition_eval_block)
+          proxy(Object.new, method_name, &definition_eval_block)
+        end
+        lately_bound_alias_method :probe, :proxy
+        lately_bound_alias_method :probe!, :proxy!
+
+        def strong!(method_name=nil, &definition_eval_block)
+          strong(Object.new, method_name, &definition_eval_block)
+        end
+
+        def any_instance_of!(method_name=nil, &definition_eval_block)
+          any_instance_of(Object.new, method_name, &definition_eval_block)
+        end
+        lately_bound_alias_method :all_instances_of, :any_instance_of
+        lately_bound_alias_method :all_instances_of!, :any_instance_of!
+
+        def instance_of!(method_name=nil, &definition_eval_block)
+          instance_of(Object.new, method_name, &definition_eval_block)
+        end
+        lately_bound_alias_method :new_instance_of, :instance_of
+        lately_bound_alias_method :new_instance_of!, :instance_of!
+      end
+    end
+  end
+end

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

@@ -19,8 +19,6 @@ module RR
         #      m.method3.with_no_args # Do not allow method3 with no arguments
         #    end        
         class DontAllow < VerificationStrategy
-          register("dont_allow", :do_not_allow, :dont_call, :do_not_call)
-
           protected
           def do_call
             definition.never

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

@@ -31,8 +31,6 @@ module RR
         #     method_name_2(arg_1, arg_2) {return_value_2}
         #   end        
         class Mock < VerificationStrategy
-          register "mock"
-
           protected
           def do_call
             definition.with(*args).once

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

@@ -31,8 +31,6 @@ module RR
         #     method_name_2(arg_1, arg_2) {return_value_2}
         #   end        
         class Stub < VerificationStrategy
-          register "stub"
-
           protected
           def do_call
             definition.any_number_of_times

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

@@ -3,11 +3,6 @@ module RR
     module Strategies
       module Verification
         class VerificationStrategy < Strategy
-          class << self
-            def register_self_at_double_definition_create(strategy_method_name)
-              DoubleDefinitionCreate.register_verification_strategy_class(self, strategy_method_name)
-            end
-          end
         end
       end
     end

data/lib/rr/hash_with_object_id_key.rb

@@ -13,6 +13,10 @@ module RR
       super(key.__id__)
     end
 
+    def has_key?(key)
+      super(key.__id__)
+    end
+
     alias_method :set_with_object_id, :[]=
 
     def []=(key, value)

data/lib/rr/injections/double_injection.rb

@@ -4,67 +4,95 @@ 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
+      extend(Module.new do
+        def find_or_create(subject_class, method_name)
+          instances[subject_class][method_name.to_sym] ||= begin
+            new(subject_class, method_name.to_sym).bind
           end
         end
 
-        def exists?(subject, method_name)
-          instances.include?(subject) && instances[subject].include?(method_name.to_sym)
+        def find_or_create_by_subject(subject, method_name)
+          find_or_create(class << subject; self; end, method_name)
+        end
+
+        def find(subject_class, method_name)
+          instances[subject_class] && instances[subject_class][method_name.to_sym]
+        end
+
+        def find_by_subject(subject, method_name)
+          find(class << subject; self; end, method_name)
+        end
+
+        def exists?(subject_class, method_name)
+          !!find(subject_class, method_name)
+        end
+
+        def exists_by_subject?(subject, method_name)
+          exists?((class << subject; self; end), method_name)
+        end
+
+        def dispatch_method(subject, subject_class, method_name, arguments, block)
+          subject_eigenclass = (class << subject; self; end)
+          if exists?(subject_class, method_name) && (subject_class == subject_eigenclass || subject_eigenclass.superclass != (class << Class; self; end))
+            find(subject_class, method_name.to_sym).dispatch_method(subject, arguments, block)
+          else
+            new(subject_class, method_name.to_sym).dispatch_original_method(subject, arguments, block)
+          end
         end
 
         def reset
-          instances.each do |subject, method_double_map|
+          instances.each do |subject_class, method_double_map|
+            SingletonMethodAddedInjection.find(subject_class) && SingletonMethodAddedInjection.find(subject_class).reset
             method_double_map.keys.each do |method_name|
-              reset_double(subject, method_name)
+              reset_double(subject_class, method_name)
             end
+            Injections::DoubleInjection.instances.delete(subject_class) if Injections::DoubleInjection.instances.has_key?(subject_class)
           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)
+          subject_classes = subjects.empty? ?
+            Injections::DoubleInjection.instances.keys :
+            subjects.map {|subject| class << subject; self; end}
+          subject_classes.each do |subject_class|
+            instances.include?(subject_class) &&
+              instances[subject_class].keys.each do |method_name|
+                verify_double(subject_class, method_name)
               end &&
-              instances.delete(subject)
+              instances.delete(subject_class)
           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
+        def verify_double(subject_class, method_name)
+          Injections::DoubleInjection.find(subject_class, method_name).verify
         ensure
-          reset_double subject, method_name
+          reset_double subject_class, 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?
+        def reset_double(subject_class, method_name)
+          double_injection = Injections::DoubleInjection.instances[subject_class].delete(method_name)
           double_injection.reset
+          Injections::DoubleInjection.instances.delete(subject_class) if Injections::DoubleInjection.instances[subject_class].empty?
         end
 
         def instances
-          @instances ||= HashWithObjectIdKey.new do |hash, subject_object|
-            hash.set_with_object_id(subject_object, {})
+          @instances ||= HashWithObjectIdKey.new do |hash, subject_class|
+            hash.set_with_object_id(subject_class, {})
           end
         end
-      end
+      end)
 
       attr_reader :subject_class, :method_name, :doubles
 
       MethodArguments = Struct.new(:arguments, :block)
 
-      def initialize(subject, method_name, subject_class)
-        @subject = subject
+      def initialize(subject_class, method_name)
         @subject_class = subject_class
         @method_name = method_name.to_sym
         @doubles = []
-        @bypass_bound_method = nil
+        @dispatch_method_delegates_to_dispatch_original_method = nil
       end
 
       # RR::DoubleInjection#register_double adds the passed in Double
@@ -77,20 +105,37 @@ module RR
       # 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)
-            if subject_is_proxy_for_method?(method_name)
-              bind_method
-            else
-              bind_method_with_alias
-            end
-          else
-            Injections::MethodMissingInjection.create(subject)
-            Injections::SingletonMethodAddedInjection.create(subject)
-          end
+        if subject_has_method_defined?(method_name)
+          bind_method_with_alias
         else
-          bind_method
+          Injections::MethodMissingInjection.find_or_create(subject_class)
+          Injections::SingletonMethodAddedInjection.find_or_create(subject_class)
+          bind_method_that_self_destructs_and_delegates_to_method_missing
+        end
+        self
+      end
+
+      def bind_method_that_self_destructs_and_delegates_to_method_missing
+        subject_class_object_id = subject_class.object_id
+        subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
+        def #{method_name}(*args, &block)
+          ObjectSpace._id2ref(#{subject_class_object_id}).class_eval do
+            remove_method(:#{method_name})
+          end
+          method_missing(:#{method_name}, *args, &block)
         end
+        METHOD
+        self
+      end
+
+      def bind_method
+        subject_class_object_id = subject_class.object_id
+        subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
+        def #{method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          RR::Injections::DoubleInjection.dispatch_method(self, ObjectSpace._id2ref(#{subject_class_object_id}), :#{method_name}, arguments.arguments, arguments.block)
+        end
+        METHOD
         self
       end
 
@@ -118,48 +163,36 @@ module RR
         end
       end
 
-      def dispatch_method(args, block)
-        dispatch = MethodDispatches::MethodDispatch.new(self, args, block)
-        if @bypass_bound_method
-          dispatch.call_original_method
+      def dispatch_method(subject, args, block)
+        if @dispatch_method_delegates_to_dispatch_original_method
+          dispatch_original_method(subject, args, block)
         else
+          dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
           dispatch.call
         end
       end
 
-      def dispatch_method_missing(method_name, args, block)
-        MethodDispatches::MethodMissingDispatch.new(subject, method_name, args, block).call
+      def dispatch_original_method(subject, args, block)
+        dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
+        dispatch.call_original_method
       end
 
       def subject_has_original_method_missing?
-        subject_respond_to_method?(original_method_missing_alias_name)
+        ClassInstanceMethodDefined.call(subject_class, MethodDispatches::MethodMissingDispatch.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
+      def dispatch_method_delegates_to_dispatch_original_method
+        @dispatch_method_delegates_to_dispatch_original_method = true
         yield
       ensure
-        @bypass_bound_method = nil
+        @dispatch_method_delegates_to_dispatch_original_method = nil
       end
 
       protected
-      def subject_is_proxy_for_method?(method_name_in_question)
-        !(
-        class << @subject;
-          self;
-        end).
-          instance_methods.
-          detect {|method_name| method_name.to_sym == method_name_in_question.to_sym}
-      end
-
       def deferred_bind_method
         unless subject_has_method_defined?(original_method_alias_name)
           bind_method_with_alias
@@ -171,16 +204,6 @@ module RR
         subject_class.__send__(:alias_method, original_method_alias_name, method_name)
         bind_method
       end
-
-      def bind_method
-        subject = @subject.is_a?(Class) && !@subject.name.to_s.empty? ? @subject.name : "self"
-        subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
-        def #{@method_name}(*args, &block)
-          arguments = MethodArguments.new(args, block)
-          RR::Injections::DoubleInjection.create(#{subject}, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
-        end
-        METHOD
-      end
     end
   end
 end