rr 1.2.1 → 3.0.0

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/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
 

data/lib/rr/injections/method_missing_injection.rb

@@ -71,16 +71,43 @@ module RR
         id = BoundObjects.size
         BoundObjects[id] = subject_class
 
-        subject_class.class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
-          def method_missing(method_name, *args, &block)
-            if respond_to_missing?(method_name, true)
-              super
-            else
-              obj = ::RR::Injections::MethodMissingInjection::BoundObjects[#{id}]
-              MethodDispatches::MethodMissingDispatch.new(self, obj, method_name, args, block).call
+        if KeywordArguments.fully_supported?
+          subject_class.class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
+            def method_missing(method_name, *args, **kwargs, &block)
+              if respond_to_missing?(method_name, true)
+                super(method_name, *args, **kwargs, &block)
+              else
+                obj = ::RR::Injections::MethodMissingInjection::BoundObjects[#{id}]
+                MethodDispatches::MethodMissingDispatch.new(
+                  self,
+                  obj,
+                  method_name,
+                  args,
+                  kwargs,
+                  block
+                ).call
+              end
             end
-          end
-        METHOD
+          METHOD
+        else
+          subject_class.class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
+            def method_missing(method_name, *args, &block)
+              if respond_to_missing?(method_name, true)
+                super(method_name, *args, &block)
+              else
+                obj = ::RR::Injections::MethodMissingInjection::BoundObjects[#{id}]
+                MethodDispatches::MethodMissingDispatch.new(
+                  self,
+                  obj,
+                  method_name,
+                  args,
+                  {},
+                  block
+                ).call
+              end
+            end
+          METHOD
+        end
       end
 
       def original_method_alias_name

data/lib/rr/keyword_arguments.rb

@@ -0,0 +1,15 @@
+module RR
+  module KeywordArguments
+    class << self
+      if (RUBY_VERSION <=> "3.0.0") >= 0
+        def fully_supported?
+          true
+        end
+      else
+        def fully_supported?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -4,7 +4,7 @@ module RR
       extend Forwardable
       include Space::Reader
 
-      attr_reader :args, :block, :double
+      attr_reader :args, :kwargs, :block, :double
 
       def call
         raise NotImplementedError
@@ -12,7 +12,7 @@ module RR
 
     protected
       def find_double_to_attempt
-        matches = DoubleMatches.new(doubles).find_all_matches(args)
+        matches = DoubleMatches.new(doubles).find_all_matches(args, kwargs)
 
         unless matches.exact_terminal_doubles_to_attempt.empty?
           return matches.exact_terminal_doubles_to_attempt.first
@@ -47,8 +47,25 @@ module RR
         end
       end
 
-      def call_original_method_missing
-        subject.__send__(MethodMissingDispatch.original_method_missing_alias_name, method_name, *args, &block)
+      if KeywordArguments.fully_supported?
+        def call_original_method_missing
+          subject.__send__(
+            MethodMissingDispatch.original_method_missing_alias_name,
+            method_name,
+            *args,
+            **kwargs,
+            &block
+          )
+        end
+      else
+        def call_original_method_missing
+          subject.__send__(
+            MethodMissingDispatch.original_method_missing_alias_name,
+            method_name,
+            *args,
+            &block
+          )
+        end
       end
 
       def implementation_is_original_method?
@@ -70,7 +87,7 @@ module RR
         message =
           "On subject #{subject},\n" <<
           "unexpected method invocation:\n" <<
-          "  #{Double.formatted_name(method_name, args)}\n" <<
+          "  #{Double.formatted_name(method_name, args, kwargs)}\n" <<
           "expected invocations:\n" <<
           Double.list_message_part(doubles)
         raise RR::Errors.build_error(:DoubleNotFoundError, message)

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -3,15 +3,19 @@ module RR
     class MethodDispatch < BaseMethodDispatch
       attr_reader :double_injection, :subject
 
-      def initialize(double_injection, subject, args, block)
-        @double_injection, @subject, @args, @block = double_injection, subject, args, block
+      def initialize(double_injection, subject, args, kwargs, block)
+        @double_injection = double_injection
+        @subject = subject
+        @args = args
+        @kwargs = kwargs
+        @block = block
         @double = find_double_to_attempt
       end
 
       def call
-        space.record_call(subject, method_name, args, block)
+        space.record_call(subject, method_name, args, kwargs, block)
         if double
-          double.method_call(args)
+          double.method_call(args, kwargs)
           call_yields
           return_value_1 = call_implementation
           return_value_2 = extract_subject_from_return_value(return_value_1)
@@ -27,11 +31,19 @@ module RR
 
       def call_original_method
         if subject_has_original_method?
-          subject.__send__(original_method_alias_name, *args, &block)
+          if KeywordArguments.fully_supported?
+            subject.__send__(original_method_alias_name, *args, **kwargs, &block)
+          else
+            subject.__send__(original_method_alias_name, *args, &block)
+          end
         elsif subject_has_original_method_missing?
           call_original_method_missing
         else
-          subject.__send__(:method_missing, method_name, *args, &block)
+          if KeywordArguments.fully_supported?
+            subject.__send__(:method_missing, method_name, *args, **kwargs, &block)
+          else
+            subject.__send__(:method_missing, method_name, *args, &block)
+          end
         end
       end
 
@@ -41,11 +53,10 @@ module RR
           call_original_method
         else
           if implementation
-            if implementation.is_a?(Method)
-              implementation.call(*args, &block)
+            if KeywordArguments.fully_supported?
+              implementation.call(*args, **kwargs, &block)
             else
-              call_args = block ? args + [ProcFromBlock.new(&block)] : args
-              implementation.call(*call_args)
+              implementation.call(*args, &block)
             end
           else
             nil

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -9,8 +9,13 @@ module RR
 
       attr_reader :subject, :subject_class, :method_name
 
-      def initialize(subject, subject_class, method_name, args, block)
-        @subject, @subject_class, @method_name, @args, @block = subject, subject_class, method_name, args, block
+      def initialize(subject, subject_class, method_name, args, kwargs, block)
+        @subject = subject
+        @subject_class = subject_class
+        @method_name = method_name
+        @args = args
+        @kwargs = kwargs
+        @block = block
       end
 
       def call
@@ -40,14 +45,18 @@ module RR
     protected
       def call_implementation
         if implementation_is_original_method?
-          space.record_call(subject, method_name, args, block)
-          double.method_call(args)
+          space.record_call(subject, method_name, args, kwargs, block)
+          double.method_call(args, kwargs)
           call_original_method
         else
           if double_injection = Injections::DoubleInjection.find(subject_class, method_name)
             double_injection.bind_method
             # The DoubleInjection takes care of calling double.method_call
-            subject.__send__(method_name, *args, &block)
+            if KeywordArguments.fully_supported?
+              subject.__send__(method_name, *args, **kwargs, &block)
+            else
+              subject.__send__(method_name, *args, &block)
+            end
           else
             nil
           end