flexmock 2.4.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95477346c9b4f5310e7aab502150273b0473194442fdee505ab366efbbba77bf
-  data.tar.gz: cf44602d7ddfa3197ff847e476da46adc9b82a07382c100e2eb149abc56ae285
+  metadata.gz: 97fdfec71cb9dd687df62403b26eb8d4d24e4b28ec7f35f5e2d5f3ac6ffed943
+  data.tar.gz: 8f250a12f731099db17e9fcea78b92e0b92ac523376a34e06b5295f3a17ec996
 SHA512:
-  metadata.gz: bc7337acd6e30ede212fbe23f44149c9b76693dacec228e06fac7b4f60bb684d9a641b2fd3b5be3b7fe401cc22bc8eeaff01883808fd594c6d7e6209f9128db5
-  data.tar.gz: cc11b26a6a3508adae240889c9c1e1c2484876b965f6dc82f54282061c8405bcf52d8e5b6f15a963239c9cf939cd50f9c2c74ad82bf9d469bec1a25d021c1ae8
+  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,44 @@ 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
@@ -556,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>
 
@@ -765,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)
 ```
 
@@ -782,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.2"
+  s.required_ruby_version = ">= 3.0"
 
   s.license = 'MIT'
 

data/lib/flexmock/argument_matchers.rb

@@ -62,41 +62,11 @@ class FlexMock
     def ===(target)
       @hash.all? { |k, v| target[k] == v }
     end
-    def inspect
-      "hsh(#{@hash.inspect})"
-    end
-  end
-
-  ####################################################################
-  # Match hashes that match all the fields of +hash+.
-  class KwArgsMatcher
-    def initialize(expected)
-      @expected = expected
-    end
-    def ===(target)
-      return false unless target.kind_of?(Hash)
-      matching = @expected.all? do |k, v|
-        v === target[k] || v == target[k]
-      end
-      return false unless matching
-
-      @expected.size == target.size
+    def empty?
+      @hash.empty?
     end
     def inspect
-      args = @expected.map do |k, v|
-        k_s = case k
-        when Symbol
-          "#{k}: "
-        else
-          "#{k.inspect} => "
-        end
-
-        v_s = FlexMock.forbid_mocking("<recursive call to mocked method in #inspect>") do
-          v.inspect
-        end
-        "#{k_s}#{v_s}"
-      end
-      args.join(", ")
+      "hsh(#{@hash.inspect})"
     end
   end
 
@@ -113,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

@@ -3,8 +3,7 @@ class FlexMock
   # A composite expectation allows several expectations to be grouped into a
   # single composite and then apply the same constraints to  all expectations
   # in the group.
-  class CompositeExpectation < BasicObject
-    attr_reader :expectations
+  class CompositeExpectation
 
     # Initialize the composite expectation.
     def initialize
@@ -17,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
@@ -39,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, orig_block)
+  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,35 +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
-    end
 
-    # Class method to format a list of args (the part between the
-    # parenthesis).
-    def format_kw_args(args)
-      if args
-        FlexMock.forbid_mocking("<recursive call to mocked method in #inspect>") do
-          args.inspect
+      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
-      else
-        "**args"
-      end
+
+      [(args unless args.empty?), kw].compact.join(", ")
     end
 
     # Check will assert the block returns true.  If it doesn't, an