rr 1.1.2 → 3.0.2

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

data/lib/rr/space.rb

@@ -13,9 +13,15 @@ module RR
       end
       attr_writer :instance
 
-    protected
-      def method_missing(method_name, *args, &block)
-        instance.__send__(method_name, *args, &block)
+      protected
+      if KeywordArguments.fully_supported?
+        def method_missing(method_name, *args, **kwargs, &block)
+          instance.__send__(method_name, *args, **kwargs, &block)
+        end
+      else
+        def method_missing(method_name, *args, &block)
+          instance.__send__(method_name, *args, &block)
+        end
       end
     end
 
@@ -79,8 +85,12 @@ module RR
       Injections::DoubleInjection.reset_double(class << subject; self; end, method_name)
     end
 
-    def record_call(subject, method_name, arguments, block)
-      @recorded_calls << [subject, method_name, arguments, block]
+    def record_call(subject, method_name, arguments, keyword_arguments, block)
+      @recorded_calls.add(subject,
+                          method_name,
+                          arguments,
+                          keyword_arguments,
+                          block)
     end
 
     def blank_slate_whitelist

data/lib/rr/spy_verification.rb

@@ -13,12 +13,12 @@ module RR
 
     include RR::DoubleDefinitions::DoubleDefinition::TimesDefinitionConstructionMethods
     include RR::DoubleDefinitions::DoubleDefinition::ArgumentDefinitionConstructionMethods
-  
+
     def ordered
       @ordered = true
       self
     end
-  
+
     def ordered?
       @ordered
     end
@@ -32,7 +32,15 @@ module RR
         call
       end
     end
-  
+
+    def subject_inspect
+      if subject.respond_to?(:__rr__original_inspect, true)
+        subject.__rr__original_inspect
+      else
+        subject.inspect
+      end
+    end
+
   protected
     attr_writer :times_matcher
 
@@ -40,9 +48,9 @@ module RR
       # with_no_args and with actually set @argument_expectation
       args.empty? ? with_no_args : with(*args)
     end
-  
+
     def install_method_callback(return_value_block)
       # Do nothing. This is to support DefinitionConstructionMethods
     end
   end
-end
+end

data/lib/rr/version.rb

@@ -1,4 +1,4 @@
 module RR
-  VERSION = '1.1.2'.freeze
+  VERSION = '3.0.2'.freeze
   def self.version; VERSION; end
 end

data/lib/rr/wildcard_matchers.rb

@@ -12,7 +12,7 @@ divisible by a certain integer.  In use, it might look like this:
 
   mock(BananaGrabber).bunch_bananas(divisible_by(5))
 
-To implement this, we need a class RR::WildcardMatchers::DivisibleBy with 
+To implement this, we need a class RR::WildcardMatchers::DivisibleBy with
 these instance methods:
 
 * ==(other)
@@ -38,7 +38,7 @@ might look like this:
 DivisibleBy#==(other) should return true if other is a wildcard matcher that
 matches the same things as self, so a natural way to write DivisibleBy#== is:
 
-  
+
   class RR::WildcardMatchers::DivisibleBy
     def ==(other)
       # Ensure that other is actually a DivisibleBy
@@ -86,7 +86,7 @@ false otherwise.  In the case of DivisibleBy, wildcard_matches? reads:
       # If other isn't a number, how can it be divisible by anything?
       return false unless other.is_a?(Numeric)
 
-      # If other is in fact divisible by expected_divisor, then 
+      # If other is in fact divisible by expected_divisor, then
       # other modulo expected_divisor should be 0.
 
       other % expected_divisor == 0
@@ -105,10 +105,10 @@ But that's less expressive than the original:
   mock(BananaGrabber).bunch_bananas(divisible_by(5))
 
 To be able to use the convenient divisible_by matcher rather than the uglier
-DivisibleBy.new version, re-open the module RR::Adapters::RRMethods and
-define divisible_by there as a simple wrapper around DivisibleBy.new:
+DivisibleBy.new version, re-open the module RR::DSL and define divisible_by
+there as a simple wrapper around DivisibleBy.new:
 
-  module RR::Adapters::RRMethods
+  module RR::DSL
     def divisible_by(expected_divisor)
       RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
     end
@@ -134,19 +134,19 @@ Here's all the code for DivisibleBy in one place for easy reference:
     def inspect
       "integer divisible by #{expected.divisor}"
     end
-  
+
     def wildcard_matches?(other)
       # If other isn't a number, how can it be divisible by anything?
       return false unless other.is_a?(Numeric)
 
-      # If other is in fact divisible by expected_divisor, then 
+      # If other is in fact divisible by expected_divisor, then
       # other modulo expected_divisor should be 0.
 
       other % expected_divisor == 0
     end
   end
-  
-  module RR::Adapters::RRMethods
+
+  module RR::DSL
     def divisible_by(expected_divisor)
       RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
     end

data/lib/rr/without_autohook.rb

@@ -6,6 +6,8 @@ require 'rr/core_ext/array'
 require 'rr/core_ext/range'
 require 'rr/core_ext/regexp'
 
+require 'rr/keyword_arguments'
+
 require 'rr/class_instance_method_defined'
 require 'rr/blank_slate'
 
@@ -36,7 +38,7 @@ require 'rr/double_definitions/strategies/implementation/proxy'
 require 'rr/double_definitions/strategies/double_injection/double_injection_strategy'
 require 'rr/double_definitions/strategies/double_injection/instance'
 require 'rr/double_definitions/strategies/double_injection/any_instance_of'
-require 'rr/adapters/rr_methods'
+require 'rr/dsl'
 require 'rr/double_definitions/double_injections/instance'
 require 'rr/double_definitions/double_injections/any_instance_of'
 require 'rr/double_definitions/double_definition'
@@ -49,8 +51,8 @@ require 'rr/method_dispatches/base_method_dispatch'
 require 'rr/method_dispatches/method_dispatch'
 require 'rr/method_dispatches/method_missing_dispatch'
 require 'rr/hash_with_object_id_key'
+require 'rr/recorded_call'
 require 'rr/recorded_calls'
-require 'rr/proc_from_block'
 
 require 'rr/double_definitions/double_definition_create_blank_slate'
 require 'rr/double_definitions/double_definition_create'
@@ -88,24 +90,19 @@ require 'rr/spy_verification'
 require 'rr/integrations'
 require 'rr/integrations/decorator'
 require 'rr/integrations/rspec/invocation_matcher'
-require 'rr/integrations/rspec_1'
 require 'rr/integrations/rspec_2'
 require 'rr/integrations/minitest_4'
 require 'rr/integrations/minitest_4_active_support'
 require 'rr/integrations/minitest'
 require 'rr/integrations/minitest_active_support'
-require 'rr/integrations/test_unit_1'
-require 'rr/integrations/test_unit_200'
-require 'rr/integrations/test_unit_200_active_support'
-require 'rr/integrations/test_unit_2'
-require 'rr/integrations/test_unit_2_active_support'
-require 'rr/adapters'
+
+require 'rr/deprecations'
 
 require 'rr/version'
 
 module RR
   class << self
-    include Adapters::RRMethods
+    include DSL
 
     (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
       class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
@@ -117,10 +114,6 @@ module RR
 
     attr_accessor :debug
     alias_method :debug?, :debug
-
-    def ruby_18?
-      RUBY_VERSION =~ /^1\.8/
-    end
   end
 end
 

data/rr.gemspec

@@ -6,11 +6,11 @@ require File.expand_path('../lib/rr/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.name = 'rr'
   gem.version = RR.version
-  gem.authors = ['Brian Takita', 'Elliot Winkler']
-  gem.email = ['elliot.winkler@gmail.com']
+  gem.authors = ['Kouhei Sutou', 'Brian Takita', 'Elliot Winkler']
+  gem.email = ['kou@cozmixng.org']
   gem.description = 'RR is a test double framework that features a rich selection of double techniques and a terse syntax.'
   gem.summary = 'RR is a test double framework that features a rich selection of double techniques and a terse syntax.'
-  gem.homepage = 'http://rr.github.com/rr'
+  gem.homepage = 'https://rr.github.io/rr'
   gem.license = 'MIT'
 
   gem.files = FileList[
@@ -29,4 +29,9 @@ Gem::Specification.new do |gem|
   ].to_a
 
   gem.require_paths = ['lib']
+
+  gem.add_development_dependency("bundler")
+  gem.add_development_dependency("rake")
+  gem.add_development_dependency("test-unit")
+  gem.add_development_dependency("test-unit-rr")
 end

data/spec/defines_spec_suite_tasks.rb

@@ -33,6 +33,18 @@ class DefinesSpecSuiteTasks
           end
         end
       end
+
+      require 'rspec/core/rake_task'
+
+      desc "Run the unit tests"
+      RSpec::Core::RakeTask.new(:unit) do |t|
+        t.pattern = 'spec/suites/rspec_2/unit/**/*_spec.rb'
+      end
+
+      desc "Run the functional (API) tests"
+      RSpec::Core::RakeTask.new(:functional) do |t|
+        t.pattern = 'spec/suites/rspec_2/functional/**/*_spec.rb'
+      end
     end
 
     namespace :travis do