rr 1.1.2.rc1 → 3.0.1

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

data/lib/rr/injections/method_missing_injection.rb

@@ -71,12 +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)
-            obj = ::RR::Injections::MethodMissingInjection::BoundObjects[#{id}]
-            MethodDispatches::MethodMissingDispatch.new(self, obj, method_name, args, block).call
-          end
-        METHOD
+        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
+          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/integrations/minitest_4.rb

@@ -36,7 +36,7 @@ module RR
       def hook
         assertion_error_class = self.assertion_error_class
         test_case_class.class_eval do
-          include RR::Adapters::RRMethods
+          include RR::DSL
           include Mixin
 
           unless instance_methods.any? { |method_name| method_name.to_sym == :setup_with_rr }

data/lib/rr/integrations/minitest_4_active_support.rb

@@ -20,7 +20,7 @@ module RR
       def hook
         parent_adapter_class = self.parent_adapter_class
         ::ActiveSupport::TestCase.class_eval do
-          include RR::Adapters::RRMethods
+          include RR::DSL
           include parent_adapter_class::Mixin
 
           setup do

data/lib/rr/integrations/rspec/invocation_matcher.rb

@@ -37,11 +37,3 @@ module RR
     end
   end
 end
-
-module RR
-  module Adapters
-    module Rspec
-      InvocationMatcher = RR::Integrations::RSpec::InvocationMatcher
-    end
-  end
-end

data/lib/rr/integrations/rspec_2.rb

@@ -1,6 +1,24 @@
 module RR
   module Integrations
-    class RSpec2 < RSpec1
+    class RSpec2
+      module Mixin
+        def setup_mocks_for_rspec
+          RR.reset
+        end
+
+        def verify_mocks_for_rspec
+          RR.verify
+        end
+
+        def teardown_mocks_for_rspec
+          RR.reset
+        end
+
+        def have_received(method = nil)
+          RSpec::InvocationMatcher.new(method)
+        end
+      end
+
       def name
         'RSpec 2'
       end
@@ -14,14 +32,16 @@ module RR
       def hook
         ::RSpec.configure do |config|
           config.mock_with Mixin
-          config.include RR::Adapters::RRMethods
-        end
-      patterns =
-        if ::RSpec.configuration.respond_to?(:backtrace_exclusion_patterns)
-          ::RSpec.configuration.backtrace_exclusion_patterns
-        else 
-          ::RSpec.configuration.backtrace_clean_patterns
+          config.include RR::DSL
         end
+
+        patterns =
+          if ::RSpec.configuration.respond_to?(:backtrace_exclusion_patterns)
+            ::RSpec.configuration.backtrace_exclusion_patterns
+          else
+            ::RSpec.configuration.backtrace_clean_patterns
+          end
+
         unless patterns.include?(RR::Errors::BACKTRACE_IDENTIFIER)
           patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
         end

data/lib/rr/keyword_arguments.rb

@@ -0,0 +1,15 @@
+module RR
+  module KeywordArguments
+    class << self
+      if (RUBY_VERSION <=> "2.7.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