--[[

General Lua Libraries for Lua 5.1, 5.2 & 5.3

Copyright (C) 2011-2018 stdlib authors

]]

local typecheck

have_typecheck, typecheck = pcall(require, 'typecheck')

local inprocess = require 'specl.inprocess'

local hell = require 'specl.shell'

local std = require 'specl.std'

badargs = require 'specl.badargs'

local top_srcdir = os.getenv 'top_srcdir' or '.'

local top_builddir = os.getenv 'top_builddir' or '.'

package.path = std.package.normalize(

top_builddir .. '/lib/?.lua',

top_builddir .. '/lib/?/init.lua',

top_srcdir .. '/lib/?.lua',

top_srcdir .. '/lib/?/init.lua',

package.path

)

-- Allow user override of LUA binary used by hell.spawn, falling

-- back to environment PATH search for 'lua' if nothing else works.

local LUA = os.getenv 'LUA' or 'lua'

-- Simplified version for specifications, does not support functable

-- valued __len metamethod, so don't write examples that need that!

function len(x)

local __len = getmetatable(x) or {}

if type(__len) == 'function' then

return __len(x)

end

if type(x) ~= 'table' then

return #x

end

local n = #x

for i = 1, n do

if x[i] == nil then

return i -1

end

end

return n

end

-- Make sure we have a maxn even when _VERSION ~= 5.1

-- @fixme remove this when we get unpack from specl.std

maxn = table.maxn or function(t)

local n = 0

for k in pairs(t) do

if type(k) == 'number' and k > n then

n = k

end

end

return n

end

pack = table.pack or function(...)

return {n=select('#', ...), ...}

end

-- Take care to always unpack upto the highest numeric index, for

-- consistency across Lua versions.

local _unpack = table.unpack or unpack

-- @fixme pick this up from specl.std with the next release

function unpack(t, i, j)

return _unpack(t, tonumber(i) or 1, tonumber(j or t.n or len(t)))

end

-- In case we're not using a bleeding edge release of Specl...

_diagnose = badargs.diagnose

badargs.diagnose = function(...)

if have_typecheck then

return _diagnose(...)

end

end

badargs.result = badargs.result or function(fname, i, want, got)

if want == nil then -- numbers only for narg error

i, want = i - 1, i

end

if got == nil and type(want) == 'number' then

local s = "bad result #%d from '%s'(no more than %d result%s expected, got %d)"

return s:format(i + 1, fname, i, i == 1 and '' or 's', want)

end

local function showarg(s)

return('|' .. s .. '|'):

gsub('|%?', '|nil|'):

gsub('|nil|', '|no value|'):

gsub('|any|', '|any value|'):

gsub('|#', '|non-empty '):

gsub('|func|', '|function|'):

gsub('|file|', '|FILE*|'):

gsub('^|', ''):

gsub('|$', ''):

gsub('|([^|]+)$', 'or %1'):

gsub('|', ', ')

end

return string.format("bad result #%d from '%s'(%s expected, got %s)",

i, fname, showarg(want), got or 'no value')

end

-- Wrap up badargs function in a succinct single call.

function init(M, mname, fname)

local name =(mname .. '.' .. fname):gsub('^%.', '')

return M[fname],

function(...)

return badargs.format(name, ...)

end,

function(...)

return badargs.result(name, ...)

end

end

-- A copy of base.lua:type, so that an unloadable base.lua doesn't

-- prevent everything else from working.

function objtype(o)

return(getmetatable(o) or {})._type or io.type(o) or type(o)

end

function nop() end

-- Error message specifications use this to shorten argument lists.

-- Copied from functional.lua to avoid breaking all tests if functional

-- cannot be loaded correctly.

function bind(f, fix)

return function(...)

local arg = {}

for i, v in pairs(fix) do

arg[i] = v

end

local i = 1

for _, v in pairs {...} do

while arg[i] ~= nil do

i = i + 1

end

arg[i] = v

end

return f(unpack(arg))

end

end

local function mkscript(code)

local f = os.tmpname()

local h = io.open(f, 'w')

h:write(code)

h:close()

return f

end

--- Run some Lua code with the given arguments and input.

-- @string code valid Lua code

-- @tparam[opt={}] string|table arg single argument, or table of

-- arguments for the script invocation.

-- @string[opt] stdin standard input contents for the script process

-- @treturn specl.shell.Process|nil status of resulting process if

-- execution was successful, otherwise nil

function luaproc(code, arg, stdin)

local f = mkscript(code)

if type(arg) ~= 'table' then

arg = {arg}

end

local cmd = {LUA, f, unpack(arg)}

-- inject env and stdin keys separately to avoid truncating `...` in

-- cmd constructor

cmd.env = {LUA_PATH=package.path, LUA_INIT='', LUA_INIT_5_2=''}

cmd.stdin = stdin

local proc = hell.spawn(cmd)

os.remove(f)

return proc

end

--- Check deprecation output when calling a named function in the given module.

-- Note that the script fragments passed in *argstr* and *objectinit*

-- can reference the module table as `M`, and(where it would make sense)

-- an object prototype as `P` and instance as `obj`.

-- @param deprecate value of `std._debug.deprecate`

-- @string module dot delimited module path to load

-- @string fname name of a function in the table returned by requiring *module*

-- @param[opt=''] args arguments to pass to *fname* call, must be stringifiable

-- @string[opt=nil] objectinit object initializer to instantiate an

-- object for object method deprecation check

-- @treturn specl.shell.Process|nil status of resulting process if

-- execution was successful, otherwise nil

function deprecation(deprecate, module, fname, args, objectinit)

args = args or ''

local script

if objectinit == nil then

script = string.format([[

require 'std._debug'.deprecate = %s

M = require '%s'

P = M.prototype

print(M.%s(%s))

]], tostring(deprecate), module, fname, tostring(args))

else

script = string.format([[

require 'std._debug'.deprecate = %s

local M = require '%s'

local P = M.prototype

local obj = P(%s)

print(obj:%s(%s))

]], tostring(deprecate), module, objectinit, fname, tostring(args))

end

return luaproc(script)

end

--- Concatenate the contents of listed existing files.

-- @string ... names of existing files

-- @treturn string concatenated contents of those files

function concat_file_content(...)

local t = {}

for _, name in ipairs {...} do

h = io.open(name)

t[#t + 1] = h:read '*a'

end

return table.concat(t)

end

local function tabulate_output(code)

local proc = luaproc(code)

if proc.status ~= 0 then

return error(proc.errout)

end

local r = {}

proc.output:gsub('(%S*)[%s]*',

function(x)

if x ~= '' then

r[x] = true

end

end)

return r

end

--- Show changes to tables wrought by a require statement.

-- There are a few modes to this function, controlled by what named

-- arguments are given. Lists new keys in T1 after `require 'import'`:

--

-- show_apis {added_to=T1, by=import}

--

-- List keys returned from `require 'import'`, which have the same

-- value in T1:

--

-- show_apis {from=T1, used_by=import}

--

-- List keys from `require 'import'`, which are also in T1 but with

-- a different value:

--

-- show_apis {from=T1, enhanced_by=import}

--

-- List keys from T2, which are also in T1 but with a different value:

--

-- show_apis {from=T1, enhanced_in=T2}

--

-- @tparam table argt one of the combinations above

-- @treturn table a list of keys according to criteria above

function show_apis(argt)

local added_to, from, not_in, enhanced_in, enhanced_after, by =

argt.added_to, argt.from, argt.not_in, argt.enhanced_in,

argt.enhanced_after, argt.by

if added_to and by then

return tabulate_output([[

local before, after = {}, {}

for k in pairs(]] .. added_to .. [[) do

before[k] = true

end

local M = require ']] .. by .. [['

for k in pairs(]] .. added_to .. [[) do

after[k] = true

end

for k in pairs(after) do

if not before[k] then

print(k)

end

end

]])

elseif from and not_in then

return tabulate_output([[

local _ENV = require 'std.normalize' {

from = ']] .. from .. [[',

M = require ']] .. not_in .. [[',

}

for k in pairs(M) do

-- M[1] is typically the module namespace name, don't match

-- that!

if k ~= 1 and from[k] ~= M[k] then

print(k)

end

end

]])

elseif from and enhanced_in then

return tabulate_output([[

local _ENV = require 'std.normalize' {

from = ']] .. from .. [[',

M = require ']] .. enhanced_in .. [[',

}

for k, v in pairs(M) do

if from[k] ~= M[k] and from[k] ~= nil then

print(k)

end

end

]])

elseif from and enhanced_after then

return tabulate_output([[

local _ENV = require 'std.normalize' {

from = ']] .. from .. [[',

}

local before, after = {}, {}

for k, v in pairs(from) do

before[k] = v

end

]] .. enhanced_after .. [[

for k, v in pairs(from) do

after[k] = v

end

for k, v in pairs(before) do

if after[k] ~= nil and after[k] ~= v then

print(k)

end

end

]])

end

assert(false, 'missing argument to show_apis')

end

-- Stub inprocess.capture if necessary; new in Specl 12.

capture = inprocess.capture or function(f, arg)

return nil, nil, f(unpack(arg or {}))

end

do

-- Custom matcher for set size and set membership.

local util = require 'specl.util'

local matchers = require 'specl.matchers'

local Matcher, matchers, q =

matchers.Matcher, matchers.matchers, matchers.stringify

matchers.have_size = Matcher {

function(self, actual, expect)

local size = 0

for _ in pairs(actual) do

size = size + 1

end

return size == expect

end,

actual = 'table',

format_expect = function(self, expect)

return ' a table containing ' .. expect .. ' elements, '

end,

format_any_of = function(self, alternatives)

return ' a table with any of ' ..

util.concat(alternatives, util.QUOTED) .. ' elements, '

end,

}

matchers.have_member = Matcher {

function(self, actual, expect)

return actual[expect] ~= nil

end,

actual = 'set',

format_expect = function(self, expect)

return ' a set containing ' .. q(expect) .. ', '

end,

format_any_of = function(self, alternatives)

return ' a set containing any of ' ..

util.concat(alternatives, util.QUOTED) .. ', '

end,

}

-- Alias that doesn't tickle sc_error_message_uppercase.

matchers.raise = matchers.error

end