muack 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 309cafc82b9f7538884fa099e8ab6827d183afcf
-  data.tar.gz: 64a20f3374a9c72abe10c4c7a78f26651c04c09b
+SHA256:
+  metadata.gz: e65f1260993f94d96899086e3975500583ec077bfae332a8fd4cefc5a2c7da49
+  data.tar.gz: 736468eb986e1925f8f83973fec00c2142df16ca80aee9ce051bbdc255cbbfc8
 SHA512:
-  metadata.gz: 312fd3143189a03c2c8d1fbe85a74296ccc71fd8247d09fc83ea8a5fc4ba3407fde7f7507e9c58d611cc476457b02d8b8ad614d1c6f9555694f2037c783eccc9
-  data.tar.gz: 658d76b3ddac4ad03c10f643f8e16f996d1250862995037c4460abf586423b1e389e851bf4f376004187dbe1069b765428b8993d9175130db5627be586a50c7c
+  metadata.gz: d3bb1281eab20185484890205696cbed1d3996ed6392b76e08297af8e742bd76a80f2e3a26fffec265848d18a5373dffd517db6d2127b4e511dfdc5a2b475937
+  data.tar.gz: 2c148e33b0dce444708d09a58f6364e160a926f73e5432120fa8668c7ee0dd65c83128e69723673fd6c95bb62db879b8ff3636af29c93e783954f8409a882ebd

data/.travis.yml

@@ -1,11 +1,21 @@
-
+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.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
+      env: RUBYOPT=--enable-frozen-string-literal

data/CHANGES.md

@@ -1,5 +1,17 @@
 # CHANGES
 
+## 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

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) [![Join the chat at https://gitter.im/godfat/muack](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/muack)
+# 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:
 
@@ -46,7 +47,7 @@ describe 'Hello' do
   after { Muack.verify }
 
   would 'say world!' do
-    str = 'Hello'
+    str = 'Hello'.dup
     mock(str).say('!'){ |arg| "World#{arg}" }
     str.say('!').should.eq 'World!'
   end
@@ -172,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   }
@@ -274,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
@@ -284,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
@@ -623,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
@@ -654,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
@@ -832,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
 ```
@@ -841,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
 ```
@@ -862,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
 ```
@@ -883,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
 ```
@@ -1209,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:
 
@@ -1218,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,
+                           :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,42 +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
-        __mock_failed(msg, actual_args)
+        __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
@@ -95,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
@@ -114,36 +112,46 @@ 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)
+      # a) ancestors.first is the first module in the method chain.
+      #    it's just the singleton_class when nothing was prepended,
+      #    otherwise the last prepended module.
+      # b) would be the class in AnyInstanceOf.
+      target = object.singleton_class.ancestors.first
+      Mock.store_original_method(target, defi)
+      __mock_inject_mock_method(target, defi)
     end
 
     def __mock_reset_method defi
-      object.singleton_class.module_eval do
+      object.singleton_class.ancestors.first.module_eval do
         remove_method(defi.msg)
         # restore original method
-        if instance_methods(false).include?(defi.original_method) ||
+        if public_instance_methods(false).include?(defi.original_method) ||
+           protected_instance_methods(false).include?(defi.original_method) ||
            private_instance_methods(false).include?(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?
+      visibility = if klass.public_instance_methods(false).include?(defi.msg)
+        :public
+      elsif klass.protected_instance_methods(false).include?(defi.msg)
+        :protected
       elsif klass.private_instance_methods(false).include?(defi.msg)
         :private
       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
+      if visibility # store original method
+        original_method = find_new_name(klass, defi.msg)
+        klass.__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
@@ -159,50 +167,100 @@ module Muack
       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 msg, actual_args, disps=__mock_disps[msg]
-      if expected = __mock_find_checked_difi(disps, actual_args)
+    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, msg, actual_args))
+          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_find_checked_difi defis, actual_args, meth=:find
-      defis.public_send(meth){ |d| __mock_check_args(d.args, actual_args) }
+    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_check_args expected_args, actual_args
-      if expected_args == [WithAnyArgs]
-        true
-      elsif expected_args.none?{ |arg| arg.kind_of?(Satisfying) }
+    def __mock_super_with_kargs? object, method_name
+      super_method =
+        ::Kernel.instance_method(:method).bind(object).call(method_name).
+        super_method
+
+      super_method && __mock_block_with_kargs?(super_method)
+    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