flexmock 2.4.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d0a8810418e4e6400b70c2704122d81e4a386f631f9013157429963b386fffa
-  data.tar.gz: ee80bbf1bcd0d626efa8d7a5512cfc7343c120d7123e83c16e10a35aad4f73c6
+  metadata.gz: 97fdfec71cb9dd687df62403b26eb8d4d24e4b28ec7f35f5e2d5f3ac6ffed943
+  data.tar.gz: 8f250a12f731099db17e9fcea78b92e0b92ac523376a34e06b5295f3a17ec996
 SHA512:
-  metadata.gz: d18374afda345a829ff9264901224891d8fcff4127415e9de3430209f8228cd43285ed79e70dae68b78f35c8affbace80d49767b68a490f67a655cd011bc8518
-  data.tar.gz: 2b49462130ee807ad062f382b1de1a9e3d25138efd41e2436ffbbaa9190581579f4c503e2eeadd86ec51e38887c7098558996814fc12d0f56f435d54e6266d8a
+  metadata.gz: 7672fd90360b33327119a7f135a7db9d05c7b7d41e0dd5299396296e0b68c8bb5175eaa2cf8d334b9b8cc62f52a87af4fe8af8216a4e9283341c909eed5ca196
+  data.tar.gz: a2112c506ef7152ba13aef9f67cb9ab5d58a0b566b5f50e7db00e545ff04e663da129f8291109dc25f028b2150ca4a936d96ced1444cbb85b4298534179046dc

data/.github/workflows/test.yml

@@ -8,7 +8,11 @@ jobs:
 
     strategy:
       matrix:
-        ruby-version: ["2.7", "2.6", "2.5"]
+        ruby-version:
+          - "3.2"
+          - "3.1"
+          - "3.0"
+          - "2.7"
 
     steps:
     - uses: actions/checkout@v2

data/README.md

@@ -22,6 +22,54 @@ Only significant changes (new APIs, deprecated APIs or backward-compatible
 changes) are documented here, a.k.a. minor or major version bumps. If you want a
 detailed changelog, go over the commit log in github (it's pretty low-traffic)
 
+3.0.0:
+ - Added keyword argument and explicit proc support. Keyword argument support
+   is Ruby 3.0+ only, getting the support to work on Ruby 2.7 deemed to be too
+   complicated. See the release notes for 2.4 below for information about how
+   migration can be done smoothly
+ - `with` now expects all expected keyword arguments to be explicitly given in a
+   natural way, for instance:
+     
+   ```
+   mock.should_receive(:m).with("some", "args", with: 42)
+   ```
+
+   The values given to the arguments can be any matcher valid for the positional
+   arguments
+ - note that not giving any keyword arguments to `with` is interpreted as a
+   negative (no keyword arguments are expected), and will fail if some arguments
+   are given. Call `with_any_kw_args` after the `with` if you do not desire
+   validation of keyword arguments:
+
+   ```
+   mock.should_receive(:m).with("some", "args").with_any_kw_args
+   ```
+
+ - for more complex matches, pass a match object to the `with_kw_args` method.
+   For instance, to match only some keyword arguments, do
+
+   ```
+   mock.should_receive(:m).with("some", "args").with_kw_args(hsh(with: 42))
+   ```
+
+ - this release also makes matching procs explicit. Instead of passing Proc at
+   the end of `with` as in 2.x, call `with_block` or `with_no_block`. If neither
+   are called, flexmock won't validate either way (ignore whether or not a block
+   was given). The default is to not match blocks, that is working
+ - The default is to assume that blocks are optional (i.e. flexmock will match
+   either way). Nonetheless, the method `with_optional_block` is implemented
+   to help migration from flexmock 2.4.0 (but is a no-op).
+
+2.4.0:
+ - forward-compatible implementation of `with_kw_args`, `with_any_kw_args`,
+   `with_block` and `with_no_block`. The objective of this release is to ensure
+   that any test changes needed to handle Ruby 3 (along with flexmock 3) can run
+   on ruby 2.7 and flexmock 2.4
+ - the default behavior of flexmock 2 regarding proc matching, that is that one
+   needs to match them explicitly, is unchanged. Use `with_optional_block` instead
+   of passing `optional_proc` to `with`, to match optionally (IMPORTANT
+   the explicit `with` methods that match blocks are called `block`, not `proc`)
+
 2.3.0:
  - implemented validation of call arity for partial mocks. By setting
      FlexMock.partials_verify_signatures = true
@@ -546,12 +594,10 @@ determining whether a given expectation matches or not.
   series. The last value will be repeatably returned if the number of
   matching calls exceeds the number of values.
 
-* <b>and_return { |<em>args</em>, ...|  <em>code</em> ... }</b>
+* <b>and_return { |<em>*args</em>, <em>**kw</em>, <em>&block</em>|  <em>code</em> ... }</b>
 
   Declares that the expected message will return the yielded value of
   the block. The block will receive all the arguments in the message.
-  If the message was provided a block, it will be passed as the last
-  parameter of the block's argument list.
 
 * <b>returns( ... )</b>
 
@@ -755,13 +801,15 @@ The following rules are used for argument matching:
 
   will match any even integer.
 
-* If you wish to match a method call where a block is given, add
-  `Proc` as the last argument to `with`.
+* By default, flexmock will ignore given blocks, that is it will assume that
+  blocks are optional.
+
+* If you wish to verify that a method call received a block, use `with_block`
 
   Example:
 
 ```ruby
-      m.should_receive(:foo).with(Integer,Proc).and_return(:got_block)
+      m.should_receive(:foo).with(Integer).with_block.and_return(:got_block)
       m.should_receive(:foo).with(Integer).and_return(:no_block)
 ```
 
@@ -772,6 +820,22 @@ The following rules are used for argument matching:
      m.foo(1)     => returns :no_block
 ```
 
+* If you wish to verify that a method call does not receive a block, use `with_no_block`
+
+  Example:
+
+```ruby
+      m.should_receive(:foo).with(Integer).with_no_block.and_return(:no_block)
+      m.should_receive(:foo).with(Integer).and_return(:got_block)
+```
+
+  will cause the mock to return the following:
+
+```ruby
+     m.foo(1) { } => returns :got_block
+     m.foo(1)     => returns :no_block
+```
+
 ### Creating Partial Mocks
 
 Sometimes it is useful to mock the behavior of one or two methods in

data/flexmock.gemspec

@@ -10,7 +10,7 @@ spec = Gem::Specification.new do |s|
     interface is simple, it is very flexible.
   }
 
-  s.required_ruby_version = ">= 2.5"
+  s.required_ruby_version = ">= 3.0"
 
   s.license = 'MIT'
 

data/lib/flexmock/argument_matchers.rb

@@ -62,6 +62,9 @@ class FlexMock
     def ===(target)
       @hash.all? { |k, v| target[k] == v }
     end
+    def empty?
+      @hash.empty?
+    end
     def inspect
       "hsh(#{@hash.inspect})"
     end
@@ -80,19 +83,4 @@ class FlexMock
       "ducktype(#{@methods.map{|m| m.inspect}.join(',')})"
     end
   end
-
-  ####################################################################
-  # Match objects that implement all the methods in +methods+.
-  class OptionalProcMatcher
-    def initialize
-    end
-    def ===(target)
-      ArgumentMatching.missing?(target) || Proc === target
-    end
-    def inspect
-      "optional_proc"
-    end
-  end
-  OPTIONAL_PROC_MATCHER = OptionalProcMatcher.new
-
 end

data/lib/flexmock/argument_matching.rb

@@ -4,7 +4,13 @@ class FlexMock
 
     MISSING_ARG = Object.new
 
-    def all_match?(expected_args, actual_args)
+    def all_match?(expected_args, expected_kw, expected_block, actual_args, actual_kw, actual_block)
+      all_match_args?(expected_args, actual_args) &&
+        all_match_kw?(expected_kw, actual_kw) &&
+        all_match_block?(expected_block, actual_block)
+    end
+
+    def all_match_args?(expected_args, actual_args)
       return true if expected_args.nil?
       return false if actual_args.size > expected_args.size
       i = 0
@@ -19,6 +25,30 @@ class FlexMock
       true
     end
 
+    def all_match_kw?(expected_kw, actual_kw)
+      return true if expected_kw.nil?
+      return expected_kw === actual_kw if expected_kw.kind_of? HashMatcher
+
+      matched_expected_k = Set.new
+      actual_kw.each do |actual_k, actual_v|
+        found_match = expected_kw.find do |k, v|
+          match?(k, actual_k) && match?(v, actual_v)
+        end
+        return false unless found_match
+        matched_expected_k << found_match
+      end
+
+      return false unless matched_expected_k.size == expected_kw.keys.size
+
+      true
+    end
+
+    def all_match_block?(expected_block, actual_block)
+      return true if expected_block.nil?
+
+      !(expected_block ^ actual_block)
+    end
+
     # Does the expected argument match the corresponding actual value.
     def match?(expected, actual)
       expected === actual ||

data/lib/flexmock/argument_types.rb

@@ -47,10 +47,6 @@ class FlexMock
     def ducktype(*methods)
       DuckMatcher.new(methods)
     end
-
-    def optional_proc
-      OPTIONAL_PROC_MATCHER
-    end
   end
   extend ArgumentTypes
 

data/lib/flexmock/call_record.rb

@@ -11,10 +11,11 @@
 
 class FlexMock
 
-  CallRecord = Struct.new(:method_name, :args, :block_given, :expectation) do
-    def matches?(sym, actual_args, options)
+  CallRecord = Struct.new(:method_name, :args, :kw, :block, :expectation) do
+    def matches?(sym, expected_args, expected_kw, options)
       method_name == sym &&
-        ArgumentMatching.all_match?(actual_args, args) &&
+        ArgumentMatching.all_match_args?(expected_args, args) &&
+        ArgumentMatching.all_match_kw?(expected_kw, kw) &&
         matches_block?(options[:with_block])
     end
 
@@ -22,8 +23,12 @@ class FlexMock
 
     def matches_block?(block_option)
       block_option.nil? ||
-        (block_option && block_given) ||
-        (!block_option && !block_given)
+        (block_option && block) ||
+        (!block_option && !block)
+    end
+
+    def block_given
+      block
     end
   end
 

data/lib/flexmock/call_validator.rb

@@ -24,10 +24,10 @@ class FlexMock
     # * :on_count => n -- If given, the :and validations on only run on the
     #                     nth invocation.
     #
-    def received?(calls, method_name, args, options)
+    def received?(calls, method_name, args, kw, options)
       count = 0
       calls.each { |call_record|
-        if call_record.matches?(method_name, args, options)
+        if call_record.matches?(method_name, args, kw, options)
           count += 1
           run_additional_validations(call_record, count, options)
         end

data/lib/flexmock/composite_expectation.rb

@@ -16,9 +16,9 @@ class FlexMock
     end
 
     # Apply the constraint method to all expectations in the composite.
-    def method_missing(sym, *args, &block)
+    def method_missing(sym, *args, **kw, &block)
       @expectations.each do |expectation|
-        expectation.send(sym, *args, &block)
+        expectation.send(sym, *args, **kw, &block)
       end
       self
     end
@@ -38,9 +38,9 @@ class FlexMock
 
     # Start a new method expectation.  The following constraints will be
     # applied to the new expectation.
-    def should_receive(*args, &block)
+    def should_receive(*args, **kw, &block)
       @expectations.first.mock.
-        flexmock_define_expectation(caller, *args, &block)
+        flexmock_define_expectation(caller, *args, **kw, &block)
     end
 
     # Return a string representations

data/lib/flexmock/core.rb

@@ -137,23 +137,22 @@ class FlexMock
   end
 
   # Handle missing methods by attempting to look up a handler.
-  def method_missing(sym, *args, &block)
+  def method_missing(sym, *args, **kw, &block)
     FlexMock.verify_mocking_allowed!
 
-    enhanced_args = block_given? ? args + [block] : args
-    call_record = CallRecord.new(sym, enhanced_args, block_given?)
+    call_record = CallRecord.new(sym, args, kw, block)
     @calls << call_record
     flexmock_wrap do
       if flexmock_closed?
         FlexMock.undefined
       elsif exp = flexmock_expectations_for(sym)
-        exp.call(args, block, call_record)
+        exp.call(args, kw, block, call_record)
       elsif @base_class && @base_class.flexmock_defined?(sym)
         FlexMock.undefined
       elsif @ignore_missing
         FlexMock.undefined
       else
-        super(sym, *args, &block)
+        super(sym, *args, **kw, &block)
       end
     end
   end
@@ -167,9 +166,9 @@ class FlexMock
   end
 
   # Find the mock expectation for method sym and arguments.
-  def flexmock_find_expectation(method_name, *args) # :nodoc:
+  def flexmock_find_expectation(method_name, *args, **kw, &block) # :nodoc:
     if exp = flexmock_expectations_for(method_name)
-      exp.find_expectation(*args)
+      exp.find_expectation(args, kw, block)
     end
   end
 
@@ -195,8 +194,8 @@ class FlexMock
   CALL_VALIDATOR = CallValidator.new
 
   # True if the mock received the given method and arguments.
-  def flexmock_received?(method_name, args, options={})
-    CALL_VALIDATOR.received?(@calls, method_name, args, options)
+  def flexmock_received?(method_name, args, kw, options = {})
+    CALL_VALIDATOR.received?(@calls, method_name, args, kw, options)
   end
 
   # Return the list of calls made on this mock. Used in formatting
@@ -207,13 +206,17 @@ class FlexMock
 
   # Invocke the original non-mocked functionality for the given
   # symbol.
-  def flexmock_invoke_original(method_name, args)
+  def flexmock_invoke_original(method_name, args, kw = {})
     return FlexMock.undefined
   end
 
   # Override the built-in +method+ to include the mocked methods.
   def method(method_name)
-    flexmock_expectations_for(method_name) || super
+    if (expectations = flexmock_expectations_for(method_name))
+      ->(*args, **kw, &block) { expectations.call(args, kw, block) }
+    else
+      super
+    end
   rescue NameError => ex
     if ignore_missing?
       proc { FlexMock.undefined }
@@ -241,15 +244,15 @@ class FlexMock
   #
   # See Expectation for a list of declarators that can be used.
   #
-  def should_receive(*args)
-    flexmock_define_expectation(caller, *args)
+  def should_receive(*args, **kw)
+    flexmock_define_expectation(caller, *args, **kw)
   end
 
   ON_RUBY_20 = (RUBY_VERSION =~ /^2\.0\./)
 
   # Using +location+, define the expectations specified by +args+.
-  def flexmock_define_expectation(location, *args)
-    @last_expectation = EXP_BUILDER.parse_should_args(self, args) do |method_name|
+  def flexmock_define_expectation(location, *args, **kw)
+    @last_expectation = EXP_BUILDER.parse_should_args(self, args, kw) do |method_name|
       exp = flexmock_expectations_for(method_name) || ExpectationDirector.new(method_name)
       @expectations[method_name] = exp
       result = Expectation.new(self, method_name, location)
@@ -258,7 +261,7 @@ class FlexMock
 
       if @base_class && !@base_class.flexmock_defined?(method_name)
         if !ON_RUBY_20 || !@base_class.ancestors.include?(Class)
-          result = ExplicitNeeded.new(result, method_name, @base_class) 
+          result = ExplicitNeeded.new(result, method_name, @base_class)
         end
       end
       result
@@ -298,8 +301,8 @@ class FlexMock
   # to explicitly invoke the method_missing logic.
   def override_existing_method(method_name)
     sclass.class_eval <<-EOS
-      def #{method_name}(*args, &block)
-        method_missing(:#{method_name}, *args, &block)
+      def #{method_name}(*args, **kw, &block)
+        method_missing(:#{method_name}, *args, **kw, &block)
       end
     EOS
   end

data/lib/flexmock/core_class_methods.rb

@@ -78,23 +78,42 @@ class FlexMock
 
     # Class method to format a method name and argument list as a nice
     # looking string.
-    def format_call(sym, args)  # :nodoc:
-      "#{sym}(#{format_args(args)})"
+    def format_call(sym, args, kw)  # :nodoc:
+      "#{sym}(#{format_args(args, kw)})"
     end
 
     # Class method to format a list of args (the part between the
     # parenthesis).
-    def format_args(args)
-      if args
-        args = args.map do |a|
-          FlexMock.forbid_mocking("<recursive call to mocked method in #inspect>") do
-            a.inspect
+    def format_args(args, kw)
+      args =
+        if args
+          args = args.map do |a|
+            FlexMock.forbid_mocking("<recursive call to mocked method in #inspect>") do
+              a.inspect
+            end
           end
+          args.join(', ')
+        else
+          "*args"
         end
-        args.join(', ')
-      else
-        "*args"
-      end
+
+      kw =
+        if kw.kind_of? HashMatcher
+          kw.inspect
+        elsif kw && !kw.empty?
+          kw = kw.transform_values do |v|
+            FlexMock.forbid_mocking("<recursive call to mocked method in #inspect>") do
+              v.inspect
+            end
+          end
+          kw.map { |k, v| "#{k}: #{v}" }.join(', ')
+        elsif kw.nil?
+          # Don't append **kwargs to signature if ruby version < 3
+          # in order to not break existing code still on ruby2
+          "**kwargs" unless RUBY_VERSION < "3"
+        end
+
+      [(args unless args.empty?), kw].compact.join(", ")
     end
 
     # Check will assert the block returns true.  If it doesn't, an

data/lib/flexmock/expectation.rb

@@ -37,11 +37,11 @@ class FlexMock
       @sym = sym
       @location = location
       @expected_args = nil
-      @expected_kw_args = nil
-      @expected_block = nil
+      @expected_kw = nil
       @count_validators = []
       @signature_validator = SignatureValidator.new(self)
       @count_validator_class = ExactCountValidator
+      @with_block = nil
       @actual_count = 0
       @return_value = nil
       @return_queue = []
@@ -52,7 +52,7 @@ class FlexMock
     end
 
     def to_s
-      FlexMock.format_call(@sym, @expected_args)
+      FlexMock.format_call(@sym, @expected_args, @expected_kw)
     end
 
     # Return a description of the matching features of the
@@ -64,7 +64,9 @@ class FlexMock
     #
     def description
       result = ["should_receive(#{@sym.inspect})"]
-      result << ".with(#{FlexMock.format_args(@expected_args)})" if @expected_args
+      if @expected_args || @expected_kw
+        result << ".with(#{FlexMock.format_args(@expected_args, @expected_kw)})"
+      end
       @count_validators.each do |validator|
         result << validator.describe
       end
@@ -85,63 +87,49 @@ class FlexMock
       FlexMock.framework_adapter.check(e.message) { false }
     end
 
-    def validate_signature(args)
-      @signature_validator.validate(args)
+    def validate_signature(args, kw, block)
+      @signature_validator.validate(args, kw, block)
     rescue SignatureValidator::ValidationFailed => e
       FlexMock.framework_adapter.check(e.message) { false }
     end
 
     # Verify the current call with the given arguments matches the
     # expectations recorded in this object.
-    def verify_call(*args, &block)
+    def verify_call(args, kw, block)
       validate_eligible
       validate_order
-      enhanced_args =
-        if block
-          args + [block]
-        else
-          args
-        end
-
-      validate_signature(enhanced_args)
+      validate_signature(args, kw, block)
       @actual_count += 1
-      perform_yielding(args, block)
-      return_value(args, block)
+      perform_yielding(block)
+      return_value(args, kw, block)
     end
 
     # Public return value (odd name to avoid accidental use as a
     # constraint).
-    def _return_value(args, block) # :nodoc:
-      return_value(args, block)
+    def _return_value(args, kw, block) # :nodoc:
+      return_value(args, kw, block)
     end
 
     # Find the return value for this expectation. (private version)
-    def return_value(args, block)
+    def return_value(args, kw, block)
       case @return_queue.size
       when 0
-        ret_block = lambda { |*a| @return_value }
+        ret_block = lambda { |*, **| @return_value }
       when 1
         ret_block = @return_queue.first
       else
         ret_block = @return_queue.shift
       end
-
-      if @expected_block
-        ret_block.call(*args, &block)
-      elsif block
-        ret_block.call(*args, block)
-      else
-        ret_block.call(*args)
-      end
+      ret_block.call(*args, **kw, &block)
     end
     private :return_value
 
     # Yield stored values to any blocks given.
-    def perform_yielding(args, block)
+    def perform_yielding(block)
       @return_value = nil
       unless @yield_queue.empty?
         values = (@yield_queue.size == 1) ? @yield_queue.first : @yield_queue.shift
-        if block
+        if block && block.respond_to?(:call)
           values.each do |v|
             @return_value = block.call(*v)
           end
@@ -185,44 +173,14 @@ class FlexMock
 
     # Does the argument list match this expectation's argument
     # specification.
-    def match_args(args)
-      expected_args =
-        if @expected_kw_args
-          if proc_matcher?(@expected_args&.last) && @expected_block.nil?
-            @expected_args[0..-2] + [@expected_kw_args, @expected_args[-1]]
-          else
-            (@expected_args || []) + [@expected_kw_args]
-          end
-        else
-          @expected_args
-        end
-
-      if @expected_block
-        expected_args = (expected_args || []) + [@expected_block]
-      end
-
-      ArgumentMatching.all_match?(expected_args, args)
-    end
-
-    def proc_matcher?(obj)
-      obj == Proc || obj == OPTIONAL_PROC_MATCHER
-    end
-
-    def with_optional_block
-      @expected_block = OPTIONAL_PROC_MATCHER
-    end
-
-    def with_block
-      @expected_block = Proc
-    end
-
-    def with_no_block
-      @expected_block = false
+    def match_args(args, kw, block)
+      ArgumentMatching.all_match?(@expected_args, @expected_kw, @expected_block, args, kw, block)
     end
 
     # Declare that the method should expect the given argument list.
-    def with(*args)
+    def with(*args, **kw)
       @expected_args = args
+      @expected_kw = kw
       self
     end
 
@@ -235,42 +193,71 @@ class FlexMock
     # arguments of any type.
     def with_any_args
       @expected_args = nil
+      @expected_kw = nil
       self
     end
 
     # Declare that the method can be called with any number of
     # arguments of any type.
-    def with_kw_args(matcher)
-      @expected_kw_args = matcher
+    def with_any_kw_args
+      @expected_kw = nil
       self
     end
 
     # Declare that the method can be called with any number of
     # arguments of any type.
-    def with_any_kw_args
-      @expected_kw_args = FlexMock.any
+    def with_any_positional_args
+      @expected_args = nil
+      self
+    end
+
+    # Declare that the method should be called with the given
+    # keyword arguments
+    def with_kw_args(kw)
+      @expected_kw = kw
+      self
+    end
+
+    # Declare that the call should have a block
+    def with_block
+      @expected_block = true
+      self
+    end
+
+    # Declare that the call should have a block
+    def with_no_block
+      @expected_block = false
+      self
+    end
+
+    def with_optional_block
+      @expected_block = nil
       self
     end
 
     # Validate general parameters on the call signature
     def with_signature(
-        required_arguments: 0, optional_arguments: 0, splat: false,
-        required_keyword_arguments: [], optional_keyword_arguments: [], keyword_splat: false)
+      required_arguments: 0, optional_arguments: 0, splat: false,
+      required_keyword_arguments: [], optional_keyword_arguments: [],
+      keyword_splat: false
+    )
       @signature_validator = SignatureValidator.new(
-          self,
-          required_arguments: required_arguments,
-          optional_arguments: optional_arguments,
-          splat: splat,
-          required_keyword_arguments: required_keyword_arguments,
-          optional_keyword_arguments: optional_keyword_arguments,
-          keyword_splat: keyword_splat)
+        self,
+        required_arguments: required_arguments,
+        optional_arguments: optional_arguments,
+        splat: splat,
+        required_keyword_arguments: required_keyword_arguments,
+        optional_keyword_arguments: optional_keyword_arguments,
+        keyword_splat: keyword_splat
+      )
       self
     end
 
     # Validate that the passed arguments match the method signature from the
     # given instance method
     def with_signature_matching(instance_method)
-      @signature_validator = SignatureValidator.from_instance_method(self, instance_method)
+      @signature_validator =
+        SignatureValidator.from_instance_method(self, instance_method)
       self
     end
 
@@ -405,16 +392,16 @@ class FlexMock
 
     def pass_thru(&block)
       block ||= lambda { |value| value }
-      and_return { |*args|
+      and_return { |*args, **kw|
         begin
-          block.call(@mock.flexmock_invoke_original(@sym, args))
+          block.call(@mock.flexmock_invoke_original(@sym, args, kw))
         rescue NoMethodError => e
           if e.name == @sym
             raise e, "#{e.message} while performing #pass_thru in expectation object #{self}"
           else
             raise
           end
-        end 
+        end
       }
     end
 

data/lib/flexmock/expectation_builder.rb

@@ -22,12 +22,12 @@ class FlexMock
     # hashes, and identifies the method names specified by each.  As each
     # method name is identified, create a mock expectation for it using the
     # supplied block.
-    def parse_should_args(mock, args, &block)  # :nodoc:
+    def parse_should_args(mock, args, kw, &block)  # :nodoc:
       result = CompositeExpectation.new
       args.each do |arg|
         case arg
         when Hash
-          arg.each do |k,v|
+          arg.each do |k, v|
             exp = create_expectation(mock, k, &block).and_return(v)
             result.add(exp)
           end
@@ -35,6 +35,12 @@ class FlexMock
           result.add(create_expectation(mock, arg, &block))
         end
       end
+
+      kw.each do |k, v|
+        exp = create_expectation(mock, k, &block).and_return(v)
+        result.add(exp)
+      end
+
       result
     end
 
@@ -86,7 +92,7 @@ class FlexMock
       names.each do |name|
         exp = mock.flexmock_find_expectation(name)
         if exp
-          next_mock = exp._return_value([], nil)
+          next_mock = exp._return_value([], {}, nil)
           check_proper_mock(next_mock, name)
         else
           next_mock = container.flexmock("demeter_#{name}")

data/lib/flexmock/expectation_director.rb

@@ -35,18 +35,16 @@ class FlexMock
     # but at least we will get a good failure message).  Finally,
     # check for expectations that don't have any argument matching
     # criteria.
-    def call(args, block = nil, call_record=nil)
-      find_args = args.dup
-      find_args << block if block
-      exp = find_expectation(*find_args)
+    def call(args, kw, block, call_record=nil)
+      exp = find_expectation(args, kw, block)
       call_record.expectation = exp if call_record
       FlexMock.check(
         proc { "no matching handler found for " +
-               FlexMock.format_call(@sym, args) +
+               FlexMock.format_call(@sym, args, kw) +
                "\nDefined expectations:\n  " +
                @expectations.map(&:description).join("\n  ") }
       ) { !exp.nil? }
-      returned_value = exp.verify_call(*args, &block)
+      returned_value = exp.verify_call(args, kw, block)
       returned_value
     end
 
@@ -56,11 +54,11 @@ class FlexMock
     end
 
     # Find an expectation matching the given arguments.
-    def find_expectation(*args) # :nodoc:
+    def find_expectation(args, kw, block) # :nodoc:
       if @expectations.empty?
-        find_expectation_in(@defaults, *args)
+        find_expectation_in(@defaults, args, kw, block)
       else
-        find_expectation_in(@expectations, *args)
+        find_expectation_in(@expectations, args, kw, block)
       end
     end
 
@@ -86,9 +84,9 @@ class FlexMock
 
     private
 
-    def find_expectation_in(expectations, *args)
-      expectations.find { |e| e.match_args(args) && e.eligible? } ||
-        expectations.find { |e| e.match_args(args) }
+    def find_expectation_in(expectations, args, kw, block)
+      expectations.find { |e| e.match_args(args, kw, block) && e.eligible? } ||
+        expectations.find { |e| e.match_args(args, kw, block) }
     end
   end
 

data/lib/flexmock/expectation_recorder.rb

@@ -23,8 +23,8 @@ class FlexMock
     end
 
     # Save any incoming messages to be played back later.
-    def method_missing(sym, *args, &block)
-      @expectations << [sym, args, block]
+    def method_missing(sym, *args, **kw, &block)
+      @expectations << [sym, args, kw, block]
       self
     end
 
@@ -33,8 +33,8 @@ class FlexMock
     # call).
     def apply(mock)
       obj = mock
-      @expectations.each do |sym, args, block|
-        obj = obj.send(sym, *args, &block)
+      @expectations.each do |sym, args, kw, block|
+        obj = obj.send(sym, *args, **kw, &block)
       end
     end
   end

data/lib/flexmock/explicit_needed.rb

@@ -31,9 +31,9 @@ class FlexMock
 
     WHITELIST = [:with_signature_matching]
 
-    def method_missing(sym, *args, &block)
+    def method_missing(sym, *args, **kw, &block)
       if explicit? || WHITELIST.include?(sym)
-        @expectation.send(sym, *args, &block)
+        @expectation.send(sym, *args, **kw, &block)
       else
         fail NoMethodError, "Cannot stub methods not defined by the base class\n" +
           "   Method:     #{@method_name}\n" +

data/lib/flexmock/partial_mock.rb

@@ -150,8 +150,8 @@ class FlexMock
     # to the result.
     #
     # See Expectation for a list of declarators that can be used.
-    def should_receive(*args)
-      flexmock_define_expectation(caller, *args)
+    def should_receive(*args, **kw)
+      flexmock_define_expectation(caller, *args, **kw)
     end
 
     def should_expect(*args)
@@ -161,16 +161,22 @@ class FlexMock
     # Invoke the original of a mocked method
     #
     # Usually called in a #and_return statement
-    def invoke_original(m, *args, &block)
+    def invoke_original(m, *args, **kw, &block)
       if block
         args << block
       end
-      flexmock_invoke_original(m, args)
+      flexmock_invoke_original(m, args, kw)
     end
 
     # Whether the given method's original definition has been stored
     def find_original_method(m)
-      it = @obj.method(m)
+      it =
+        if m.respond_to?(:to_str) || m.respond_to?(:to_sym)
+          @obj.method(m)
+        else
+          m
+        end
+
       while it && (it.owner != @proxy_definition_module)
         it = it.super_method
       end
@@ -203,15 +209,24 @@ class FlexMock
           @proxy_definition_module.method_defined?(m)
     end
 
-    def flexmock_define_expectation(location, *args)
-      EXP_BUILDER.parse_should_args(self, args) do |method_name|
+    def flexmock_plain_new_method?(m)
+      m.name == :new && m.owner == Class
+    end
+
+    def flexmock_define_expectation(location, *args, **kw)
+      EXP_BUILDER.parse_should_args(self, args, kw) do |method_name|
         if !has_proxied_method?(method_name)
           define_proxy_method(method_name)
         end
         ex = @mock.flexmock_define_expectation(location, method_name)
         if FlexMock.partials_verify_signatures
           if (existing_method = find_original_method(method_name))
-            ex.with_signature_matching(existing_method)
+            if flexmock_plain_new_method?(existing_method)
+              # Look for the signature of `initialize` instead
+              ex.with_signature_matching(@obj.instance_method(:initialize))
+            else
+              ex.with_signature_matching(existing_method)
+            end
           end
         end
         ex.mock = self
@@ -219,17 +234,17 @@ class FlexMock
       end
     end
 
-    def flexmock_find_expectation(*args)
-      @mock.flexmock_find_expectation(*args)
+    def flexmock_find_expectation(*args, **kw, &block)
+      @mock.flexmock_find_expectation(*args, **kw, &block)
     end
 
     def add_mock_method(method_name)
       proxy_module_eval do
-        define_method(method_name) { |*args, &block|
+        define_method(method_name) { |*args, **kw, &block|
           proxy = __flexmock_proxy or
             fail "Missing FlexMock proxy " +
                  "(for method_name=#{method_name.inspect}, self=\#{self})"
-          proxy.send(method_name, *args, &block)
+          proxy.send(method_name, *args, **kw, &block)
         }
       end
     end
@@ -265,9 +280,9 @@ class FlexMock
       end
 
       allocators.each do |allocate_method|
-        flexmock_define_expectation(location, allocate_method).and_return { |*args|
+        flexmock_define_expectation(location, allocate_method).and_return { |*args, **kw|
           create_new_mocked_object(
-            allocate_method, args, expectation_recorder, block)
+            allocate_method, args, kw, expectation_recorder, block)
         }
       end
       expectation_recorder
@@ -279,7 +294,7 @@ class FlexMock
         expectation_blocks    = @initialize_expectation_blocks = Array.new
         expectation_recorders = @initialize_expectation_recorders = Array.new
         @initialize_override = Module.new do
-          define_method :initialize do |*args, &block|
+          define_method :initialize do |*args, **kw, &block|
             if self.class.respond_to?(:__flexmock_proxy) && (mock = self.class.__flexmock_proxy)
               container = mock.flexmock_container
               mock = container.flexmock(self)
@@ -290,7 +305,7 @@ class FlexMock
                 r.apply(mock)
               end
             end
-            super(*args, &block)
+            super(*args, **kw, &block)
           end
         end
         override = @initialize_override
@@ -320,8 +335,8 @@ class FlexMock
     # (2) Pass to the block for custom configuration.
     # (3) Apply any recorded expecations
     #
-    def create_new_mocked_object(allocate_method, args, recorder, block)
-      new_obj = flexmock_invoke_original(allocate_method, args)
+    def create_new_mocked_object(allocate_method, args, kw, recorder, block)
+      new_obj = flexmock_invoke_original(allocate_method, args, kw)
       mock = flexmock_container.flexmock(new_obj)
       block.call(mock) unless block.nil?
       recorder.apply(mock)
@@ -331,15 +346,15 @@ class FlexMock
 
     # Invoke the original definition of method on the object supported by
     # the stub.
-    def flexmock_invoke_original(method, args)
+    def flexmock_invoke_original(method, args, kw)
       if (original_method = find_original_method(method))
         if Proc === args.last
           block = args.last
           args = args[0..-2]
         end
-        original_method.call(*args, &block)
+        original_method.call(*args, **kw, &block)
       else
-        @obj.__send__(:method_missing, method, *args, &block)
+        @obj.__send__(:method_missing, method, *args, **kw, &block)
       end
     end
 
@@ -373,8 +388,8 @@ class FlexMock
     end
 
     # Forward to the mock
-    def flexmock_received?(*args)
-      @mock.flexmock_received?(*args)
+    def flexmock_received?(*args, **kw)
+      @mock.flexmock_received?(*args, **kw)
     end
 
     # Forward to the mock
@@ -406,15 +421,15 @@ class FlexMock
 
     # Evaluate a block (or string) in the context of the singleton
     # class of the target partial object.
-    def target_class_eval(*args, &block)
-      target_singleton_class.class_eval(*args, &block)
+    def target_class_eval(*args, **kw, &block)
+      target_singleton_class.class_eval(*args, **kw, &block)
     end
 
     class ProxyDefinitionModule < Module
     end
 
     # Evaluate a block into the module we use to define the proxy methods
-    def proxy_module_eval(*args, &block)
+    def proxy_module_eval(*args, **kw, &block)
       if !@proxy_definition_module
         obj = @obj
         @proxy_definition_module = m = ProxyDefinitionModule.new do
@@ -426,7 +441,7 @@ class FlexMock
         end
         target_class_eval { prepend m }
       end
-      @proxy_definition_module.class_eval(*args, &block)
+      @proxy_definition_module.class_eval(*args, **kw, &block)
     end
 
     # Hide the existing method definition with a singleton defintion
@@ -445,15 +460,15 @@ class FlexMock
     def define_proxy_method(method_name)
       if method_name =~ /=$/
         proxy_module_eval do
-          define_method(method_name) do |*args, &block|
-            __flexmock_proxy.mock.__send__(method_name, *args, &block)
+          define_method(method_name) do |*args, **kw, &block|
+            __flexmock_proxy.mock.__send__(method_name, *args, **kw, &block)
           end
         end
       else
         proxy_module_eval <<-EOD
-          def #{method_name}(*args, &block)
+          def #{method_name}(*args, **kw, &block)
             FlexMock.verify_mocking_allowed!
-            __flexmock_proxy.mock.#{method_name}(*args, &block)
+            __flexmock_proxy.mock.#{method_name}(*args, **kw, &block)
           end
         EOD
       end

data/lib/flexmock/spy_describers.rb

@@ -1,25 +1,25 @@
 class FlexMock
 
     module SpyDescribers
-      def spy_description(spy, sym, args, options)
+      def spy_description(spy, sym, args, kw, options)
         result = "have received "
-        result << FlexMock.format_call(sym, args)
+        result << FlexMock.format_call(sym, args, kw)
         result << times_description(options[:times])
         result << block_description(options[:with_block])
         result
       end
 
-      def describe_spy_expectation(spy, sym, args, options={})
-        describe_spy(spy, sym, args, options)
+      def describe_spy_expectation(spy, sym, args, kw, options={})
+        describe_spy(spy, sym, args, kw, options)
       end
 
-      def describe_spy_negative_expectation(spy, sym, args, options={})
-        describe_spy(spy, sym, args, options, " NOT")
+      def describe_spy_negative_expectation(spy, sym, args, kw, options={})
+        describe_spy(spy, sym, args, kw, options, " NOT")
       end
 
-      def describe_spy(spy, sym, args, options, not_clause="")
+      def describe_spy(spy, sym, args, kw, options, not_clause="")
         result = "expected "
-        result << FlexMock.format_call(sym, args)
+        result << FlexMock.format_call(sym, args, kw)
         result << " to#{not_clause} be received by " << spy.inspect
         result << times_description(options[:times])
         result << block_description(options[:with_block])
@@ -44,7 +44,7 @@ class FlexMock
       def append_call_record(result, call_record)
         result <<
           "    " <<
-          FlexMock.format_call(call_record.method_name, call_record.args)
+          FlexMock.format_call(call_record.method_name, call_record.args, call_record.kw)
         if call_record.expectation
           result <<
             " matched by " <<

data/lib/flexmock/test_unit_assert_spy_called.rb

@@ -4,29 +4,36 @@ class FlexMock
   module TestUnitAssertions
     include FlexMock::SpyDescribers
 
-    def assert_spy_called(spy, method_name, *args)
-      _assert_spy_called(false, spy, method_name, *args)
+    def assert_spy_called(spy, method_name, *args, **kw)
+      _assert_spy_called(false, spy, method_name, *args, **kw)
     end
 
-    def assert_spy_not_called(spy, method_name, *args)
-      _assert_spy_called(true, spy, method_name, *args)
+    def assert_spy_not_called(spy, method_name, *args, **kw)
+      _assert_spy_called(true, spy, method_name, *args, **kw)
     end
 
     private
 
-    def _assert_spy_called(negative, spy, method_name, *args)
+    def _assert_spy_called(negative, spy, method_name, *args, **kw)
       options = {}
       if method_name.is_a?(Hash)
         options = method_name
         method_name = args.shift
       end
+
+      # Prior to ruby3, kw args would be matched in *args
+      # thus, expecting any args (:_) implied also expecting
+      # any kw args.
+      kw = :_ if args == [:_]
+
       args = nil if args == [:_]
-      bool = spy.flexmock_received?(method_name, args, options)
+      kw = nil if kw == :_
+      bool = spy.flexmock_received?(method_name, args, kw, options)
       if negative
         bool = !bool
-        message = describe_spy_negative_expectation(spy, method_name, args, options)
+        message = describe_spy_negative_expectation(spy, method_name, args, kw, options)
       else
-        message = describe_spy_expectation(spy, method_name, args, options)
+        message = describe_spy_expectation(spy, method_name, args, kw, options)
       end
       assert bool, message
     end

data/lib/flexmock/validators.rb

@@ -212,74 +212,28 @@ class FlexMock
     #
     # @param [Array] args
     # @raise ValidationFailed
-    def validate(args)
-      args = args.dup
-      kw_args = Hash.new
-
-      last_is_proc = false
-      begin
-        if args.last.kind_of?(Proc)
-          args.pop
-          last_is_proc = true
-        end
-      rescue NoMethodError
-      end
-
-      last_is_kw_hash = false
-      if expects_keyword_arguments?
-        last_is_kw_hash =
-          begin
-            args.last.kind_of?(Hash)
-          rescue NoMethodError
-          end
+    def validate(args, kw, block)
+      kw ||= Hash.new
 
-        if last_is_kw_hash
-          kw_args = args.pop
-        elsif requires_keyword_arguments?
-          raise ValidationFailed, "#{@exp} expects keyword arguments but none were provided"
-        end
+      if expects_keyword_arguments? && requires_keyword_arguments? && kw.empty?
+        raise ValidationFailed, "#{@exp} expects keyword arguments but none were provided"
       end
 
-      # There is currently no way to disambiguate "given a block" from "given a
-      # proc as last argument" ... give some leeway in this case
-      positional_count = args.size
-
-      if required_arguments > positional_count
-        if requires_keyword_arguments?
-          raise ValidationFailed, "#{@exp} expects at least #{required_arguments} positional arguments but got only #{positional_count}"
-        end
-
-        if (required_arguments - positional_count) == 1 && (last_is_kw_hash || last_is_proc)
-          if last_is_kw_hash
-            last_is_kw_hash = false
-            kw_args = Hash.new
-          else
-            last_is_proc = false
-          end
-          positional_count += 1
-        elsif (required_arguments - positional_count) == 2 && (last_is_kw_hash && last_is_proc)
-          last_is_kw_hash = false
-          kw_args = Hash.new
-          last_is_proc = false
-          positional_count += 2
-        else
-          raise ValidationFailed, "#{@exp} expects at least #{required_arguments} positional arguments but got only #{positional_count}"
-        end
+      if required_arguments > args.size
+        raise ValidationFailed, "#{@exp} expects at least #{required_arguments} positional arguments but got only #{args.size}"
       end
 
-      if !splat? && (required_arguments + optional_arguments) < positional_count
-        if !last_is_proc || (required_arguments + optional_arguments) < positional_count - 1
-          raise ValidationFailed, "#{@exp} expects at most #{required_arguments + optional_arguments} positional arguments but got #{positional_count}"
-        end
+      if !splat? && (required_arguments + optional_arguments) < args.size
+        raise ValidationFailed, "#{@exp} expects at most #{required_arguments + optional_arguments} positional arguments but got #{args.size}"
       end
 
       missing_keyword_arguments = required_keyword_arguments.
-        find_all { |k| !kw_args.has_key?(k) }
+        find_all { |k| !kw.has_key?(k) }
       if !missing_keyword_arguments.empty?
         raise ValidationFailed, "#{@exp} missing required keyword arguments #{missing_keyword_arguments.map(&:to_s).sort.join(", ")}"
       end
       if !keyword_splat?
-        kw_args.each_key do |k|
+        kw.each_key do |k|
           if !optional_keyword_arguments.include?(k) && !required_keyword_arguments.include?(k)
             raise ValidationFailed, "#{@exp} given unexpected keyword argument #{k}"
           end
@@ -313,4 +267,3 @@ class FlexMock
     end
   end
 end
-

data/lib/flexmock/version.rb

@@ -1,3 +1,3 @@
 class FlexMock
-    VERSION = "2.4.0"
+    VERSION = "3.0.0"
 end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: flexmock
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Jim Weirich
 - Sylvain Joyeux
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2024-08-20 00:00:00.000000000 Z
@@ -157,7 +157,7 @@ homepage: https://github.com/doudou/flexmock
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -165,15 +165,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: Simple and Flexible Mock Objects for Testing
 test_files: []