rr 0.4.10 → 0.6.0

data/lib/rr/double.rb

@@ -19,7 +19,7 @@ module RR
     attr_reader :times_called, :double_injection, :definition
     include Space::Reader
 
-    def initialize(double_injection, definition = DoubleDefinition.new)
+    def initialize(double_injection, definition)
       @double_injection = double_injection
       @definition = definition
       @times_called = 0
@@ -212,20 +212,6 @@ module RR
       definition.implemented_by implementation
     end
 
-    # Double#proxy sets the implementation
-    # of the Double to be the original method.
-    # This is primarily used with proxy.
-    #
-    #   obj = Object.new
-    #   def obj.foobar
-    #     yield(1)
-    #   end
-    #   mock(obj).method_name.proxy
-    #   obj.foobar {|arg| puts arg} # puts 1
-    def proxy
-      definition.proxy
-    end
-
     # Double#call calls the Double's implementation. The return
     # value of the implementation is returned.
     #
@@ -235,46 +221,27 @@ module RR
       if verbose?
         puts Double.formatted_name(double_injection.method_name, args)
       end
-      self.times_called_expectation.attempt if definition.times_matcher
+      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)
-      return return_value unless definition.after_call_value
-      definition.after_call_value.call(return_value)
+      definition.after_call_proc ? extract_subject_from_return_value(definition.after_call_proc.call(return_value)) : return_value
     end
 
     def yields!(block)
       if definition.yields_value
-        unless block
+        if block
+          block.call(*definition.yields_value)
+        else
           raise ArgumentError, "A Block must be passed into the method call when using yields"
         end
-        block.call(*definition.yields_value)
       end
     end
     protected :yields!
 
     def call_implementation(double_injection, *args, &block)
-      return nil unless implementation
-
-      if implementation === DoubleDefinition::ORIGINAL_METHOD
-        if double_injection.object_has_original_method?
-          return double_injection.call_original_method(*args, &block)
-        else
-          return double_injection.object.__send__(
-            :method_missing,
-            method_name,
-            *args,
-            &block
-          )
-        end
-      end
-
-      if implementation.is_a?(Method)
-        return implementation.call(*args, &block)
-      else
-        args << block if block
-        return implementation.call(*args)
-      end
+      return_value = do_call_implementation_and_get_return_value(double_injection, *args, &block)
+      extract_subject_from_return_value(return_value)
     end
     protected :call_implementation
 
@@ -351,5 +318,43 @@ module RR
     def formatted_name
       self.class.formatted_name(method_name, expected_arguments)
     end
+
+    protected
+    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 << 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.subject
+      when DoubleDefinitions::DoubleDefinitionCreatorProxy
+        return_value.__creator__.subject
+      else
+        return_value
+      end
+    end
   end
 end

data/lib/rr/double_definitions/child_double_definition_creator.rb

@@ -0,0 +1,23 @@
+module RR
+  module DoubleDefinitions
+    class ChildDoubleDefinitionCreator < DoubleDefinitionCreator # :nodoc
+      attr_reader :parent_double_definition
+      def initialize(parent_double_definition)
+        @parent_double_definition = parent_double_definition
+        super()
+      end
+
+      def instance_of(*args)
+        raise NoMethodError
+      end
+
+      protected
+      def add_strategy(subject, method_name, definition_eval_block, &block)
+        super do
+          block.call
+          parent_double_definition.implemented_by(lambda {subject})
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/double_definition.rb

@@ -0,0 +1,212 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinition #:nodoc:
+      class << self
+        def register_strategy_class(strategy_class, method_name)
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}(subject=DoubleDefinitionCreator::NO_SUBJECT, method_name=nil, &definition_eval_block)
+            ChildDoubleDefinitionCreator.new(self).#{method_name}(subject, method_name, &definition_eval_block)
+          end
+          CLASS
+
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}!(method_name=nil, &definition_eval_block)
+            ChildDoubleDefinitionCreator.new(self).#{method_name}!(method_name, &definition_eval_block)
+          end
+          CLASS
+        end
+      end
+
+      ORIGINAL_METHOD = Object.new
+      attr_accessor(
+        :argument_expectation,
+        :times_matcher,
+        :implementation,
+        :after_call_proc,
+        :yields_value,
+        :double,
+        :double_definition_creator,
+        :subject
+      )
+
+      include Space::Reader
+
+      def initialize(double_definition_creator, subject)
+        @implementation = nil
+        @argument_expectation = nil
+        @times_matcher = nil
+        @after_call_proc = nil
+        @yields_value = nil
+        @double_definition_creator = double_definition_creator
+        @subject = subject
+      end
+
+      module DefinitionConstructionMethods
+        def with(*args, &return_value_block)
+          @argument_expectation = Expectations::ArgumentEqualityExpectation.new(*args)
+          install_method_callback return_value_block
+          self
+        end
+
+        def with_any_args(&return_value_block)
+          @argument_expectation = Expectations::AnyArgumentExpectation.new
+          install_method_callback return_value_block
+          self
+        end
+
+        def with_no_args(&return_value_block)
+          @argument_expectation = Expectations::ArgumentEqualityExpectation.new()
+          install_method_callback return_value_block
+          self
+        end
+
+        def never
+          @times_matcher = TimesCalledMatchers::IntegerMatcher.new(0)
+          self
+        end
+
+        def once(&return_value_block)
+          @times_matcher = TimesCalledMatchers::IntegerMatcher.new(1)
+          install_method_callback return_value_block
+          self
+        end
+
+        def twice(&return_value_block)
+          @times_matcher = TimesCalledMatchers::IntegerMatcher.new(2)
+          install_method_callback return_value_block
+          self
+        end
+
+        def at_least(number, &return_value_block)
+          @times_matcher = TimesCalledMatchers::AtLeastMatcher.new(number)
+          install_method_callback return_value_block
+          self
+        end
+
+        def at_most(number, &return_value_block)
+          @times_matcher = TimesCalledMatchers::AtMostMatcher.new(number)
+          install_method_callback return_value_block
+          self
+        end
+
+        def any_number_of_times(&return_value_block)
+          @times_matcher = TimesCalledMatchers::AnyTimesMatcher.new
+          install_method_callback return_value_block
+          self
+        end
+
+        def times(matcher_value, &return_value_block)
+          @times_matcher = TimesCalledMatchers::TimesCalledMatcher.create(matcher_value)
+          install_method_callback return_value_block
+          self
+        end
+
+        def ordered(&return_value_block)
+          raise(
+            Errors::DoubleDefinitionError,
+            "Double Definitions must have a dedicated Double to be ordered. " <<
+            "For example, using instance_of does not allow ordered to be used. " <<
+            "proxy the class's #new method instead."
+          ) unless @double
+          @ordered = true
+          space.register_ordered_double(@double)
+          install_method_callback return_value_block
+          DoubleDefinitionCreatorProxy.new(double_definition_creator)
+        end
+        alias_method :then, :ordered
+
+        def yields(*args, &return_value_block)
+          @yields_value = args
+          install_method_callback return_value_block
+          self
+        end
+
+        def after_call(&after_call_proc)
+          raise ArgumentError, "after_call expects a block" unless after_call_proc
+          @after_call_proc = after_call_proc
+          self
+        end
+
+        def verbose(&after_call_proc)
+          @verbose = true
+          @after_call_proc = after_call_proc
+          self
+        end
+
+        def returns(*args, &implementation)
+          value = args.first
+          if !args.empty? && implementation
+            raise ArgumentError, "returns cannot accept both an argument and a block"
+          end
+          if implementation
+            implemented_by implementation
+          else
+            implemented_by lambda {value}
+          end
+          self
+        end
+
+        def implemented_by_original_method
+          implemented_by ORIGINAL_METHOD
+          self
+        end
+
+        def implemented_by(implementation)
+          @implementation = implementation
+          self
+        end
+
+        protected
+        def install_method_callback(block)
+          return unless block
+          if implementation_is_original_method?
+            after_call(&block)
+          else
+            returns(&block)
+          end
+        end
+      end
+      include DefinitionConstructionMethods
+
+      module StateQueryMethods
+        def ordered?
+          @ordered
+        end
+
+        def verbose?
+          @verbose ? true : false
+        end
+
+        def exact_match?(*arguments)
+          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @argument_expectation
+          @argument_expectation.exact_match?(*arguments)
+        end
+
+        def wildcard_match?(*arguments)
+          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @argument_expectation
+          @argument_expectation.wildcard_match?(*arguments)
+        end
+
+        def terminal?
+          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @times_matcher
+          @times_matcher.terminal?
+        end
+
+        def expected_arguments
+          return [] unless argument_expectation
+          argument_expectation.expected_arguments
+        end
+
+        def implementation_is_original_method?
+          implementation_strategy.is_a?(Strategies::Implementation::Proxy)
+        end
+
+        protected
+        def implementation_strategy
+          double_definition_creator.implementation_strategy
+        end
+      end
+      include StateQueryMethods
+    end
+  end
+end

data/lib/rr/double_definitions/double_definition_creator.rb

@@ -0,0 +1,153 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinitionCreator # :nodoc
+      class << self
+        def register_verification_strategy_class(strategy_class, method_name)
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+            add_strategy(subject, method_name, definition_eval_block) do
+              self.verification_strategy = #{strategy_class.name}.new(self)
+            end
+          end
+          CLASS
+
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}!(method_name=nil, &definition_eval_block)
+            #{method_name}(Object.new, method_name, &definition_eval_block)
+          end
+          CLASS
+        end
+
+        def register_implementation_strategy_class(strategy_class, method_name)
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+            add_strategy(subject, method_name, definition_eval_block) do
+              self.implementation_strategy = #{strategy_class.name}.new(self)
+            end
+          end
+          CLASS
+
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}!(method_name=nil, &definition_eval_block)
+            #{method_name}(Object.new, method_name, &definition_eval_block)
+          end
+          CLASS
+        end
+
+        def register_scope_strategy_class(strategy_class, method_name)
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+            add_strategy(subject, method_name, definition_eval_block) do
+              self.scope_strategy = #{strategy_class.name}.new(self)
+            end
+          end
+          CLASS
+
+          class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
+          def #{method_name}!(method_name=nil, &definition_eval_block)
+            #{method_name}(Object.new, method_name, &definition_eval_block)
+          end
+          CLASS
+        end
+      end
+
+      attr_reader :subject, :method_name, :args, :handler, :definition, :verification_strategy, :implementation_strategy, :scope_strategy
+      NO_SUBJECT = Object.new
+
+      include Space::Reader
+
+      def initialize
+        @verification_strategy = nil
+        @implementation_strategy = Strategies::Implementation::Reimplementation.new(self)
+        @scope_strategy = Strategies::Scope::Instance.new(self)
+      end
+
+      module StrategySetupMethods
+        def no_subject?
+          subject.__id__ === NO_SUBJECT.__id__
+        end
+
+        protected
+        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
+          if no_subject?
+            self
+          elsif method_name
+            create(method_name)
+          else
+            DoubleDefinitionCreatorProxy.new(self, &definition_eval_block)
+          end
+        end
+
+        def verification_strategy=(verification_strategy)
+          verify_no_verification_strategy
+          verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
+          @verification_strategy = verification_strategy
+          verification_strategy
+        end
+
+        def implementation_strategy=(implementation_strategy)
+          verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
+          @implementation_strategy = implementation_strategy
+        end
+
+        def scope_strategy=(scope_strategy)
+          verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
+          @scope_strategy = scope_strategy
+        end
+
+        def verify_no_verification_strategy
+          strategy_already_defined_error if verification_strategy
+        end
+
+        def strategy_already_defined_error
+          raise(
+            Errors::DoubleDefinitionError,
+            "This Double already has a #{verification_strategy.name} strategy"
+          )
+        end
+
+        def verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
+          proxy_when_dont_allow_error if
+            verification_strategy.is_a?(Strategies::Verification::DontAllow) &&
+            implementation_strategy.is_a?(Strategies::Implementation::Proxy)
+        end
+
+        def proxy_when_dont_allow_error
+          raise(
+            Errors::DoubleDefinitionError,
+            "Doubles cannot be proxied when using dont_allow strategy"
+          )
+        end
+
+        def no_strategy_error
+          raise(
+            Errors::DoubleDefinitionError,
+            "This Double has no strategy"
+          )
+        end
+      end
+      include StrategySetupMethods
+
+      module StrategyExecutionMethods
+        def create(method_name, *args, &handler)
+          raise DoubleDefinitionCreatorError if no_subject?
+          @method_name, @args, @handler = method_name, args, handler
+          @definition = DoubleDefinition.new(self, subject)
+          verification_strategy ? verification_strategy.call(definition, method_name, args, handler) : no_strategy_error
+          implementation_strategy.call(definition, method_name, args, handler)
+          scope_strategy.call(definition, method_name, args, handler)
+          definition
+        end
+      end
+      include StrategyExecutionMethods
+
+      class DoubleDefinitionCreatorError < Errors::RRError
+      end
+    end
+  end
+end