rr 1.2.1 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35d55fd0d14916ec412865fa0093c5c3ecf6af07
-  data.tar.gz: e5dd7d9dbddb7c2dfe272de8a0fb9e3c18ffbf9b
+SHA256:
+  metadata.gz: 303d118de2a2762d0b82b84ce5074540e77008a95805fb0b3b8df64872e3bb26
+  data.tar.gz: 84a6e68fae515e2c5c1e6bed26dd55cbfba98e846e54d03b353266acb681a056
 SHA512:
-  metadata.gz: 3013497ba6d79be17044b1da4efa0806f8c608840d46603fc05ec255aebdc701946cd097d9032a017f88ff2e672c5a065d0a4a4a14431bb5d0b0c6c431a3c9d3
-  data.tar.gz: 066dc64081fc2b385185e25bd4f56612b90f14c9788ab8ca78fb17b5593542fb601b33108703ce637770d28c2a90a4dd00edac809447b59f09755e7bbe73588f
+  metadata.gz: c5b89becb9e9df041c472826206c92e0c9b9b6755246ce8e0c6bd84b81b5cb498c77222aaf22dbaa20f55b3315483dff85dd3b910f2ef16a0b4405d51c697dc9
+  data.tar.gz: f590f980d6fb93a5c173efe8a0f85676402262bd4fcec944e9804602f2372426b2a78cd9e2120569520667e9eaf213e72cb70c5db08d62373bee831a2f75387e

data/CHANGES.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 3.0.4 - 2021-06-23
+
+### Fixes
+
+  * Fix inverted condition in keyword arguments related code.
+    [GitHub#84][Patch by akira yamada]
+
+### Thanks
+
+  * akira yamada
+
+## 3.0.3 - 2021-06-22
+
+### Improvements
+
+  * Improved keyword arguments support.
+    [GitHub#83][Patch by akira yamada]
+
+### Thanks
+
+  * akira yamada
+
+## 3.0.2 - 2021-06-18
+
+### Improvements
+
+  * `stub`: Added support for Ruby 3.0's keyword arguments.
+    [GitHub#82][Reported by akira yamada]
+
+### Thanks
+
+  * akira yamada
+
+## 3.0.1 - 2021-06-18
+
+### Improvements
+
+  * Suppressed keyword arguments related warnings on Ruby 2.7.
+    [GitHub#81][Reported by akira yamada]
+
+### Thanks
+
+  * akira yamada
+
+## 3.0.0 - 2021-03-31
+
+### Improvements
+
+  * Added support for Ruby 3.0's keyword arguments.
+    [GitHub#17][Reported by Takuro Ashie]
+
+### Fixes
+
+  * Fixed a bug that `any_instance_of` doesn't work with class
+    hierarchies. [GitHub#12][Reported by Étienne Barrié]
+
+### Thanks
+
+  * Étienne Barrié
+
+  * Takuro Ashie
+
+## 1.2.1 - 2017-06-22
+
+### Fixes
+
+  * Fixed a bug that `RR.reset` resets newly created methods.
+    [GitHub#8]
+
 ## 1.2.0 - 2016-05-30
 
 ### Improvements

data/Gemfile

@@ -1,10 +1,3 @@
 source 'https://rubygems.org'
 
-gem 'rake', '~> 10.0'
-gem 'simplecov', '~> 0.7'
-gem 'appraisal', '~> 0.5'
-gem 'posix-spawn', :platforms => :mri
-gem 'open4', :platforms => :mri
-gem 'test-unit'
-gem 'test-unit-rr'
-gem 'rspec', '~> 2.14'
+gemspec

data/README.md

@@ -1,4 +1,4 @@
-# RR [![Gem Version](https://badge.fury.io/rb/rr.png)](http://badge.fury.io/rb/rr) [![Build Status](https://travis-ci.org/rr/rr.png?branch=master)](https://travis-ci.org/rr/rr) [![Code Climate GPA](https://codeclimate.com/github/rr/rr.png)](https://codeclimate.com/github/rr/rr)
+# RR [![Gem Version](https://badge.fury.io/rb/rr.svg)](https://badge.fury.io/rb/rr) [![Build Status](https://travis-ci.org/rr/rr.svg?branch=master)](https://travis-ci.org/rr/rr) [![Code Climate GPA](https://codeclimate.com/github/rr/rr.svg)](https://codeclimate.com/github/rr/rr)
 
 RR is a test double framework for Ruby that features a rich selection of double
 techniques and a terse syntax.
@@ -147,35 +147,31 @@ require 'rr'
 
 RR is designed and tested to work against the following Ruby versions:
 
-* 2.1
-* 2.2
-* 2.3
+* 2.4
+* 2.5
+* 2.6
+* 2.7
+* 3.0
 * JRuby 1.7.4
 
 as well as the following test frameworks:
 
-* RSpec 2
 * Test::Unit via [test-unit-rr](https://test-unit.github.io/#test-unit-rr)
+* RSpec 2
 * MiniTest 4
 * Minitest 5
 
-and the following Rails versions:
-
-* Rails 4
-
-
 ## Help!
 
 If you have a question or are having trouble, simply [post it as an
-issue](http://github.com/rr/rr/issues) and I'll respond as soon as I can.
+issue](https://github.com/rr/rr/issues) and I'll respond as soon as I can.
 
 
 ## Contributing
 
 Want to contribute a bug fix or new feature to RR? Great! Follow these steps:
 
-1. Make sure you have Ruby 2.0.0-p195 installed (this is the primary Ruby
-   version that RR targets).
+1. Make sure you have a recent Ruby (check the compatibility table above).
 2. Clone the repo (you probably knew that already).
 3. Make a new branch off of `master` with a descriptive name.
 4. Work on your patch.

data/Rakefile

@@ -7,10 +7,15 @@ require 'pp'
 # build, install, release
 require 'bundler/gem_tasks'
 
+require_relative "lib/rr/version"
+
+default_tasks = []
+
 begin
   # appraisal
   require 'appraisal'
-
+rescue LoadError
+else
   # appraisals
   Appraisal::File.each do |appraisal|
     desc "Resolve and install dependencies for the #{appraisal.name} appraisal"
@@ -18,16 +23,35 @@ begin
       appraisal.install
     end
   end
-rescue LoadError
+  default_tasks << 'appraisal:install'
 end
 
-# spec
-require File.expand_path('../spec/defines_spec_suite_tasks', __FILE__)
-DefinesSpecSuiteTasks.call
+begin
+  # spec
+  require 'rspec/core/rake_task'
+rescue LoadError
+else
+  require File.expand_path('../spec/defines_spec_suite_tasks', __FILE__)
+  DefinesSpecSuiteTasks.call
+  default_tasks << :spec
+end
 
 desc "Run tests"
 task :test do
   ruby("test/run-test.rb")
 end
+default_tasks << :test
+
+namespace :"gh-pages" do
+  namespace :version do
+    desc "Update version"
+    task :update do
+      config_yml_path = "gh-pages/_config.yml"
+      config_yml = File.read(config_yml_path)
+      config_yml = config_yml.gsub(/^version: .*$/, "version: #{RR::VERSION}")
+      File.write(config_yml_path, config_yml)
+    end
+  end
+end
 
-task :default => ['appraisal:install', :spec, :test]
+task :default => default_tasks

data/lib/rr/class_instance_method_defined.rb

@@ -6,4 +6,4 @@ module RR
         klass.private_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym}
     end
   end
-end
+end

data/lib/rr/double.rb

@@ -4,14 +4,20 @@ module RR
   # and the implementation.
   class Double
     extend(Module.new do
-      def formatted_name(method_name, args)
-        formatted_errors = args.collect {|arg| arg.inspect}.join(', ')
+      def formatted_name(method_name, args, kwargs)
+        formatted_arguments =
+          args.collect {|arg| arg.inspect} +
+          kwargs.collect {|keyword, value| "#{keyword}: #{value.inspect}"}
+        formatted_errors = formatted_arguments.join(', ')
         "#{method_name}(#{formatted_errors})"
       end
 
       def list_message_part(doubles)
         doubles.collect do |double|
-          "- #{formatted_name(double.method_name, double.expected_arguments)}"
+          name = formatted_name(double.method_name,
+                                double.expected_arguments,
+                                double.expected_keyword_arguments)
+          "- #{name}"
         end.join("\n")
       end
     end)
@@ -32,14 +38,14 @@ module RR
 
     # Double#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityExpectation arguments.
-    def exact_match?(*arguments)
-      definition.exact_match?(*arguments)
+    def exact_match?(arguments, keyword_arguments)
+      definition.exact_match?(arguments, keyword_arguments)
     end
 
     # Double#wildcard_match? returns true when the passed in arguments
     # wildcard match the ArgumentEqualityExpectation arguments.
-    def wildcard_match?(*arguments)
-      definition.wildcard_match?(*arguments)
+    def wildcard_match?(arguments, keyword_arguments)
+      definition.wildcard_match?(arguments, keyword_arguments)
     end
 
     # Double#attempt? returns true when the
@@ -74,18 +80,26 @@ module RR
       argument_expectation.expected_arguments
     end
 
+    # The keyword arguments that this Double expects
+    def expected_keyword_arguments
+      verify_argument_expectation_is_set
+      argument_expectation.expected_keyword_arguments
+    end
+
     # The TimesCalledMatcher for the TimesCalledExpectation
     def times_matcher
       definition.times_matcher
     end
 
     def formatted_name
-      self.class.formatted_name(method_name, expected_arguments)
+      self.class.formatted_name(method_name,
+                                expected_arguments,
+                                expected_keyword_arguments)
     end
 
-    def method_call(args)
+    def method_call(args, kwargs)
       if verbose?
-        puts Double.formatted_name(method_name, args)
+        puts Double.formatted_name(method_name, args, kwargs)
       end
       times_called_expectation.attempt if definition.times_matcher
       space.verify_ordered_double(self) if ordered?
@@ -148,6 +162,10 @@ module RR
       definition.argument_expectation.expected_arguments
     end
 
+    def kwargs
+      definition.argument_expectation.expected_keyword_arguments
+    end
+
     def argument_expectation
       definition.argument_expectation
     end

data/lib/rr/double_definitions/double_definition.rb

@@ -36,16 +36,26 @@ module RR
       end
 
       module ArgumentDefinitionConstructionMethods
-        # Double#with sets the expectation that the Double will receive
-        # the passed in arguments.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.with(1, 2) {:return_value}
-        def with(*args, &return_value_block)
-          @argument_expectation = Expectations::ArgumentEqualityExpectation.new(*args)
-          install_method_callback return_value_block
-          self
+        if KeywordArguments.fully_supported?
+          # Double#with sets the expectation that the Double will receive
+          # the passed in arguments.
+          #
+          # Passing in a block sets the return value.
+          #
+          #   mock(subject).method_name.with(1, 2) {:return_value}
+          def with(*args, **kwargs, &return_value_block)
+            @argument_expectation =
+              Expectations::ArgumentEqualityExpectation.new(args, kwargs)
+            install_method_callback return_value_block
+            self
+          end
+        else
+          def with(*args, &return_value_block)
+            @argument_expectation =
+              Expectations::ArgumentEqualityExpectation.new(args, {})
+            install_method_callback return_value_block
+            self
+          end
         end
 
         # Double#with_any_args sets the expectation that the Double can receive
@@ -67,7 +77,8 @@ module RR
         #
         #   mock(subject).method_name.with_no_args {:return_value}
         def with_no_args(&return_value_block)
-          @argument_expectation = Expectations::ArgumentEqualityExpectation.new()
+          @argument_expectation =
+            Expectations::ArgumentEqualityExpectation.new([], {})
           install_method_callback return_value_block
           self
         end
@@ -298,18 +309,18 @@ module RR
           @verbose ? true : false
         end
 
-        def exact_match?(*arguments)
+        def exact_match?(arguments, keyword_arguments)
           unless @argument_expectation
             raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
           end
-          @argument_expectation.exact_match?(*arguments)
+          @argument_expectation.exact_match?(arguments, keyword_arguments)
         end
 
-        def wildcard_match?(*arguments)
+        def wildcard_match?(arguments, keyword_arguments)
           unless @argument_expectation
             raise RR::Errors.build_error(:DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}")
           end
-          @argument_expectation.wildcard_match?(*arguments)
+          @argument_expectation.wildcard_match?(arguments, keyword_arguments)
         end
 
         def terminal?
@@ -320,7 +331,19 @@ module RR
         end
 
         def expected_arguments
-          argument_expectation ? argument_expectation.expected_arguments : []
+          if argument_expectation
+            argument_expectation.expected_arguments
+          else
+            []
+          end
+        end
+
+        def expected_keyword_arguments
+          if argument_expectation
+            argument_expectation.expected_keyword_arguments
+          else
+            {}
+          end
         end
 
         def implementation_is_original_method?

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/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,23 @@ 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
+            elsif kwargs.empty?
+              definition.with(*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