rr 1.1.1 → 3.0.0

data/lib/rr/double_definitions/double_definition_create.rb

@@ -30,11 +30,11 @@ module RR
         @double_injection_strategy = self.class.default_double_injection_strategy.call(self)
       end
 
-      def call(method_name, *args, &handler)
+      def call(method_name, args, kwargs, &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)
+        verification_strategy.call(definition, method_name, args, kwargs, handler)
+        implementation_strategy.call(definition, method_name, args, kwargs, handler)
+        double_injection_strategy.call(definition, method_name, args, kwargs, handler)
         definition
       end
 
@@ -81,7 +81,7 @@ module RR
             self
           elsif method_name
             # TODO: Pass in arguments.
-            call(method_name)
+            call(method_name, [], {})
           else
             DoubleDefinitionCreateBlankSlate.new(self, &definition_eval_block)
           end

data/lib/rr/double_definitions/double_definition_create_blank_slate.rb

@@ -14,13 +14,19 @@ module RR
         end
       end
 
-      def method_missing(method_name, *args, &block)
-        @double_definition_create.call(method_name, *args, &block)
+      if KeywordArguments.fully_supported?
+        def method_missing(method_name, *args, **kwargs, &block)
+          @double_definition_create.call(method_name, args, kwargs, &block)
+        end
+      else
+        def method_missing(method_name, *args, &block)
+          @double_definition_create.call(method_name, args, {}, &block)
+        end
       end
 
       def __double_definition_create__
         @double_definition_create
       end
-    end    
+    end
   end
-end
+end

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

@@ -3,7 +3,7 @@ module RR
     module DoubleInjections
       class AnyInstanceOf
         extend(Module.new do
-          include RR::Adapters::RRMethods
+          include RR::DSL
 
           def call(subject_class, stubbed_methods=nil, &block)
             strategy_lambda = lambda do |double_definition_create|

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

@@ -3,7 +3,7 @@ module RR
     module DoubleInjections
       class Instance
         extend(Module.new do
-          include ::RR::Adapters::RRMethods
+          include ::RR::DSL
 
           def call(double_method_name, *args, &definition_eval_block)
             double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
@@ -13,4 +13,4 @@ module RR
       end
     end
   end
-end
+end

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

@@ -2,7 +2,12 @@ module RR
   module DoubleDefinitions
     module Strategies
       class Strategy
-        attr_reader :double_definition_create, :definition, :method_name, :args, :handler
+        attr_reader :double_definition_create
+        attr_reader :definition
+        attr_reader :method_name
+        attr_reader :args
+        attr_reader :kwargs
+        attr_reader :handler
 
         include Space::Reader
 
@@ -10,8 +15,12 @@ module RR
           @double_definition_create = double_definition_create
         end
 
-        def call(definition, method_name, args, handler)
-          @definition, @method_name, @args, @handler = definition, method_name, args, handler
+        def call(definition, method_name, args, kwargs, handler)
+          @definition = definition
+          @method_name = method_name
+          @args = args
+          @kwargs = kwargs
+          @handler = handler
           do_call
         end
 
@@ -23,11 +32,21 @@ module RR
           raise NotImplementedError
         end
 
-        def permissive_argument
-          if args.empty?
-            definition.with_any_args
-          else
-            definition.with(*args)
+        if KeywordArguments.fully_supported?
+          def permissive_argument
+            if args.empty? and kwargs.empty?
+              definition.with_any_args
+            else
+              definition.with(*args, **kwargs)
+            end
+          end
+        else
+          def permissive_argument
+            if args.empty?
+              definition.with_any_args
+            else
+              definition.with(*args)
+            end
           end
         end
 

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

@@ -32,8 +32,14 @@ module RR
         #   end
         class Mock < VerificationStrategy
           protected
-          def do_call
-            definition.with(*args).once
+          if KeywordArguments.fully_supported?
+            def do_call
+              definition.with(*args, **kwargs).once
+            end
+          else
+            def do_call
+              definition.with(*args).once
+            end
           end
         end
       end

data/lib/rr/double_matches.rb

@@ -15,9 +15,10 @@ module RR
       @wildcard_non_terminal_doubles_to_attempt = []
     end
 
-    def find_all_matches(args)
+    def find_all_matches(args, kwargs)
+      kwargs ||= {}
       @doubles.each do |double|
-        if double.exact_match?(*args)
+        if double.exact_match?(args, kwargs)
           matching_doubles << double
           if double.attempt?
             if double.terminal?
@@ -26,7 +27,7 @@ module RR
               exact_non_terminal_doubles_to_attempt << double
             end
           end
-        elsif double.wildcard_match?(*args)
+        elsif double.wildcard_match?(args, kwargs)
           matching_doubles << double
           if double.attempt?
             if double.terminal?

data/lib/rr/dsl.rb

@@ -0,0 +1,152 @@
+module RR
+  module DSL
+    METHODS_TO_EXCLUDE_FROM_SPYING = [
+      :methods,
+      :==,
+      :__send__,
+      :__id__,
+      :object_id,
+      :class,
+      :respond_to?,
+      :inspect,
+      :to_s,
+      :respond_to_missing?,
+      :instance_eval,
+      :instance_exec
+    ]
+
+    include DoubleDefinitions::Strategies::StrategyMethods
+
+    def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.mock(subject, method_name, &definition_eval_block)
+    end
+
+    def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.stub(subject, method_name, &definition_eval_block)
+    end
+
+    def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.dont_allow(subject, method_name, &definition_eval_block)
+    end
+
+    def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.proxy(subject, method_name, &definition_eval_block)
+    end
+
+    def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.strong(subject, method_name, &definition_eval_block)
+    end
+
+    def instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.instance_of(subject, method_name, &definition_eval_block)
+    end
+
+    def any_instance_of(*args, &block)
+      RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
+    end
+
+    # Verifies all the DoubleInjection objects have met their
+    # TimesCalledExpectations.
+    def verify
+      RR::Space.instance.verify_doubles
+    end
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      RR::Space.instance.reset
+    end
+
+    # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
+    # to Double#times.
+    #
+    #   mock(object).method_name(anything).times(any_times) {return_value}
+    def any_times
+      TimesCalledMatchers::AnyTimesMatcher.new
+    end
+
+    # Sets up an Anything wildcard ArgumentEqualityExpectation
+    # that succeeds when passed any argument.
+    #   mock(object).method_name(anything) {return_value}
+    #   object.method_name("an arbitrary value") # passes
+    def anything
+      RR::WildcardMatchers::Anything.new
+    end
+
+    # Sets up an IsA wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument of a certain type.
+    #   mock(object).method_name(is_a(String)) {return_value}
+    #   object.method_name("A String") # passes
+    def is_a(klass)
+      RR::WildcardMatchers::IsA.new(klass)
+    end
+
+    # Sets up an Numeric wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is ::Numeric.
+    #   mock(object).method_name(numeric) {return_value}
+    #   object.method_name(99) # passes
+    def numeric
+      RR::WildcardMatchers::Numeric.new
+    end
+
+    # Sets up an Boolean wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is a ::Boolean.
+    #   mock(object).method_name(boolean) {return_value}
+    #   object.method_name(false) # passes
+    def boolean
+      RR::WildcardMatchers::Boolean.new
+    end
+
+    # Sets up a DuckType wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument implements the methods.
+    #   arg = Object.new
+    #   def arg.foo; end
+    #   def arg.bar; end
+    #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
+    #   object.method_name(arg) # passes
+    def duck_type(*args)
+      RR::WildcardMatchers::DuckType.new(*args)
+    end
+
+    # Sets up a HashIncluding wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument contains at least those keys
+    # and values of the expectation.
+    #   mock(object).method_name(hash_including(:foo => 1)) {return_value}
+    #   object.method_name({:foo => 1, :bar => 2) # passes
+    def hash_including(expected_hash)
+      RR::WildcardMatchers::HashIncluding.new(expected_hash)
+    end
+
+    # Sets up a Satisfy wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument causes the expectation's
+    # proc to return true.
+    #   mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
+    #   object.method_name(:foo) # passes
+    def satisfy(expectation_proc=nil, &block)
+      expectation_proc ||= block
+      RR::WildcardMatchers::Satisfy.new(expectation_proc)
+    end
+
+    def spy(subject)
+      subject_methods = subject.public_methods.map {|method_name| method_name.to_sym }
+      methods_to_stub = subject_methods - METHODS_TO_EXCLUDE_FROM_SPYING
+
+      methods_to_stub.each do |method|
+        stub.proxy(subject, method)
+      end
+    end
+
+    def received(subject)
+      RR::SpyVerificationProxy.new(subject)
+    end
+
+    instance_methods.each do |name|
+      alias_method "rr_#{name}", name
+    end
+  end
+end

data/lib/rr/expectations/any_argument_expectation.rb

@@ -2,14 +2,14 @@ module RR
   module Expectations
     class AnyArgumentExpectation < ArgumentEqualityExpectation #:nodoc:
       def initialize
-        super
+        super([], {})
       end
 
-      def exact_match?(*arguments)
+      def exact_match?(arguments, keyword_arguments)
         false
       end
 
-      def wildcard_match?(*arguments)
+      def wildcard_match?(arguments, keyword_arguments)
         true
       end
 
@@ -18,4 +18,4 @@ module RR
       end
     end
   end
-end
+end

data/lib/rr/expectations/argument_equality_expectation.rb

@@ -10,20 +10,37 @@ module RR
       end
 
       attr_reader :expected_arguments
+      attr_reader :expected_keyword_arguments
 
-      def initialize(*expected_arguments)
+      def initialize(expected_arguments,
+                     expected_keyword_arguments)
         @expected_arguments = expected_arguments
+        @expected_keyword_arguments = expected_keyword_arguments
       end
 
-      def exact_match?(*arguments)
+      def exact_match?(arguments, keyword_arguments)
         return false unless arguments.length == expected_arguments.length
         arguments.each_with_index do |arg, index|
-          return false unless self.class.recursive_safe_eq(expected_arguments[index], arg)
+          expected_arg = expected_arguments[index]
+          return false unless self.class.recursive_safe_eq(expected_arg, arg)
+        end
+        keywords = keyword_arguments.keys
+        expected_keywords = expected_keyword_arguments.keys
+        unless keywords.length == expected_keywords.length
+          return false
+        end
+        keywords.each do |keyword|
+          keyword_argument = keyword_arguments[keyword]
+          expected_keyword_argument = expected_keyword_arguments[keyword]
+          unless self.class.recursive_safe_eq(expected_keyword_argument,
+                                              keyword_argument)
+            return false
+          end
         end
         true
       end
 
-      def wildcard_match?(*arguments)
+      def wildcard_match?(arguments, keyword_arguments)
         return false unless arguments.length == expected_arguments.length
         arguments.each_with_index do |arg, index|
           expected_argument = expected_arguments[index]
@@ -33,11 +50,32 @@ module RR
             return false unless self.class.recursive_safe_eq(expected_argument, arg)
           end
         end
+        keywords = keyword_arguments.keys
+        expected_keywords = expected_keyword_arguments.keys
+        unless keywords.length == expected_keywords.length
+          return false
+        end
+        keywords.each do |keyword|
+          keyword_argument = keyword_arguments[keyword]
+          expected_keyword_argument = expected_keyword_arguments[keyword]
+          if expected_keyword_argument.respond_to?(:wildcard_match?)
+            unless expected_keyword_argument.wildcard_match?(keyword_argument)
+              return false
+            end
+          else
+            unless self.class.recursive_safe_eq(expected_keyword_argument,
+                                                keyword_argument)
+              return false
+            end
+          end
+        end
         true
       end
 
       def ==(other)
-        expected_arguments == other.expected_arguments
+        other.is_a?(self.class) and
+          expected_arguments == other.expected_arguments and
+          expected_keyword_arguments == other.expected_keyword_arguments
       end
     end
   end

data/lib/rr/injections/double_injection.rb

@@ -31,15 +31,20 @@ module RR
           exists?((class << subject; self; end), method_name)
         end
 
-        def dispatch_method(subject, subject_class, method_name, arguments, block)
+        def dispatch_method(subject,
+                            subject_class,
+                            method_name,
+                            arguments,
+                            keyword_arguments,
+                            block)
           subject_eigenclass = (class << subject; self; end)
           if (
             exists?(subject_class, method_name) &&
-            (subject_class == subject_eigenclass) || !subject.is_a?(Class)
+            ((subject_class == subject_eigenclass) || !subject.is_a?(Class))
           )
-            find(subject_class, method_name.to_sym).dispatch_method(subject, arguments, block)
+            find(subject_class, method_name.to_sym).dispatch_method(subject, arguments, keyword_arguments, block)
           else
-            new(subject_class, method_name.to_sym).dispatch_original_method(subject, arguments, block)
+            new(subject_class, method_name.to_sym).dispatch_original_method(subject, arguments, keyword_arguments, block)
           end
         end
 
@@ -91,7 +96,9 @@ module RR
 
       attr_reader :subject_class, :method_name, :doubles
 
-      MethodArguments = Struct.new(:arguments, :block)
+      MethodArguments = Struct.new(:arguments,
+                                   :keyword_arguments,
+                                   :block)
 
       def initialize(subject_class, method_name)
         @subject_class = subject_class
@@ -111,7 +118,11 @@ module RR
       # is called.
       def bind
         if subject_has_method_defined?(method_name)
-          bind_method_with_alias
+          if subject_has_original_method?
+            bind_method
+          else
+            bind_method_with_alias
+          end
         else
           Injections::MethodMissingInjection.find_or_create(subject_class)
           Injections::SingletonMethodAddedInjection.find_or_create(subject_class)
@@ -141,13 +152,37 @@ module RR
         id = BoundObjects.size
         BoundObjects[id] = subject_class
 
-        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{method_name}(*args, &block)
-            arguments = MethodArguments.new(args, block)
-            obj = ::RR::Injections::DoubleInjection::BoundObjects[#{id}]
-            ::RR::Injections::DoubleInjection.dispatch_method(self, obj, :#{method_name}, arguments.arguments, arguments.block)
-          end
-        RUBY
+        if KeywordArguments.fully_supported?
+          subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{method_name}(*args, **kwargs, &block)
+              arguments = MethodArguments.new(args, kwargs, block)
+              obj = ::RR::Injections::DoubleInjection::BoundObjects[#{id}]
+              ::RR::Injections::DoubleInjection.dispatch_method(
+                self,
+                obj,
+                :#{method_name},
+                arguments.arguments,
+                arguments.keyword_arguments,
+                arguments.block
+              )
+            end
+          RUBY
+        else
+          subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{method_name}(*args, &block)
+              arguments = MethodArguments.new(args, {}, block)
+              obj = ::RR::Injections::DoubleInjection::BoundObjects[#{id}]
+              ::RR::Injections::DoubleInjection.dispatch_method(
+                self,
+                obj,
+                :#{method_name},
+                arguments.arguments,
+                arguments.keyword_arguments,
+                arguments.block
+              )
+            end
+          RUBY
+        end
         self
       end
 
@@ -175,17 +210,29 @@ module RR
         end
       end
 
-      def dispatch_method(subject, args, block)
+      def dispatch_method(subject, args, kwargs, block)
         if @dispatch_method_delegates_to_dispatch_original_method
-          dispatch_original_method(subject, args, block)
+          dispatch_original_method(subject, args, kwargs, block)
         else
-          dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
+          dispatch = MethodDispatches::MethodDispatch.new(
+            self,
+            subject,
+            args,
+            kwargs,
+            block
+          )
           dispatch.call
         end
       end
 
-      def dispatch_original_method(subject, args, block)
-        dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
+      def dispatch_original_method(subject, args, kwargs, block)
+        dispatch = MethodDispatches::MethodDispatch.new(
+          self,
+          subject,
+          args,
+          kwargs,
+          block
+        )
         dispatch.call_original_method
       end
 
@@ -206,7 +253,8 @@ module RR
 
     protected
       def deferred_bind_method
-        unless subject_has_method_defined?(original_method_alias_name)
+        if respond_to?(method_name) and
+            not subject_has_method_defined?(original_method_alias_name)
           bind_method_with_alias
         end
         @performed_deferred_bind = true