Nonbinary Wiki

Module:Arguments: Difference between revisions

m>Mr. Stradivarius
(return a table rather than a function, improve the comments)
m (3 revisions imported from templatewiki:Module:Arguments: see Topic:Vtixlm0q28eo6jtf)
 
(43 intermediate revisions by 26 users not shown)
Line 1: Line 1:
-- This module provides easy processing of arguments passed to Scribunto from #invoke.
-- This module provides easy processing of arguments passed to Scribunto from
-- It is intended for use by other Lua modules, and should not be called from #invoke directly.
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.
 
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType


local arguments = {}
local arguments = {}


function arguments.getArgs(frame, options)
-- Generate four different tidyVal functions, so that we don't have to check the
options = type(options) == 'table' and options or {}
-- options every time we call it.
 
local function tidyValDefault(key, val)
if type(val) == 'string' then
val = val:match('^%s*(.-)%s*$')
if val == '' then
return nil
else
return val
end
else
return val
end
end
 
local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end


-- Get the arguments from the frame object if available. If the frame object is not available, we are being called
local function tidyValRemoveBlanksOnly(key, val)
-- from another Lua module or from the debug console, so assume arguments are passed directly in.
if type(val) == 'string' then
local fargs, pargs
if val:find('%S') then
if frame == mw.getCurrentFrame() then
return val
fargs = frame.args
else
pargs = frame:getParent().args
return nil
end
else
else
fargs = type(frame) == 'table' and frame or {}
return val
pargs = {}
end
end
end


local args, metaArgs, metatable = {}, {}, {}
local function tidyValNoChange(key, val)
setmetatable(args, metatable)
return val
end
 
local function matchesTitle(given, title)
local tp = type( given )
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end
 
local translate_mt = { __index = function(t, k) return k end }
 
function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}


local function tidyVal(key, val)
--[[
-- Processes a value according to the options given to getArguments. Can trim whitespace and remove blanks.
-- Set up argument translation.
-- Keys are not used here, but they can be used by user-generated functions, so defining it here to avoid breakage.
--]]
if type(val) == 'string' then
options.translate = options.translate or {}
if options.trim ~= false then
if getmetatable(options.translate) == nil then
val = mw.text.trim(val)
setmetatable(options.translate, translate_mt)
end
if options.backtranslate == nil then
options.backtranslate = {}
for k,v in pairs(options.translate) do
options.backtranslate[v] = k
end
end
if options.backtranslate and getmetatable(options.backtranslate) == nil then
setmetatable(options.backtranslate, {
__index = function(t, k)
if options.translate[k] ~= k then
return nil
else
return k
end
end
end
if options.removeBlanks == false or mw.ustring.find(val, '%S') then
})
return val
end
 
--[[
-- Get the argument tables. If we were passed a valid frame object, get the
-- frame arguments (fargs) and the parent frame arguments (pargs), depending
-- on the options set and on the parent frame's availability. If we weren't
-- passed a valid frame object, we are being called from another Lua module
-- or from the debug console, so assume that we were passed a table of args
-- directly, and assign it to a new variable (luaArgs).
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- The wrappers option makes Module:Arguments look up arguments in
-- either the frame argument table or the parent argument table, but
-- not both. This means that users can use either the #invoke syntax
-- or a wrapper template without the loss of performance associated
-- with looking arguments up i