mcmire-rr 1.0.5.rc1

data/lib/rr/double_definitions/double_definition_create.rb

@@ -0,0 +1,139 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinitionCreate # :nodoc
+      extend(Module.new do
+        def default_double_injection_strategy
+          @default_double_injection_strategy ||= lambda do |double_injection_create|
+            Strategies::DoubleInjection::Instance.new(double_injection_create)
+          end
+        end
+
+        def set_default_double_injection_strategy(strategy_lambda)
+          original_strategy_lambda = default_double_injection_strategy
+          begin
+            @default_double_injection_strategy = strategy_lambda
+            yield
+          ensure
+            @default_double_injection_strategy = original_strategy_lambda
+          end
+        end
+      end)
+
+      attr_reader :subject, :verification_strategy, :implementation_strategy, :double_injection_strategy
+      NO_SUBJECT = Object.new
+
+      include Space::Reader
+
+      def initialize
+        @verification_strategy = Strategies::Verification::Stub.new(self)
+        @implementation_strategy = Strategies::Implementation::Reimplementation.new(self)
+        @double_injection_strategy = self.class.default_double_injection_strategy.call(self)
+      end
+
+      def call(method_name, *args, &handler)
+        definition = DoubleDefinition.new(self)
+        verification_strategy.call(definition, method_name, args, handler)
+        implementation_strategy.call(definition, method_name, args, handler)
+        double_injection_strategy.call(definition, method_name, args, handler)
+        definition
+      end
+
+      def root_subject
+        subject
+      end
+
+      def method_name
+        @verification_strategy.method_name
+      end
+
+      module StrategySetupMethods
+        def no_subject?
+          subject.__id__ === NO_SUBJECT.__id__
+        end
+
+        protected
+        def add_verification_strategy(verification_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+          add_strategy(subject, method_name, definition_eval_block) do
+            self.verification_strategy = verification_strategy_class.new(self)
+          end
+        end
+
+        def add_implementation_strategy(implementation_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+          add_strategy(subject, method_name, definition_eval_block) do
+            self.implementation_strategy = implementation_strategy_class.new(self)
+          end
+        end
+
+        def add_double_injection_strategy(double_injection_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+          add_strategy(subject, method_name, definition_eval_block) do
+            self.double_injection_strategy = double_injection_strategy_class.new(self)
+          end
+        end
+
+        def add_strategy(subject, method_name, definition_eval_block)
+          if method_name && definition_eval_block
+            raise ArgumentError, "Cannot pass in a method name and a block"
+          end
+          @subject = subject
+          yield
+          # TODO: Allow hash argument to simulate a Struct.
+          if no_subject?
+            self
+          elsif method_name
+            # TODO: Pass in arguments.
+            call(method_name)
+          else
+            DoubleDefinitionCreateBlankSlate.new(self, &definition_eval_block)
+          end
+        end
+
+        def verification_strategy=(verification_strategy)
+          @verification_strategy = verification_strategy
+          verification_strategy
+        end
+
+        def implementation_strategy=(implementation_strategy)
+          @implementation_strategy = implementation_strategy
+        end
+
+        def double_injection_strategy=(double_injection_strategy)
+          @double_injection_strategy = double_injection_strategy
+        end
+      end
+      include StrategySetupMethods
+
+      class DoubleDefinitionCreateError < Errors::RRError
+      end
+
+      # Verification Strategies
+      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
+      def mock(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::Mock, subject, method_name, &definition_eval_block)
+      end
+
+      def stub(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::Stub, subject, method_name, &definition_eval_block)
+      end
+
+      def dont_allow(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::DontAllow, subject, method_name, &definition_eval_block)
+      end
+
+      # Implementation Strategies
+      def proxy(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_implementation_strategy(::RR::DoubleDefinitions::Strategies::Implementation::Proxy, subject, method_name, &definition_eval_block)
+      end
+
+      def strong(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_implementation_strategy(::RR::DoubleDefinitions::Strategies::Implementation::StronglyTypedReimplementation, subject, method_name, &definition_eval_block)
+      end
+
+      # DoubleInjection Strategies
+      def instance_of(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::AnyInstanceOf, subject, method_name, &definition_eval_block)
+      end
+      alias_method :any_instance_of, :instance_of
+      alias_method :all_instances_of, :instance_of
+    end
+  end
+end

data/lib/rr/double_definitions/double_definition_create_blank_slate.rb

@@ -0,0 +1,26 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinitionCreateBlankSlate
+      def initialize(double_definition_create, &block) #:nodoc:
+        @double_definition_create = double_definition_create
+        BlankSlate.call(respond_to?(:class) ? self.class : __blank_slated_class)
+
+        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)
+        @double_definition_create.call(method_name, *args, &block)
+      end
+
+      def __double_definition_create__
+        @double_definition_create
+      end
+    end    
+  end
+end

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/strategies/double_injection/any_instance_of.rb

@@ -0,0 +1,30 @@
+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
+            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/implementation/implementation_strategy.rb

@@ -0,0 +1,10 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class ImplementationStrategy < Strategy
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+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
+          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,15 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class StronglyTypedReimplementation < Reimplementation
+          protected
+          def do_call
+            super
+            definition.verify_method_signature
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      class Strategy
+        attr_reader :double_definition_create, :definition, :method_name, :args, :handler
+        include Space::Reader
+
+        def initialize(double_definition_create)
+          @double_definition_create = double_definition_create
+        end
+        
+        def call(definition, method_name, args, handler)
+          @definition, @method_name, @args, @handler = definition, method_name, args, handler
+          do_call
+        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/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