mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-07 20:08:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Lua: vim.validate()

Browse Source
This commit is contained in:
Justin M. Keyes
2019-11-10 19:58:14 -08:00
parent 678a51b1da
commit 7aa4042d3b
2 changed files with 108 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
runtime/lua/vim/shared.lua
View File

@@ -190,68 +190,81 @@ function vim.pesc(s)
return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1') return s:gsub('[%(%)%.%%%+%-%*%?%[%]%^%$]', '%%%1')
end end
--- Type checking validation function --- Validates a parameter specification (types and values).
--- ---
--- Examples: --- Examples:
--- <pre> --- <pre>
--- validate({ arg={ { 'foo' }, 'table' }}) --> Nop --- function user.new(name, age, hobbies)
--- validate({ arg={ 1, 'table' } }) --> error("arg: expected table, got number") --- vim.validate{
--- validate({ arg1={ { 'foo' }, 'table' }, arg2={ 1, 'string' } }) --> error("arg2: expected string, got number") --- name={name, 'string'},
--- validate({ arg={ 3, function(a) return (a % 2) == 0 end, 'even number' }}) --> error("arg: expected even number, got 3") --- age={age, 'number'},
--- hobbies={hobbies, 'table'},
--- }
--- ...
--- end
--
--- vim.validate{ arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
--- => NOP (success)
--- vim.validate{arg1={1, 'table'}}
--- => error("arg1: expected table, got number")
--- vim.validate{arg1={{'foo'}, 'table'}, arg2={1, 'string'}}
--- => error("arg2: expected string, got number")
--- vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
--- => error("arg1: expected even number, got 3")
--- </pre> --- </pre>
--- ---
---@param ... Table or list of table. That table is "argument_name = { validation_target, type_name (, whether nil is allowed) }" --@param opt Map of parameter names to validations. Each key is a parameter
--- or "argument_name = { validation_target, validation function, expected_description }". --- name; each value is a tuple in one of these forms:
--- The following can be used as type_names: --- 1. {arg_value, type_name, optional}
--- - table or t --- - arg_value: argument value
--- - string or s --- - type_name: string type name, one of: ("table", "t", "string",
--- - number or n --- "s", "number", "n", "boolean", "b", "function", "f", "nil",
--- - boolean or b --- "thread", "userdata")
--- - function or f --- - optional: (optional) boolean, if true, `nil` is valid
--- - nil --- 2. {arg_value, fn, msg}
--- - thread --- - arg_value: argument value
--- - userdata --- - fn: any function accepting one argument, returns true if and
function vim.validate(opt) --- only if the argument is valid
local function _type_name(t) --- - msg: (optional) error string if validation fails
if t == 't' or t == 'table' then return 'table' end function vim.validate(opt) end -- luacheck: no unused
if t == 's' or t == 'string' then return 'string' end vim.validate = (function()
if t == 'n' or t == 'number' then return 'number' end local type_names = {
if t == 'b' or t == 'boolean' then return 'boolean' end t='table', s='string', n='number', b='boolean', f='function', c='callable',
if t == 'f' or t == 'function' then return 'function' end ['table']='table', ['string']='string', ['number']='number',
if t == 'c' then return 'callable' end ['boolean']='boolean', ['function']='function', ['callable']='callable',
if t == 'nil' then return 'nil' end ['nil']='nil', ['thread']='thread', ['userdata']='userdata',
if t == 'thread' or t == 'thread' then return 'thread' end }
if t == 'userdata' then return 'userdata' end local function type_name(t)
if vim.is_callable(t) then return end local tname = type_names[t]
if tname == nil then
error(string.format("Invalid type name '%s'. See \":help validate\" for more info.", t)) error(string.format('invalid type name: %s', tostring(t)))
end
local function _check_type(target, expected_type)
if expected_type == 'callable' then
return vim.is_callable(target)
else
return type(target) == expected_type
end end
return tname
end
local function is_type(val, t)
return t == 'callable' and vim.is_callable(val) or type(val) == t
end end
for arg, v in pairs(opt) do return function(opt)
assert(type(arg) == 'string',string.format('Expected string, got %s', type(arg))) assert(type(opt) == 'table', string.format('opt: expected table, got %s', type(opt)))
assert(type(v) == 'table', string.format('Expected table, got %s', type(v))) for param_name, spec in pairs(opt) do
assert(type(spec) == 'table', string.format('%s: expected table, got %s', param_name, type(spec)))
local actual_arg_type = type(v[1]) local val = spec[1] -- Argument value.
local expected_type = _type_name(v[2]) local t = spec[2] -- Type name, or callable.
local optional = (true == spec[3])
if expected_type then if not vim.is_callable(t) then -- Check type name.
if v[3] == true then if not (optional or type(val) == 'nil') and not is_type(val, type_name(t)) then
assert(_check_type(v[1], expected_type) or actual_arg_type == 'nil', string.format("%s: expected %s, got %s", arg, expected_type, actual_arg_type)) error(string.format("%s: expected %s, got %s", param_name, type_name(t), type(val)))
else end
assert(_check_type(v[1], expected_type), string.format("%s: expected %s, got %s", arg, expected_type, actual_arg_type)) elseif not t(val) then -- Check user-provided validation function.
error(string.format("%s: expected %s, got %s", param_name, spec[3], val))
end end
else
assert(v[2](v[1]), string.format("%s: expected %s, got %s", arg, v[3], v[1]))
end end
return true
end end
end end)()
--- Return whether an object can call be used as a function. --- Return whether an object can call be used as a function.
--- ---

79
test/functional/lua/vim_spec.lua
View File

@@ -404,40 +404,53 @@ describe('lua stdlib', function()
end) end)
it('vim.validate', function() it('vim.validate', function()
eq(NIL, exec_lua("vim.validate({ arg1={ {}, 'table' }})")) exec_lua("vim.validate{arg1={{}, 'table' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ {}, 't' }})")) exec_lua("vim.validate{arg1={{}, 't' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 't', true }})")) exec_lua("vim.validate{arg1={nil, 't', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ { foo='foo' }, 't' }})")) exec_lua("vim.validate{arg1={{ foo='foo' }, 't' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ { 'foo' }, 't' }})")) exec_lua("vim.validate{arg1={{ 'foo' }, 't' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 'foo', 'string' }})")) exec_lua("vim.validate{arg1={'foo', 'string' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 'foo', 's' }})")) exec_lua("vim.validate{arg1={'foo', 's' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ '', 's' }})")) exec_lua("vim.validate{arg1={'', 's' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 's', true }})")) exec_lua("vim.validate{arg1={nil, 's', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 1, 'number' }})")) exec_lua("vim.validate{arg1={1, 'number' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 1, 'n' }})")) exec_lua("vim.validate{arg1={1, 'n' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 0, 'n' }})")) exec_lua("vim.validate{arg1={0, 'n' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 0.1, 'n' }})")) exec_lua("vim.validate{arg1={0.1, 'n' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 'n', true }})")) exec_lua("vim.validate{arg1={nil, 'n', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ true, 'boolean' }})")) exec_lua("vim.validate{arg1={true, 'boolean' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ true, 'b' }})")) exec_lua("vim.validate{arg1={true, 'b' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ false, 'b' }})")) exec_lua("vim.validate{arg1={false, 'b' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 'b', true }})")) exec_lua("vim.validate{arg1={nil, 'b', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ function()end, 'function' }})")) exec_lua("vim.validate{arg1={function()end, 'function' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ function()end, 'f' }})")) exec_lua("vim.validate{arg1={function()end, 'f' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 'f', true }})")) exec_lua("vim.validate{arg1={nil, 'f', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 'nil' }})")) exec_lua("vim.validate{arg1={nil, 'nil' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 'nil', true }})")) exec_lua("vim.validate{arg1={nil, 'nil', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ coroutine.create(function()end), 'thread' }})")) exec_lua("vim.validate{arg1={coroutine.create(function()end), 'thread' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ nil, 'thread', true }})")) exec_lua("vim.validate{arg1={nil, 'thread', true }}")
eq(NIL, exec_lua("vim.validate({ arg1={ {}, 't' } }, { arg2={ 'foo', 's' }})")) exec_lua("vim.validate{arg1={{}, 't' }, arg2={ 'foo', 's' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ {}, 't' }, arg2={ 'foo', 's' }})")) exec_lua("vim.validate{arg1={2, function(a) return (a % 2) == 0 end, 'even number' }}")
eq(NIL, exec_lua("vim.validate({ arg1={ 2, function(a) return (a % 2) == 0 end, 'even number' }})"))
eq("Error executing lua: .../shared.lua: arg1: expected table, got number", pcall_err(exec_lua, "vim.validate({ arg1={ 1, 't' }})")) eq("Error executing lua: .../shared.lua: 1: expected table, got number",
eq("Error executing lua: .../shared.lua: arg2: expected string, got number", pcall_err(exec_lua, "vim.validate({ arg1={ {}, 't' }, arg2={ 1, 's' }})")) pcall_err(exec_lua, "vim.validate{ 1, 'x' }"))
eq("Error executing lua: .../shared.lua: arg2: expected string, got nil", pcall_err(exec_lua, "vim.validate({ arg1={ {}, 't' }, arg2={ nil, 's' }})")) eq("Error executing lua: .../shared.lua: invalid type name: x",
eq("Error executing lua: .../shared.lua: arg2: expected string, got nil", pcall_err(exec_lua, "vim.validate({ arg1={ {}, 't' }, arg2={ nil, 's' }})")) pcall_err(exec_lua, "vim.validate{ arg1={ 1, 'x' }}"))
eq("Error executing lua: .../shared.lua: arg1: expected even number, got 3", pcall_err(exec_lua, "vim.validate({ arg1={ 3, function(a) return a == 1 end, 'even number' }})")) eq("Error executing lua: .../shared.lua: invalid type name: 1",
pcall_err(exec_lua, "vim.validate{ arg1={ 1, 1 }}"))
eq("Error executing lua: .../shared.lua: invalid type name: nil",
pcall_err(exec_lua, "vim.validate{ arg1={ 1 }}"))
eq("Error executing lua: .../shared.lua: arg1: expected table, got number",
pcall_err(exec_lua, "vim.validate{arg1={1, 't'}}"))
eq("Error executing lua: .../shared.lua: arg2: expected string, got number",
pcall_err(exec_lua, "vim.validate{arg1={{}, 't'}, arg2={1, 's'}}"))
eq("Error executing lua: .../shared.lua: arg2: expected string, got nil",
pcall_err(exec_lua, "vim.validate{arg1={{}, 't'}, arg2={nil, 's'}}"))
eq("Error executing lua: .../shared.lua: arg2: expected string, got nil",
pcall_err(exec_lua, "vim.validate{arg1={{}, 't'}, arg2={nil, 's'}}"))
eq("Error executing lua: .../shared.lua: arg1: expected even number, got 3",
pcall_err(exec_lua, "vim.validate{arg1={3, function(a) return a == 1 end, 'even number'}}"))
end) end)
it('vim.is_callable', function() it('vim.is_callable', function()