redinger-rr 0.10.3

data/lib/rr/double_definitions/double_definition_creator_proxy.rb

@@ -0,0 +1,37 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinitionCreatorProxy
+      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' || m.to_s == 'instance_eval' || m.to_s == 'instance_exec'
+              alias_method "__blank_slated_#{m}", m
+              undef_method m
+            end
+          end
+        end
+      end
+
+      def initialize(creator, &block) #:nodoc:
+        @creator = creator
+        respond_to?(:class) ? self.class.blank_slate_methods : __blank_slated_class.blank_slate_methods
+
+        if block_given?
+          if block.arity == 1
+            yield(self)
+          else
+            respond_to?(:instance_eval) ? instance_eval(&block) : __blank_slated_instance_eval(&block)
+          end
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        @creator.create(method_name, *args, &block)
+      end
+
+      def __creator__
+        @creator
+      end
+    end    
+  end
+end

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

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class ImplementationStrategy < Strategy
+          class << self
+            def register_self_at_double_definition_creator(domain_name)
+              DoubleDefinitionCreator.register_implementation_strategy_class(self, domain_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        # This method add proxy capabilities to the Double. proxy can be called
+        # with mock or stub.
+        #
+        #   mock.proxy(controller.template).render(:partial => "my/socks")
+        #
+        #   stub.proxy(controller.template).render(:partial => "my/socks") do |html|
+        #     html.should include("My socks are wet")
+        #     html
+        #   end
+        #
+        #   mock.proxy(controller.template).render(:partial => "my/socks") do |html|
+        #     html.should include("My socks are wet")
+        #     "My new return value"
+        #   end
+        #
+        # mock.proxy also takes a block for definitions.
+        #   mock.proxy(subject) do
+        #     render(:partial => "my/socks")
+        #
+        #     render(:partial => "my/socks") do |html|
+        #       html.should include("My socks are wet")
+        #       html
+        #     end
+        #
+        #     render(:partial => "my/socks") do |html|
+        #       html.should include("My socks are wet")
+        #       html
+        #     end
+        #
+        #     render(:partial => "my/socks") do |html|
+        #       html.should include("My socks are wet")
+        #       "My new return value"
+        #     end
+        #   end
+        #
+        # Passing a block to the Double (after the method name and arguments)
+        # allows you to intercept the return value.
+        # The return value can be modified, validated, and/or overridden by
+        # passing in a block. The return value of the block will replace
+        # the actual return value.
+        #
+        #   mock.proxy(controller.template).render(:partial => "my/socks") do |html|
+        #     html.should include("My socks are wet")
+        #     "My new return value"
+        #   end        
+        class Proxy < ImplementationStrategy
+          register("proxy", :probe)
+
+          protected
+          def do_call
+            definition.implemented_by_original_method
+            definition.after_call(&handler) if handler
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class Reimplementation < ImplementationStrategy
+          protected
+          def do_call
+            reimplementation
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class StronglyTypedReimplementation < Reimplementation
+          register("strong")
+
+          protected
+          def do_call
+            super
+            definition.verify_method_signature
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Scope
+        class Instance < ScopeStrategy
+          protected
+          def do_call
+            double_injection = space.double_injection(subject, method_name)
+            Double.new(double_injection, definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/scope/instance_of_class.rb

@@ -0,0 +1,50 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Scope
+        # 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 InstanceOfClass < ScopeStrategy
+          register "instance_of"
+
+          def initialize(*args)
+            super
+
+            if !double_definition_creator.no_subject? && !double_definition_creator.subject.is_a?(Class)
+              raise ArgumentError, "instance_of only accepts class objects"
+            end
+          end
+
+          protected
+          def do_call
+            instance_of_subject_creator = DoubleDefinitionCreator.new
+            instance_of_subject_creator.strong if definition.verify_method_signature?
+            instance_of_subject_creator.stub(subject)
+            instance_of_subject_creator.create(:new) do |*args|
+              #####
+              instance = subject.allocate
+              double_injection = space.double_injection(instance, method_name)
+              Double.new(double_injection, definition)
+              #####
+              if args.last.is_a?(ProcFromBlock)
+                instance.__send__(:initialize, *args[0..(args.length-2)], &args.last)
+              else
+                instance.__send__(:initialize, *args)
+              end
+              instance
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/scope/scope_strategy.rb

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Scope
+        class ScopeStrategy < Strategy
+          class << self
+            def register_self_at_double_definition_creator(domain_name)
+              DoubleDefinitionCreator.register_scope_strategy_class(self, domain_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      class Strategy
+        class << self
+          attr_reader :domain_name
+          def register(domain_name, *alias_method_names)
+            @domain_name = domain_name
+            register_self_at_double_definition_creator(domain_name)
+            DoubleDefinitionCreator.class_eval do
+              alias_method_names.each do |alias_method_name|
+                alias_method alias_method_name, domain_name
+              end
+            end
+            RR::Adapters::RRMethods.register_strategy_class(self, domain_name)
+            DoubleDefinition.register_strategy_class(self, domain_name)
+            RR::Adapters::RRMethods.class_eval do
+              alias_method_names.each do |alias_method_name|
+                alias_method alias_method_name, domain_name
+              end
+            end
+          end
+
+          def register_self_at_double_definition_creator
+          end
+        end
+
+        attr_reader :double_definition_creator, :definition, :method_name, :args, :handler
+        include Space::Reader
+
+        def initialize(double_definition_creator)
+          @double_definition_creator = double_definition_creator
+        end
+        
+        def call(definition, method_name, args, handler)
+          @definition, @method_name, @args, @handler = definition, method_name, args, handler
+          do_call
+        end
+
+        def name
+          self.class.domain_name
+        end
+
+        def verify_subject(subject)
+        end  
+
+        protected
+        def do_call
+          raise NotImplementedError
+        end
+
+        def permissive_argument
+          if args.empty?
+            definition.with_any_args
+          else
+            definition.with(*args)
+          end
+        end
+
+        def reimplementation
+          definition.returns(&handler)
+        end
+
+        def subject
+          definition.subject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a dont_allow strategy.
+        # A dont_allow strategy sets the default state of the Double
+        # to expect never to be called. The Double's expectations can be
+        # changed.
+        #
+        # The following example sets the expectation that subject.method_name
+        # will never be called with arg1 and arg2.
+        #
+        #   do_not_allow(subject).method_name(arg1, arg2)
+        #
+        # dont_allow also supports a block sytnax.
+        #    dont_allow(subject) do |m|
+        #      m.method1 # Do not allow method1 with any arguments
+        #      m.method2(arg1, arg2) # Do not allow method2 with arguments arg1 and arg2
+        #      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
+            permissive_argument
+            reimplementation
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a mock strategy. A mock strategy
+        # sets the default state of the Double to expect the method call
+        # with arguments exactly one time. The Double's expectations can be
+        # changed.
+        #
+        # This method can be chained with proxy.
+        #   mock.proxy(subject).method_name_1
+        #   or
+        #   proxy.mock(subject).method_name_1
+        #
+        # When passed the subject, a DoubleDefinitionCreatorProxy 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.
+        #   mock(subject).method_name_1 {return_value_1}
+        #   mock(subject).method_name_2(arg1, arg2) {return_value_2}
+        #
+        # When passed the subject and the method_name, this method returns
+        # a mock Double with the method already set.
+        #
+        #   mock(subject, :method_name_1) {return_value_1}
+        #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+        #
+        # mock also takes a block for definitions.
+        #   mock(subject) do
+        #     method_name_1 {return_value_1}
+        #     method_name_2(arg_1, arg_2) {return_value_2}
+        #   end        
+        class Mock < VerificationStrategy
+          register "mock"
+
+          protected
+          def do_call
+            definition.with(*args).once
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        # This method sets the Double to have a stub strategy. A stub strategy
+        # sets the default state of the Double to expect the method call
+        # with any arguments any number of times. The Double's
+        # expectations can be changed.
+        #
+        # This method can be chained with proxy.
+        #   stub.proxy(subject).method_name_1
+        #   or
+        #   proxy.stub(subject).method_name_1
+        #
+        # When passed the subject, a DoubleDefinitionCreatorProxy 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.
+        #   stub(subject).method_name_1 {return_value_1}
+        #   stub(subject).method_name_2(arg_1, arg_2) {return_value_2}
+        #
+        # When passed the subject and the method_name, this method returns
+        # a stub Double with the method already set.
+        #
+        #   mock(subject, :method_name_1) {return_value_1}
+        #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+        #
+        # stub also takes a block for definitions.
+        #   stub(subject) do
+        #     method_name_1 {return_value_1}
+        #     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
+            permissive_argument
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        class VerificationStrategy < Strategy
+          class << self
+            def register_self_at_double_definition_creator(domain_name)
+              DoubleDefinitionCreator.register_verification_strategy_class(self, domain_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end