Editing Module:Arguments
Jump to navigation
Jump to search
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.
Latest revision | Your text | ||
Line 7: | Line 7: | ||
local arguments = {} | local arguments = {} | ||
local nilArg = {} -- Used for memoizing nil arguments in metaArgs. | |||
-- Generate four different tidyVal functions, so that we don't have to check the | -- Generate four different tidyVal functions, so that we don't have to check the | ||
Line 47: | Line 49: | ||
return val | return val | ||
end | end | ||
function arguments.getArgs(frame, options) | function arguments.getArgs(frame, options) | ||
Line 62: | Line 57: | ||
--[[ | --[[ | ||
-- Get the arguments from the frame object if available. If the frame object | |||
-- is not available, we are being called from another Lua module or from the | |||
-- debug console, so assign the args to a new variable so we can | |||
-- differentiate them. | |||
-- Get the | |||
-- | |||
-- | |||
-- | |||
--]] | --]] | ||
local fargs, pargs, luaArgs | local fargs, pargs, luaArgs | ||
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then | if type(frame.args) == 'table' and type(frame.getParent) == 'function' then | ||
if | if not options.parentOnly then | ||
fargs = frame.args | |||
end | |||
if not options.frameOnly then | |||
pargs = frame:getParent().args | |||
end | end | ||
if options.parentFirst then | if options.parentFirst then | ||
Line 150: | Line 77: | ||
end | end | ||
-- Set the | -- Set up the args and metaArgs tables. args will be the one accessed from | ||
-- | -- functions, and metaArgs will hold the actual arguments. The metatable | ||
-- | -- connects the two together. | ||
local | local args, metaArgs, metatable = {}, {}, {} | ||
setmetatable(args, metatable) | |||
--[[ | --[[ | ||
Line 188: | Line 114: | ||
end | end | ||
local function mergeArgs(iterator, tables) | |||
local function mergeArgs(tables) | |||
--[[ | --[[ | ||
-- Accepts multiple tables as input and merges their keys and values | -- Accepts multiple tables as input and merges their keys and values | ||
-- into one table. If a value is already present it is not overwritten; | -- into one table using the specified iterator. If a value is already | ||
-- present it is not overwritten; tables listed earlier have precedence. | |||
-- | -- We are also memoizing nil values, but those values can be | ||
-- overwritten. | |||
--]] | --]] | ||
for _, t in ipairs(tables) do | for _, t in ipairs(tables) do | ||
for key, val in | for key, val in iterator(t) do | ||
local metaArgsVal = metaArgs[key] | |||
if metaArgsVal == nil or metaArgsVal == nilArg then | |||
local tidiedVal = tidyVal(key, val) | local tidiedVal = tidyVal(key, val) | ||
if tidiedVal == nil then | if tidiedVal == nil then | ||
metaArgs[key] = nilArg | |||
else | else | ||
metaArgs[key] = tidiedVal | metaArgs[key] = tidiedVal | ||
Line 217: | Line 136: | ||
end | end | ||
end | end | ||
-- Set the order of precedence of the argument tables. If the variables are | |||
-- nil, nothing will be added to the table, which is how we avoid clashes | |||
-- between the frame/parent args and the Lua args. | |||
local argTables = {fargs} | |||
argTables[#argTables + 1] = pargs | |||
argTables[#argTables + 1] = luaArgs | |||
--[[ | --[[ | ||
-- Define metatable behaviour. Arguments are memoized in the metaArgs table, | -- Define metatable behaviour. Arguments are memoized in the metaArgs table, | ||
-- and are only fetched from the argument tables once. | -- and are only fetched from the argument tables once. Nil arguments are | ||
-- | -- also memoized using the nilArg variable in order to increase performance. | ||
-- Also, we keep a record in the metatable of when pairs and ipairs have | |||
-- | -- been called, so we do not run pairs and ipairs on fargs and pargs more | ||
-- than once. We also do not run ipairs on fargs and pargs if pairs has | |||
-- already been run, as all the arguments will already have been copied | |||
-- over. | |||
--]] | --]] | ||
metatable.__index = function (t, key) | metatable.__index = function (t, key) | ||
local val = metaArgs[key] | local val = metaArgs[key] | ||
if val ~= nil then | if metatable.donePairs or val ~= nil then | ||
--[[ | |||
-- We have either memoized the argument already, or pairs has been | |||
return | -- called, meaning that mergeArgs has already copied all of the | ||
-- available arguments into the metaArgs table. We need to check for | |||
-- pairs as we can't memoize nils to the metaArgs table while pairs | |||
-- is iterating. Adding new instances of nilArg to the metaArgs | |||
-- table while pairs is iterating over it produces undefined | |||
-- behaviour in the next() function. | |||
--]] | |||
if val == nilArg then | |||
return nil | |||
else | |||
return val | |||
end | |||
end | end | ||
for _, argTable in ipairs(argTables) do | for _, argTable in ipairs(argTables) do | ||
local argTableVal = tidyVal(key, argTable[key]) | local argTableVal = tidyVal(key, argTable[key]) | ||
if argTableVal | if argTableVal == nil then | ||
metaArgs[key] = nilArg | |||
else | |||
metaArgs[key] = argTableVal | metaArgs[key] = argTableVal | ||
return argTableVal | return argTableVal | ||
end | end | ||
end | end | ||
return nil | return nil | ||
end | end | ||
metatable.__newindex = function (t, key, val) | metatable.__newindex = function (t, key, val) | ||
if options.readOnly then | if options.readOnly then | ||
error( | error( | ||
Line 283: | Line 201: | ||
) | ) | ||
elseif val == nil then | elseif val == nil then | ||
metaArgs[key] = nilArg -- Memoize nils. | |||
metaArgs[key] = | |||
else | else | ||
metaArgs[key] = val | metaArgs[key] = val | ||
end | end | ||
end | end | ||
metatable.__pairs = function () | metatable.__pairs = function () | ||
if not metatable.donePairs then | if not metatable.donePairs then | ||
mergeArgs(argTables) | mergeArgs(pairs, argTables) | ||
metatable.donePairs = true | metatable.donePairs = true | ||
metatable.doneIpairs = true | |||
end | |||
return function (t, k) | |||
local nk, val = next(metaArgs, k) | |||
if val == nilArg then | |||
val = nil | |||
end | |||
return nk, val | |||
end | end | ||
end | end | ||
metatable.__ipairs = function () | |||
if not metatable.doneIpairs then | |||
mergeArgs(ipairs, argTables) | |||
if | metatable.doneIpairs = true | ||
end | end | ||
return function (t, i) | |||
local val = metaArgs[i + 1] | |||
if val == nil then | |||
return nil | |||
elseif val == nilArg then | |||
val = nil | |||
end | |||
return i + 1, val | |||
end, nil, 0 | |||
end | end | ||