muack 1.2.0 → 1.5.0

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.rb

@@ -1,6 +1,6 @@
 
 require 'muack/session'
-require 'muack/satisfy'
+require 'muack/satisfying'
 
 module Muack
   def self.verify obj=nil
@@ -46,20 +46,16 @@ module Muack
       if block_given? then yield(ret) else ret end
     end
 
-    def is_a klass
-      Muack::IsA.new(klass)
-    end
-
     def anything
       Muack::Anything.new
     end
 
-    def match regexp
-      Muack::Match.new(regexp)
+    def is_a klass
+      Muack::IsA.new(klass)
     end
 
-    def hash_including hash
-      Muack::HashIncluding.new(hash)
+    def matching regexp
+      Muack::Matching.new(regexp)
     end
 
     def including element
@@ -70,12 +66,48 @@ module Muack
       Muack::Within.new(range_or_array)
     end
 
+    def responding_to *msg
+      Muack::RespondingTo.new(*msg)
+    end
+
+    def where spec
+      Muack::Where.new(spec)
+    end
+
+    def having spec
+      Muack::Having.new(spec)
+    end
+
+    def allowing spec
+      Muack::Allowing.new(spec)
+    end
+
+    def satisfying &block
+      Muack::Satisfying.new(&block)
+    end
+
+    def match regexp
+      $stderr.puts("Muack::API.match is deprecated." \
+                   " Use Muack::API.matching instead.")
+      matching(regexp)
+    end
+
     def respond_to *msg
-      Muack::RespondTo.new(*msg)
+      $stderr.puts("Muack::API.respond_to is deprecated." \
+                   " Use Muack::API.responding_to instead.")
+      responding_to(*msg)
+    end
+
+    def hash_including spec
+      $stderr.puts("Muack::API.hash_including is deprecated." \
+                   " Use Muack::API.having instead.")
+      having(spec)
     end
 
     def satisfy &block
-      Muack::Satisfy.new(block)
+      $stderr.puts("Muack::API.satisfy is deprecated." \
+                   " Use Muack::API.satisfying instead.")
+      satisfying(&block)
     end
   end
 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/error.rb

@@ -15,4 +15,10 @@ module Muack
             ".times(#{times})"
     end
   end
+
+  class UnknownSpec < Error
+    def initialize spec
+      super "\nUnknown spec: #{spec.inspect}"
+    end
+  end
 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,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
@@ -166,40 +167,105 @@ 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 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_find_checked_difi defis, actual_call, meth=:find
+      defis.public_send(meth){ |d| __mock_check_args(d, actual_call) }
     end
 
-    def __mock_check_args expected_args, actual_args
-      if expected_args == [WithAnyArgs]
-        true
-      elsif expected_args.none?{ |arg| arg.kind_of?(Satisfy) }
+    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
+
+      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
         expected_args.zip(actual_args).all?{ |(e, a)|
-          if e.kind_of?(Satisfy) then e.match(a) else e == a end
+          if e.kind_of?(Satisfying) then e.match(a) else e == a end
         }
       else
         false