chore: bump luassert to the latest master (#377)

Author: Conni2461

lua/luassert/assert.lua

@@ -1,7 +1,7 @@
 local s = require 'say'
 local astate = require 'luassert.state'
 local util = require 'luassert.util'
-local unpack = require 'luassert.compatibility'.unpack
+local unpack = util.unpack
 local obj   -- the returned module table
 local level_mt = {}
 
@@ -39,8 +39,7 @@ local __state_meta = {
         end
       end
 
-      local arguments = {...}
-      arguments.n = select('#', ...) -- add argument count for trailing nils
+      local arguments = util.make_arglist(...)
       local val, retargs = assertion.callback(self, arguments, util.errorlevel())
 
       if not val == self.mod then
@@ -57,8 +56,7 @@ local __state_meta = {
       end
       return ...
     else
-      local arguments = {...}
-      arguments.n = select('#', ...)
+      local arguments = util.make_arglist(...)
       self.tokens = {}
 
       for _, key in ipairs(keys) do
@@ -135,25 +133,25 @@ obj = {
   set_parameter = function(self, name, value)
     astate.set_parameter(name, value)
   end,
-  
+
   get_parameter = function(self, name)
     return astate.get_parameter(name)
-  end,  
-  
+  end,
+
   add_spy = function(self, spy)
     astate.add_spy(spy)
   end,
-  
+
   snapshot = function(self)
     return astate.snapshot()
   end,
-  
+
   level = function(self, level)
     return setmetatable({
         level = level
       }, level_mt)
   end,
-  
+
   -- returns the level if a level-value, otherwise nil
   get_level = function(self, level)
     if getmetatable(level) ~= level_mt then

lua/luassert/assertions.lua

@@ -142,11 +142,15 @@ local function same(state, arguments, level)
 end
 
 local function truthy(state, arguments, level)
+  local argcnt = arguments.n
+  assert(argcnt > 0, s("assertion.internal.argtolittle", { "truthy", 1, tostring(argcnt) }), level)
   set_failure_message(state, arguments[2])
   return arguments[1] ~= false and arguments[1] ~= nil
 end
 
 local function falsy(state, arguments, level)
+  local argcnt = arguments.n
+  assert(argcnt > 0, s("assertion.internal.argtolittle", { "falsy", 1, tostring(argcnt) }), level)
   return not truthy(state, arguments, level)
 end
 

lua/luassert/compatibility.lua

@@ -1,3 +1,9 @@
+-- no longer needed, only for backward compatibility
+local unpack = require ("luassert.util").unpack
+
 return {
-  unpack = table.unpack or unpack,
+  unpack = function(...)
+    print(debug.traceback("WARN: calling deprecated function 'luassert.compatibility.unpack' use 'luassert.util.unpack' instead"))
+    return unpack(...)
+  end
 }

lua/luassert/formatters/init.lua

@@ -1,5 +1,7 @@
 -- module will not return anything, only register formatters with the main assert engine
 local assert = require('luassert.assert')
+local match = require('luassert.match')
+local util = require('luassert.util')
 
 local colors = setmetatable({
   none = function(c) return c end
@@ -201,6 +203,35 @@ local function fmt_thread(arg)
   end
 end
 
+local function fmt_matcher(arg)
+  if not match.is_matcher(arg) then
+    return
+  end
+  local not_inverted = {
+    [true] = "is.",
+    [false] = "no.",
+  }
+  local args = {}
+  for idx = 1, arg.arguments.n do
+    table.insert(args, assert:format({ arg.arguments[idx], n = 1, })[1])
+  end
+  return string.format("(matcher) %s%s(%s)",
+                       not_inverted[arg.mod],
+                       tostring(arg.name),
+                       table.concat(args, ", "))
+end
+
+local function fmt_arglist(arglist)
+  if not util.is_arglist(arglist) then
+    return
+  end
+  local formatted_vals = {}
+  for idx = 1, arglist.n do
+    table.insert(formatted_vals, assert:format({ arglist[idx], n = 1, })[1])
+  end
+  return "(values list) (" .. table.concat(formatted_vals, ", ") .. ")"
+end
+
 assert:add_formatter(fmt_string)
 assert:add_formatter(fmt_number)
 assert:add_formatter(fmt_boolean)
@@ -209,6 +240,8 @@ assert:add_formatter(fmt_table)
 assert:add_formatter(fmt_function)
 assert:add_formatter(fmt_userdata)
 assert:add_formatter(fmt_thread)
+assert:add_formatter(fmt_matcher)
+assert:add_formatter(fmt_arglist)
 -- Set default table display depth for table formatter
 assert:set_parameter("TableFormatLevel", 3)
 assert:set_parameter("TableFormatShowRecursion", false)

lua/luassert/match.lua

@@ -25,17 +25,16 @@ local state_mt = {
         end
       end
 
-      local arguments = {...}
-      arguments.n = select('#', ...) -- add argument count for trailing nils
+      local arguments = util.make_arglist(...)
       local matches = matcher.callback(self, arguments, util.errorlevel())
       return setmetatable({
         name = matcher.name,
         mod = self.mod,
         callback = matches,
+        arguments = arguments,
       }, matcher_mt)
     else
-      local arguments = {...}
-      arguments.n = select('#', ...) -- add argument count for trailing nils
+      local arguments = util.make_arglist(...)
 
       for _, key in ipairs(keys) do
         if namespace.modifier[key] then

lua/luassert/matchers/core.lua

@@ -60,7 +60,6 @@ local function matches(state, arguments, level)
   local pattern = arguments[1]
   local init = arguments[2]
   local plain = arguments[3]
-  local stringtype = "string or object convertible to a string"
   assert(type(pattern) == "string", s("assertion.internal.badargtype", { 1, "matches", "string", type(arguments[1]) }), level)
   assert(init == nil or tonumber(init), s("assertion.internal.badargtype", { 2, "matches", "number", type(arguments[2]) }), level)
 

lua/luassert/spy.lua

@@ -5,12 +5,10 @@ local util = require('luassert.util')
 -- Spy metatable
 local spy_mt = {
   __call = function(self, ...)
-    local arguments = {...}
-    arguments.n = select('#',...)  -- add argument count for trailing nils
+    local arguments = util.make_arglist(...)
     table.insert(self.calls, util.copyargs(arguments))
     local function get_returns(...)
-      local returnvals = {...}
-      returnvals.n = select('#',...)  -- add argument count for trailing nils
+      local returnvals = util.make_arglist(...)
       table.insert(self.returnvals, util.copyargs(returnvals))
       return ...
     end
@@ -59,11 +57,27 @@ spy = {
       end,
 
       called_with = function(self, args)
-        return util.matchargs(self.calls, args) ~= nil
+        local last_arglist = nil
+        if #self.calls > 0 then
+          last_arglist = self.calls[#self.calls].vals
+        end
+        local matching_arglists = util.matchargs(self.calls, args)
+        if matching_arglists ~= nil then
+          return true, matching_arglists.vals
+        end
+        return false, last_arglist
       end,
 
       returned_with = function(self, args)
-        return util.matchargs(self.returnvals, args) ~= nil
+        local last_returnvallist = nil
+        if #self.returnvals > 0 then
+          last_returnvallist = self.returnvals[#self.returnvals].vals
+        end
+        local matching_returnvallists = util.matchargs(self.returnvals, args)
+        if matching_returnvallists ~= nil then
+          return true, matching_returnvallists.vals
+        end
+        return false, last_returnvallist
       end
     }, spy_mt)
     assert:add_spy(s)  -- register with the current state
@@ -96,7 +110,12 @@ local function returned_with(state, arguments, level)
   local level = (level or 1) + 1
   local payload = rawget(state, "payload")
   if payload and payload.returned_with then
-    return state.payload:returned_with(arguments)
+    local assertion_holds, matching_or_last_returnvallist = state.payload:returned_with(arguments)
+    local expected_returnvallist = util.shallowcopy(arguments)
+    util.cleararglist(arguments)
+    util.tinsert(arguments, 1, matching_or_last_returnvallist)
+    util.tinsert(arguments, 2, expected_returnvallist)
+    return assertion_holds
   else
     error("'returned_with' must be chained after 'spy(aspy)'", level)
   end
@@ -106,7 +125,12 @@ local function called_with(state, arguments, level)
   local level = (level or 1) + 1
   local payload = rawget(state, "payload")
   if payload and payload.called_with then
-    return state.payload:called_with(arguments)
+    local assertion_holds, matching_or_last_arglist = state.payload:called_with(arguments)
+    local expected_arglist = util.shallowcopy(arguments)
+    util.cleararglist(arguments)
+    util.tinsert(arguments, 1, matching_or_last_arglist)
+    util.tinsert(arguments, 2, expected_arglist)
+    return assertion_holds
   else
     error("'called_with' must be chained after 'spy(aspy)'", level)
   end

lua/luassert/state.lua

@@ -30,7 +30,7 @@ state.revert = function(self)
     end
   end
   if getmetatable(self) ~= state_mt then error("Value provided is not a valid snapshot", 2) end
-  
+
   if self.next then
     self.next:revert()
   end
@@ -52,7 +52,6 @@ end
 -- Creates a new snapshot.
 -- @return snapshot table
 state.snapshot = function()
-  local s = current
   local new = setmetatable ({
     formatters = {},
     parameters = {},

lua/luassert/stub.lua

@@ -2,7 +2,8 @@
 local assert = require 'luassert.assert'
 local spy = require 'luassert.spy'
 local util = require 'luassert.util'
-local unpack = require 'luassert.compatibility'.unpack
+local unpack = util.unpack
+local pack = util.pack
 
 local stub = {}
 
@@ -12,22 +13,20 @@ function stub.new(object, key, ...)
     object = {}
     key = ""
   end
-  local return_values_count = select("#", ...)
-  local return_values = {...}
+  local return_values = pack(...)
   assert(type(object) == "table" and key ~= nil, "stub.new(): Can only create stub on a table key, call with 2 params; table, key", util.errorlevel())
   assert(object[key] == nil or util.callable(object[key]), "stub.new(): The element for which to create a stub must either be callable, or be nil", util.errorlevel())
   local old_elem = object[key]    -- keep existing element (might be nil!)
 
-  local fn = (return_values_count == 1 and util.callable(return_values[1]) and return_values[1])
+  local fn = (return_values.n == 1 and util.callable(return_values[1]) and return_values[1])
   local defaultfunc = fn or function()
-    return unpack(return_values, 1, return_values_count)
+    return unpack(return_values)
   end
   local oncalls = {}
   local callbacks = {}
   local stubfunc = function(...)
-    local args = {...}
-    args.n = select('#', ...)
-    local match = util.matchargs(oncalls, args)
+    local args = util.make_arglist(...)
+    local match = util.matchoncalls(oncalls, args)
     if match then
       return callbacks[match](...)
     end
@@ -48,10 +47,9 @@ function stub.new(object, key, ...)
   end
 
   s.returns = function(...)
-    local return_args = {...}
-    local n = select('#', ...)
+    local return_args = pack(...)
     defaultfunc = function()
-      return unpack(return_args, 1, n)
+      return unpack(return_args)
     end
     return s
   end
@@ -69,16 +67,14 @@ function stub.new(object, key, ...)
   }
 
   s.on_call_with = function(...)
-    local match_args = {...}
-    match_args.n = select('#', ...)
+    local match_args = util.make_arglist(...)
     match_args = util.copyargs(match_args)
     return {
       returns = function(...)
-        local return_args = {...}
-        local n = select('#', ...)
+        local return_args = pack(...)
         table.insert(oncalls, match_args)
         callbacks[match_args] = function()
-          return unpack(return_args, 1, n)
+          return unpack(return_args)
         end
         return s
       end,