muack 1.3.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 44cee556b89d8eb6f0b0cf73e9082a41c24f0c07
-  data.tar.gz: 3843d7a99fd975384d3faccce6b4235ce3d273f3
+SHA256:
+  metadata.gz: 012f658496e2711ec98bf468ffbb58ddfe339eafe03c4618e3cc9b91025b0b03
+  data.tar.gz: 505dbe6462efb20502468cf75f23459afa4589a8cd9d5f5ebc24eaf9a4d004ea
 SHA512:
-  metadata.gz: 5a50371ce353f2063dcbf323e3089b51a8c3e45bb1dd0b1b14882dd0849b4d499e5c61a6dc64ac7a4db9ecd84a11085db9ad95507633fcdaac029fd9b5551611
-  data.tar.gz: b21dbd44169cea461871d4d67ddc9cdb7fecf0b41378b118046b82093e5690165da8c69f907f20d602da8d935c7e50b06896c92ae4149faeb9f641ba6e4000a5
+  metadata.gz: 9b538db391549b7da213ab0be7af6f58f71682277e897aae341285daecb47aad5bedfee581e0602908df4a5be55e5faa471d4bf8127a5cd68190058e22dc422c
+  data.tar.gz: 2d3ca26974fa4b73f2dd394ccf0323ebb720a40f3f6c30c72736680f4399f714a4a141998abf799dc846c4f1e0d2d4e3716fb719a256cfd2dd3618a57572be27

data/.travis.yml

@@ -1,11 +1,22 @@
-
+sudo: false
 language: ruby
-rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - rbx-2
-  - jruby
 
-install: 'bundle install --retry=3'
-script: 'ruby -r bundler/setup -S rake test'
+install: 'gem update --system; gem install bundler; bundle install --retry=3'
+before_script: unset CI
+script: 'ruby -vwr bundler/setup -S rake test'
+
+matrix:
+  include:
+    - rvm: 2.3
+    - rvm: 2.4
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: 2.5
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: 2.6
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: 2.7
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: ruby-head
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: jruby-9.2
+      env: RUBYOPT=--enable-frozen-string-literal

data/CHANGES.md

@@ -1,5 +1,52 @@
 # CHANGES
 
+## Muack 1.6.0 -- 2020-12-06
+
+### Enhancement
+
+* Fix a few cases for mocking against modules/classes with prepended modules,
+  especially when `any_instance_of` is also used in combination. Previously,
+  it's either not mocking correctly or it may affect modules/classes which
+  also use the same prepended modules. For mocking prepended methods, an
+  internal `MuackPrepended` module will be prepended into the modules/classes
+  to properly override the prepended methods. This module cannot be removed
+  between tests because there's no way to do that with current Rubies.
+* Performance could be potentially slightly improved with Ruby 2.6+
+
+## Muack 1.5.1 -- 2020-12-06
+
+### Bugs fixed
+
+* Eliminated potential keyword arguments warnings for `initialize` when
+  mocking against `new`.
+
+## Muack 1.5.0 -- 2020-11-28
+
+### Bugs fixed
+
+* Properly handle prepended objects
+* Properly restore method visibilities for singleton methods
+
+### Enhancement
+
+* Eliminated any potential keyword arguments warnings to be future proof
+* Some major internal restructure
+
+## Muack 1.4.0 -- 2015-11-21
+
+### Incompatible changes / Enhancement
+
+* Spies would now do pattern matching like stubs for matching
+  method arguments. This could be an incompatible change if you're
+  relying on spies checking the order for the same method calls.
+  This change would make spies and stubs more similar. If you are
+  really into a specific order, use mocks instead.
+
+## Muack 1.3.2 -- 2015-06-11
+
+* Fixed a bug for `where`, `having`, and `allowing` which should distinguish
+  between `nil` and `undefined` (which does not have a key in a hash)
+
 ## Muack 1.3.1 -- 2015-05-27
 
 * Fixed a bug for `where`, `having`, and `allowing` which would raise an

data/Gemfile

@@ -8,7 +8,3 @@ gem 'pork'
 
 gem 'simplecov', :require => false if ENV['COV']
 gem 'coveralls', :require => false if ENV['CI']
-
-platform :rbx do
-  gem 'rubysl-singleton' # used in rake
-end

data/README.md

@@ -1,4 +1,4 @@
-# Muack [![Build Status](https://secure.travis-ci.org/godfat/muack.png?branch=master)](http://travis-ci.org/godfat/muack) [![Coverage Status](https://coveralls.io/repos/godfat/muack/badge.png?branch=master)](https://coveralls.io/r/godfat/muack?branch=master)
+# Muack [![Build Status](https://secure.travis-ci.org/godfat/muack.png?branch=master)](http://travis-ci.org/godfat/muack) [![Coverage Status](https://coveralls.io/repos/github/godfat/muack/badge.png)](https://coveralls.io/github/godfat/muack) [![Join the chat at https://gitter.im/godfat/muack](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/muack)
 
 by Lin Jen-Shin ([godfat](http://godfat.org))
 
@@ -7,6 +7,7 @@ by Lin Jen-Shin ([godfat](http://godfat.org))
 * [github](https://github.com/godfat/muack)
 * [rubygems](https://rubygems.org/gems/muack)
 * [rdoc](http://rdoc.info/github/godfat/muack)
+* [issues](https://github.com/godfat/muack/issues) (feel free to ask for support)
 
 ## DESCRIPTION:
 
@@ -25,7 +26,7 @@ Muack is much simpler and thus much faster and much more consistent.
 
 ## REQUIREMENTS:
 
-* Tested with MRI (official CRuby), Rubinius and JRuby.
+* Tested with MRI (official CRuby) and JRuby.
 
 ## INSTALLATION:
 
@@ -39,14 +40,14 @@ Here's a quick example using [Pork][].
 require 'pork/auto'
 require 'muack'
 
-include Muack::API
-
 describe 'Hello' do
+  include Muack::API
+
   before{ Muack.reset  }
   after { Muack.verify }
 
   would 'say world!' do
-    str = 'Hello'
+    str = 'Hello'.dup
     mock(str).say('!'){ |arg| "World#{arg}" }
     str.say('!').should.eq 'World!'
   end
@@ -98,7 +99,7 @@ p obj.name     # 'obj'
 p Muack.verify # true
 ```
 
-Which is roughly semantically equivalent to using a stub with a spy:
+Which is similar to using a stub with a spy:
 
 ``` ruby
 obj = Object.new
@@ -143,6 +144,11 @@ p Muack.verify # true
 However you should not mix mocks and stubs with the same method, or you
 might encounter some unexpected result. Jump to _Caveat_ for more detail.
 
+The other differences for stubs and spies, please check
+[Pattern Matching for stubs and spies][pattern-matching].
+In short, stubs and spies would do some kind of pattern matching,
+making the order of the same method irrelevant.
+
 On the other hand, stubs aren't limited to testing. If we want to monkey
 patching something, stubs could be useful as we don't care how many times
 the injected methods are called. Jump to _Muack as a mocky patching library_
@@ -167,7 +173,7 @@ affecting the others. This is helpful in the cases of mocking some very
 basic objects like Time, without causing too much side effect.
 
 ``` ruby
-name = 'str'
+name = 'str'.dup
 stub(name).to_s{ 'hi'       }
 stub(Time).new { Time.at(0) }
 mock(Time).now { Time.new   }
@@ -269,7 +275,7 @@ into proxy mode we simply do not provide any block to the injected method,
 but just name it. Here's an example:
 
 ``` ruby
-str = 'str'
+str = 'str'.dup
 mock(str).reverse
 p str.reverse  # 'rts'
 p Muack.verify # true
@@ -279,7 +285,7 @@ Note that if reverse was not called exactly once, the mock would complain.
 We could also use stub + spy to do the same thing as well:
 
 ``` ruby
-str = 'str'
+str = 'str'.dup
 stub(str).reverse
 p str.reverse  # 'rts'
 spy(str).reverse
@@ -326,7 +332,7 @@ If the order is reversed, then it would always return the original value,
 because the proxy would always match, and Muack would stop searching the
 next stub.
 
-[pattern-matching]: #arguments-verifiers-satisfy
+[pattern-matching]: #pattern-matching-for-stubs-and-spies
 
 #### any_instance_of mode
 
@@ -446,7 +452,7 @@ p Muack.verify # true
 
 Note that it does not make sense to specify `times` for stubs, because
 stubs don't care about times. Spies do, though. So this is also
-semantically equivalent to below:
+similar to below:
 
 ``` ruby
 obj = Object.new
@@ -618,7 +624,7 @@ our own behaviour, then we already have full control of the arguments.
 There's no points to use both. This also applies to `peek_return`.
 
 ``` ruby
-str = 'ff'
+str = 'ff'.dup
 mock(str).to_i.with_any_args.peek_args{ |radix| radix * 2 }
 p str.to_i(8)  # 255
 p Muack.verify # true
@@ -649,7 +655,7 @@ might just want to take a look at the return? Here's an example using
 `peek_return` to modify the original return value.
 
 ``` ruby
-str = 'ff'
+str = 'ff'.dup
 mock(str).to_i.with_any_args.peek_return{ |int| int * 2 }
 p str.to_i(16) # 510
 p Muack.verify # true
@@ -708,6 +714,8 @@ obj.say{ |msg| p msg } # 'Hi'
 p Muack.verify  # true
 ```
 
+#### Pattern Matching for stubs and spies
+
 Moreover, we could also have stubs on the same method for different
 arguments. We could think of this as a sort of pattern matching, and Muack
 would try to find the best matched stub for us.
@@ -722,7 +730,8 @@ p Muack.verify # true
 ```
 
 If `obj.find(2)` is called and Muack cannot find a matched stub, it would
-raise a `Muack::Unexpected` and list the candidates for us.
+raise a `Muack::Unexpected` and list the candidates for us. This also
+applies to spies.
 
 However, What if we don't want to be so exact? Then we should use verifiers.
 We'll introduce each of them in next section. Note that verifiers
@@ -824,7 +833,7 @@ p Muack.verify # true
 
 ``` ruby
 obj = Object.new
-mock(obj).say(where(:a => is_a(Fixnum))){ |arg| arg }
+mock(obj).say(where(:a => is_a(Integer))){ |arg| arg }
 p obj.say(:a => 0) # {:a => 0}
 p Muack.verify # true
 ```
@@ -833,7 +842,7 @@ Note that this could be recursive.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(where(:a => {:b => [is_a(Fixnum)]})){ |arg| arg[:a] }
+mock(obj).say(where(:a => {:b => [is_a(Integer)]})){ |arg| arg[:a] }
 p obj.say(:a => {:b => [0]}) # {:b => [0]}
 p Muack.verify # true
 ```
@@ -854,7 +863,7 @@ Note that this could be recursive.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(having(:a => {:b => [is_a(Fixnum)]})){ |arg| arg[:c] }
+mock(obj).say(having(:a => {:b => [is_a(Integer)]})){ |arg| arg[:c] }
 p obj.say(:a => {:b => [1]}, :c => 2) # 2
 p Muack.verify # true
 ```
@@ -875,7 +884,7 @@ Note that this could be recursive.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(allowing(:a => {:b => is_a(Fixnum), :c => 1})){ |arg| arg[:a] }
+mock(obj).say(allowing(:a => {:b => is_a(Integer), :c => 1})){ |arg| arg[:a] }
 p obj.say(:a => {:b => 2}) # {:b => 2}
 p Muack.verify # true
 ```
@@ -1114,7 +1123,7 @@ Consider we have two classes:
 
 ```  ruby
 Food = Class.new
-User = Class.new{ attr_accessor :food }
+User = Class.new(Struct.new(:food))
 ```
 
 And we could make sure User#food is always a kind of `Food` by putting this
@@ -1141,7 +1150,7 @@ verifiers. For example, we could do this to check if the food is frozen:
 
 ``` ruby
 Food = Class.new
-User = Class.new{ attr_accessor :food }
+User = Class.new(Struct.new(:food))
 
 FoodFrozen = Class.new(Muack::Satisfying) do
   def match actual_arg
@@ -1201,8 +1210,8 @@ Or, I am happy to break legacy.
 ## USERS:
 
 * [Rib][]
-* [rest-core](https://github.com/cardinalblue/rest-core)
-* [rest-more](https://github.com/cardinalblue/rest-more)
+* [rest-core](https://github.com/godfat/rest-core)
+* [rest-more](https://github.com/godfat/rest-more)
 
 ## CONTRIBUTORS:
 
@@ -1210,9 +1219,9 @@ Or, I am happy to break legacy.
 
 ## LICENSE:
 
-Apache License 2.0
+Apache License 2.0 (Apache-2.0)
 
-Copyright (c) 2013-2015, Lin Jen-Shin (godfat)
+Copyright (c) 2013-2020, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,14 +1,13 @@
 
 begin
-  require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+  require "#{__dir__}/task/gemgem"
 rescue LoadError
-  sh 'git submodule update --init'
+  sh 'git submodule update --init --recursive'
   exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
 end
 
-Gemgem.init(dir) do |s|
+Gemgem.init(__dir__) do |s|
   require 'muack/version'
   s.name    = 'muack'
   s.version = Muack::VERSION
-  %w[].each{ |g| s.add_runtime_dependency(g) }
 end

data/lib/muack/block.rb

@@ -1,17 +1,6 @@
 
-module Muack
-  class Block
-    attr_accessor :block, :context
-    def initialize block, context=nil
-      self.block, self.context = block, context
-    end
-
-    def call *args, &actual_block
-      if context # ruby: no way to pass actual_block to instance_exec
-        context.instance_exec(*args, &block)
-      else
-        block.call(*args, &actual_block)
-      end
-    end
-  end
+if RUBY_VERSION < '2.7'
+  require 'muack/block_26'
+else
+  require 'muack/block_27'
 end

data/lib/muack/block_26.rb

@@ -0,0 +1,16 @@
+
+module Muack
+  class Block < Struct.new(:block, :context)
+    def initialize block, context=nil
+      super
+    end
+
+    def call(*args, &block)
+      if context
+        context.instance_exec(*args, &block)
+      else
+        block.call(*args, &block)
+      end
+    end
+  end
+end

data/lib/muack/block_27.rb

@@ -0,0 +1,16 @@
+
+module Muack
+  class Block < Struct.new(:block, :context)
+    def initialize block, context=nil
+      super
+    end
+
+    def call(...)
+      if context
+        context.instance_exec(...)
+      else
+        block.call(...)
+      end
+    end
+  end
+end

data/lib/muack/coat.rb

@@ -4,7 +4,7 @@ require 'muack/mock'
 module Muack
   class Coat < Mock
     # used for mocked object to dispatch mocked method
-    def __mock_dispatch msg, actual_args
+    def __mock_dispatch actual_call
       defi = super
       if __mock_defis[defi.msg].empty?
         __mock_reset_method(defi)

data/lib/muack/definition.rb

@@ -1,7 +1,8 @@
 
 module Muack
-  Definition  = Class.new(Struct.new(:msg, :args, :returns,
-                                     :peek_args, :peek_return,
-                                     :original_method))
+  Definition  = Struct.new(:msg, :args, :returns,
+                           :peek_args, :peek_return,
+                           :target, :original_method, :visibility)
+  ActualCall  = Struct.new(:msg, :args, :block)
   WithAnyArgs = Object.new
 end

data/lib/muack/failure.rb

@@ -12,11 +12,12 @@ module Muack
 
   class Unexpected < Failure
     attr_reader :was
-    def initialize obj, expected_defis, msg, args
-      @was = "#{obj.inspect}.#{msg}(" \
-             "#{args.map(&:inspect).join(', ')})"
+    def initialize obj, expected_defis, actual_call
+      args = actual_call.args.map(&:inspect)
+      @was = "#{obj.inspect}.#{actual_call.msg}(#{args.join(', ')})"
+
       if expected_defis.empty?
-        super("\nUnexpected call: #{@was}")
+        super("\nUnexpected call: #{was}")
       else
         build_expected(obj, expected_defis)
         super("\nExpected: #{expected}\n but was: #{was}")

data/lib/muack/mock.rb

@@ -6,8 +6,6 @@ require 'muack/block'
 require 'muack/error'
 
 module Muack
-  EmptyBlock = proc{}
-
   class Mock < BasicObject
     attr_reader :object
     def initialize object
@@ -24,8 +22,8 @@ module Muack
     end
 
     # Public API: Define mocked method
-    def method_missing msg, *args, &block
-      defi = Definition.new(msg, args, block)
+    def method_missing msg, *args, &returns
+      defi = Definition.new(msg, args, returns)
       if injected = __mock_injected[defi.msg]
         defi.original_method = injected.original_method
       else
@@ -51,49 +49,42 @@ module Muack
     end
 
     # used for mocked object to dispatch mocked method
-    def __mock_dispatch msg, actual_args
-      if defi = __mock_defis[msg].shift
+    def __mock_dispatch actual_call
+      if defi = __mock_defis[actual_call.msg].shift
         __mock_disps_push(defi)
-        if __mock_check_args(defi.args, actual_args)
+        if __mock_check_args(defi, actual_call)
           defi
         else
           Mock.__send__(:raise, # Wrong argument
-            Unexpected.new(object, [defi], msg, actual_args))
+            Unexpected.new(object, [defi], actual_call))
         end
       else
-        defis = __mock_disps[msg]
-        if expected = defis.find{ |d| __mock_check_args(d.args, actual_args) }
-          Mock.__send__(:raise, # Too many times
-            Expected.new(object, expected, defis.size, defis.size+1))
-        else
-          Mock.__send__(:raise, # Wrong argument
-            Unexpected.new(object, defis, msg, actual_args))
-        end
+        __mock_failed(actual_call)
       end
     end
 
     # used for mocked object to dispatch mocked method
-    def __mock_dispatch_call context, disp, actual_args, actual_block, &_yield
-      args = if disp.peek_args
-               __mock_block_call(context, disp.peek_args,
-                                 actual_args, actual_block, true)
-             else
-               actual_args
-             end
-
-      ret = if disp.returns
-              __mock_block_call(context, disp.returns,
-                                args, actual_block, true)
-            elsif disp.original_method # proxies for singleton methods
-              context.__send__(disp.original_method, *args, &actual_block)
-            else # proxies for instance methods
-              # need the original context for calling `super`
-              # ruby: can't pass a block to yield, so we name it _yield
-              _yield.call(args, &actual_block)
-            end
+    def __mock_dispatch_call context, disp, actual_call, &proxy_super
+      # resolving arguments
+      call =
+        if disp.peek_args
+          args = __mock_block_call(context, disp.peek_args, actual_call)
+          ActualCall.new(actual_call.msg, args, actual_call.block)
+        else
+          actual_call
+        end
 
+      # retrieve actual return
+      ret =
+        if disp.returns
+          __mock_block_call(context, disp.returns, call)
+        else
+          __mock_proxy_call(context, disp, call, proxy_super)
+        end
+
+      # resolving return
       if disp.peek_return
-        __mock_block_call(context, disp.peek_return, ret, EmptyBlock, false)
+        __mock_block_call(context, disp.peek_return, ret, true)
       else
         ret
       end
@@ -102,9 +93,9 @@ module Muack
     # used for Muack::Session#verify
     def __mock_verify
       __mock_defis.values.all?(&:empty?) || begin
-        msg, defis_with_same_msg = __mock_defis.find{ |_, v| v.size > 0 }
+        msg, defis_with_same_msg = __mock_defis.find{ |_, v| v.any? }
         args, defis = defis_with_same_msg.group_by(&:args).first
-        dsize = __mock_disps[msg].select{ |d| d.args == args }.size
+        dsize = __mock_disps[msg].count{ |d| d.args == args }
         Mock.__send__(:raise,   # Too little times
           Expected.new(object, defis.first, defis.size + dsize, dsize))
       end
@@ -121,80 +112,207 @@ module Muack
     private
     def __mock_inject_method defi
       __mock_injected[defi.msg] = defi
-      target = object.singleton_class # would be the class in AnyInstanceOf
-      privilege = Mock.store_original_method(target, defi)
-      __mock_inject_mock_method(target, defi, privilege)
+      target = Mock.prepare_target(object.singleton_class, defi.msg)
+      defi.target = target
+      Mock.store_original_method(target, defi)
+      __mock_inject_mock_method(target, defi)
     end
 
     def __mock_reset_method defi
-      object.singleton_class.module_eval do
+      defi.target.module_eval do
         remove_method(defi.msg)
         # restore original method
-        if instance_methods(false).include?(defi.original_method) ||
-           private_instance_methods(false).include?(defi.original_method)
+        if defi.original_method &&
+           Mock.direct_method_defined?(self, defi.original_method)
           alias_method(defi.msg, defi.original_method)
+          __send__(defi.visibility, defi.msg)
           remove_method(defi.original_method)
         end
       end
     end
 
-    def self.store_original_method klass, defi
-      privilege = if klass.instance_methods(false).include?(defi.msg)
-        :public # TODO: forget about protected methods?
-      elsif klass.private_instance_methods(false).include?(defi.msg)
-        :private
+    if ::Class.instance_method(:method_defined?).arity == 1 # Ruby 2.5-
+      def self.direct_method_defined? mod, msg
+        mod.public_instance_methods(false).include?(msg) ||
+          mod.protected_instance_methods(false).include?(msg) ||
+          mod.private_instance_methods(false).include?(msg)
+      end
+
+      def self.method_visibility mod, msg
+        if mod.public_instance_methods(false).include?(msg)
+          :public
+        elsif mod.protected_instance_methods(false).include?(msg)
+          :protected
+        elsif mod.private_instance_methods(false).include?(msg)
+          :private
+        end
+      end
+    else # Ruby 2.6+
+      def self.direct_method_defined? mod, msg
+        mod.method_defined?(msg, false) || # this doesn't cover private method
+          mod.private_method_defined?(msg, false)
+      end
+
+      def self.method_visibility mod, msg
+        if mod.public_method_defined?(msg, false)
+          :public
+        elsif mod.protected_method_defined?(msg, false)
+          :protected
+        elsif mod.private_method_defined?(msg, false)
+          :private
+        end
+      end
+    end
+
+    def self.prepare_target singleton_class, msg
+      if singleton_class == singleton_class.ancestors.first # no prepended mod
+        singleton_class
+      else # check if we need to prepend an internal module to override
+        index = singleton_class.ancestors.index(singleton_class)
+        prepended_modules = singleton_class.ancestors[0...index]
+
+        if prepended_modules.find{ |m| direct_method_defined?(m, msg) }
+          # prepend an internal module to override the prepended module(s)
+          name = :MuackPrepended
+          if singleton_class.const_defined?(name)
+            singleton_class.const_get(name)
+          else
+            prepended = ::Module.new
+            singleton_class.const_set(name, prepended)
+            singleton_class.private_constant(name)
+            singleton_class.prepend(prepended)
+            prepended
+          end
+        else # we don't need to override so singleton class is enough
+          singleton_class
+        end
       end
+    end
 
-      return :public unless privilege
-      # store original method
-      original_method = find_new_name(klass, defi.msg)
-      klass.__send__(:alias_method, original_method, defi.msg)
-      defi.original_method = original_method
-      privilege
+    def self.store_original_method mod, defi
+      if visibility = method_visibility(mod, defi.msg)
+        original_method = find_new_name(mod, defi.msg)
+        mod.__send__(:alias_method, original_method, defi.msg)
+        defi.original_method = original_method
+        defi.visibility = visibility
+      else
+        defi.visibility = :public
+      end
     end
 
-    def self.find_new_name klass, message, level=0
+    def self.find_new_name mod, message, level=0
       if level >= (::ENV['MUACK_RECURSION_LEVEL'] || 9).to_i
         raise CannotFindInjectionName.new(level+1, message)
       end
 
       new_name = "__muack_#{name}_#{level}_#{message}".to_sym
-      if klass.instance_methods(false).include?(new_name)
-        find_new_name(klass, message, level+1)
+      if direct_method_defined?(mod, new_name)
+        find_new_name(mod, message, level+1)
       else
         new_name
       end
     end
 
-    def __mock_inject_mock_method target, defi, privilege=:public
+    def __mock_inject_mock_method target, defi
       mock = self # remember the context
       target.__send__(:define_method, defi.msg){ |*actual_args, &actual_block|
-        disp = mock.__mock_dispatch(defi.msg, actual_args)
-        mock.__mock_dispatch_call(self, disp, actual_args,
-                                              actual_block) do |args, &block|
-          super(*args, &block)
+        actual_call = ActualCall.new(defi.msg, actual_args, actual_block)
+        disp = mock.__mock_dispatch(actual_call)
+        mock.__mock_dispatch_call(self, disp, actual_call) do |call, has_kargs|
+          # need the original context for calling `super`
+          if has_kargs && kargs = call.args.last
+            super(*call.args[0...-1], **kargs, &call.block)
+          else
+            super(*call.args, &call.block)
+          end
         end
       }
-      target.__send__(privilege, defi.msg)
+      target.__send__(defi.visibility, defi.msg)
+    end
+
+    # used for __mock_dispatch
+    def __mock_failed actual_call, disps=__mock_disps[actual_call.msg]
+      if expected = __mock_find_checked_difi(disps, actual_call)
+        Mock.__send__(:raise, # Too many times
+          Expected.new(object, expected, disps.size, disps.size+1))
+      else
+        Mock.__send__(:raise, # Wrong argument
+          Unexpected.new(object, disps, actual_call))
+      end
     end
 
     # used for __mock_dispatch_call
-    def __mock_block_call context, block, actual_args, actual_block, splat
-      return unless block
+    def __mock_block_call context, block, actual_call, peek_return=false
       # for AnyInstanceOf, we don't have the actual context at the time
       # we're defining it, so we update it here
-      block.context = context if block.kind_of?(Block)
-      if splat
-        block.call(*actual_args, &actual_block)
-      else # peek_return doesn't need splat
-        block.call(actual_args, &actual_block)
+      if block.kind_of?(Block)
+        block.context = context
+        instance_exec_block = block.block
+      end
+
+      if peek_return # actual_call is the actual return in this case
+        block.call(actual_call, &instance_exec_block)
+      else
+        actual_block = actual_call.block || instance_exec_block
+        if __mock_block_with_kargs?(instance_exec_block || block) &&
+           kargs = actual_call.args.last
+          block.call(*actual_call.args[0...-1], **kargs, &actual_block)
+        else
+          block.call(*actual_call.args, &actual_block)
+        end
+      end
+    end
+
+    # used for __mock_dispatch_call
+    def __mock_proxy_call context, disp, call, proxy_super
+      if disp.original_method # proxies for singleton methods with __send__
+        if __mock_method_with_kargs?(context, disp.original_method) &&
+          kargs = call.args.last
+          context.__send__(
+            disp.original_method, *call.args[0...-1], **kargs, &call.block)
+        else
+          context.__send__(disp.original_method, *call.args, &call.block)
+        end
+      else # proxies for instance methods with super
+        proxy_super.call(call, __mock_super_with_kargs?(context, call.msg))
       end
     end
 
-    def __mock_check_args expected_args, actual_args
-      if expected_args == [WithAnyArgs]
-        true
-      elsif expected_args.none?{ |arg| arg.kind_of?(Satisfying) }
+    def __mock_find_checked_difi defis, actual_call, meth=:find
+      defis.public_send(meth){ |d| __mock_check_args(d, actual_call) }
+    end
+
+    def __mock_method_with_kargs? object, method_name
+      __mock_block_with_kargs?(
+        ::Kernel.instance_method(:method).bind(object).call(method_name))
+    end
+
+    def __mock_super_with_kargs? object, method_name
+      super_method =
+        ::Kernel.instance_method(:method).bind(object).call(method_name).
+        super_method
+
+      if super_method.owner == ::Class && super_method.name == :new
+        initialize_method = ::Class.instance_method(:instance_method).
+          bind(object).call(:initialize)
+        __mock_block_with_kargs?(initialize_method)
+      else
+        super_method && __mock_block_with_kargs?(super_method)
+      end
+    end
+
+    def __mock_block_with_kargs? block
+      # there's no Symbol#start_with? in older Ruby
+      block.parameters.dig(-1, 0).to_s.start_with?('key')
+    end
+
+    def __mock_check_args defi, actual_call
+      return true if defi.args.size == 1 && defi.args.first == WithAnyArgs
+
+      expected_args = defi.args
+      actual_args = actual_call.args
+
+      if expected_args.none?{ |arg| arg.kind_of?(Satisfying) }
         expected_args == actual_args
 
       elsif expected_args.size == actual_args.size