rr 1.1.1 → 3.0.0

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.rb

@@ -30,20 +30,21 @@ module RR
     adapters.select { |adapter| adapter.applies? }
   end
 
-  def self.find_applicable_adapter_matching(pattern)
-    adapter = adapters.
-      select { |adapter| adapter.name.to_s =~ pattern }.
+  def self.find_applicable_adapter(name)
+    adapters.
+      select { |adapter| name === adapter.name.to_s }.
       find   { |adapter| adapter.applies? }
-    if adapter
-      mod = Module.new
-      (class << mod; self; end).class_eval do
-        define_method(:included) do |base|
-          # Note: This assumes that the thing that is including this module
-          # is the same that the adapter detected and will hook into.
-          adapter.hook
-        end
+  end
+
+  def self.module_shim_for_adapter(adapter)
+    mod = Module.new
+    (class << mod; self; end).class_eval do
+      define_method(:included) do |base|
+        # Note: This assumes that the thing that is including this module
+        # is the same that the adapter detected and will hook into.
+        adapter.load
       end
-      mod
     end
+    mod
   end
 end

data/lib/rr/integrations/decorator.rb

@@ -22,9 +22,12 @@ module RR
       end
 
       def load
+        return if @loaded
         hook
+        if RR.debug?
+          puts "Loaded adapter: #{name}"
+        end
         @loaded = true
-        puts "Loaded adapter: #{name}" if RR.debug?
       rescue => e
         if RR.debug?
           puts "Couldn't load adapter #{name}: #{e.class} (#{e.message})"

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,9 +32,16 @@ module RR
       def hook
         ::RSpec.configure do |config|
           config.mock_with Mixin
-          config.include RR::Adapters::RRMethods
+          config.include RR::DSL
         end
-        patterns = ::RSpec.configuration.backtrace_clean_patterns
+
+        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 <=> "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

data/lib/rr/recorded_call.rb

@@ -0,0 +1,35 @@
+module RR
+  class RecordedCall < Struct.new(:subject,
+                                  :method_name,
+                                  :arguments,
+                                  :keyword_arguments,
+                                  :block)
+    def inspect
+      '[%s, %s, %s, %s, %s]' % [
+        subject_to_s,
+        method_name.inspect,
+        arguments.inspect,
+        keyword_arguments.inspect,
+        block.inspect
+      ]
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        subject == other.subject &&
+        method_name == other.method_name &&
+        arguments == other.arguments &&
+        keyword_arguments == other.keyword_arguments
+    end
+
+    private
+
+    def subject_to_s
+      if subject.respond_to?(:__rr__original_to_s, true)
+        subject.__rr__original_to_s
+      else
+        subject.to_s
+      end
+    end
+  end
+end

data/lib/rr/recorded_calls.rb

@@ -9,13 +9,21 @@ module RR
 
     attr_reader :recorded_calls
 
+    def [](index)
+      @recorded_calls[index]
+    end
+
     def clear
       self.ordered_index = 0
       recorded_calls.clear
     end
 
-    def <<(recorded_call)
-      recorded_calls << recorded_call
+    def add(subject, method_name, arguments, keyword_arguments, block)
+      recorded_calls << RecordedCall.new(subject,
+                                         method_name,
+                                         arguments,
+                                         keyword_arguments,
+                                         block)
     end
 
     def any?(&block)
@@ -43,9 +51,9 @@ module RR
       unless Injections::DoubleInjection.exists_by_subject?(spy_verification.subject, spy_verification.method_name)
         RR::Errors.build_error(RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError,
           "A Double Injection for the subject and method call:\n" <<
-          "#{spy_verification.subject.inspect}\n" <<
+          "#{spy_verification.subject_inspect}\n" <<
           "#{spy_verification.method_name}\ndoes not exist in:\n" <<
-          "\t#{recorded_calls.map {|call| call.inspect}.join("\n\t")}"
+          "\t#{recorded_calls.map {|call| call.inspect }.join("\n\t")}"
         )
       end
     end
@@ -77,22 +85,28 @@ module RR
 
     def match_double_injection(spy_verification)
       lambda do |recorded_call|
-        recorded_call[0] == spy_verification.subject &&
-        recorded_call[1] == spy_verification.method_name
+        recorded_call.subject == spy_verification.subject &&
+          recorded_call.method_name == spy_verification.method_name
       end
     end
 
     def match_argument_expectation(spy_verification)
       lambda do |recorded_call|
-        spy_verification.argument_expectation.exact_match?(*recorded_call[2]) ||
-        spy_verification.argument_expectation.wildcard_match?(*recorded_call[2])
+        expectation = spy_verification.argument_expectation
+        arguments = recorded_call.arguments
+        keyword_arguments = recorded_call.keyword_arguments
+        expectation.exact_match?(arguments, keyword_arguments) ||
+          expectation.wildcard_match?(arguments, keyword_arguments)
       end
     end
 
     def invocation_count_error(spy_verification, matching_recorded_calls)
+      method_name = spy_verification.method_name
+      arguments = spy_verification.argument_expectation.expected_arguments
+      keyword_arguments = spy_verification.argument_expectation.expected_keyword_arguments
       RR::Errors.build_error(RR::Errors::SpyVerificationErrors::InvocationCountError,
         "On subject #{spy_verification.subject.inspect}\n" <<
-        "Expected #{Double.formatted_name(spy_verification.method_name, spy_verification.argument_expectation.expected_arguments)}\n" <<
+        "Expected #{Double.formatted_name(method_name, arguments, keyword_arguments)}\n" <<
         "to be called #{spy_verification.times_matcher.expected_times_message},\n" <<
         "but was called #{matching_recorded_calls.size} times.\n" <<
         "All of the method calls related to Doubles are:\n" <<