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 2: | Line 2: | ||
-- #invoke. It is intended for use by other Lua modules, and should not be | -- #invoke. It is intended for use by other Lua modules, and should not be | ||
-- called from #invoke directly. | -- called from #invoke directly. | ||
local libraryUtil = require('libraryUtil') | local libraryUtil = require('libraryUtil') | ||
local checkType = libraryUtil.checkType | local checkType = libraryUtil.checkType | ||
local arguments = {} | local arguments = {} | ||
-- 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 | ||
-- options every time we call it. | -- options every time we call it. | ||
local function tidyValDefault(key, val) | local function tidyValDefault(key, val) | ||
if type(val) == 'string' then | if type(val) == 'string' then | ||
Line 23: | Line 23: | ||
end | end | ||
end | end | ||
local function tidyValTrimOnly(key, val) | local function tidyValTrimOnly(key, val) | ||
if type(val) == 'string' then | if type(val) == 'string' then | ||
Line 31: | Line 31: | ||
end | end | ||
end | end | ||
local function tidyValRemoveBlanksOnly(key, val) | local function tidyValRemoveBlanksOnly(key, val) | ||
if type(val) == 'string' then | if type(val) == 'string' then | ||
Line 43: | Line 43: | ||
end | end | ||
end | end | ||
local function tidyValNoChange(key, val) | local function tidyValNoChange(key, val) | ||
return val | return val | ||
end | end | ||
function arguments.getArgs(frame, options) | function arguments.getArgs(frame, options) | ||
checkType('getArgs', 1, frame, 'table', true) | checkType('getArgs', 1, frame, 'table', true) | ||
Line 60: | Line 53: | ||
frame = frame or {} | frame = frame or {} | ||
options = options or {} | options = options or {} | ||
--[[ | --[[ | ||
-- 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 149: | Line 74: | ||
luaArgs = frame | luaArgs = frame | ||
end | end | ||
-- Set the order of precedence of the argument tables. If the variables are | -- 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 | -- nil, nothing will be added to the table, which is how we avoid clashes | ||
-- between the frame/parent args and the Lua args. | -- between the frame/parent args and the Lua args. | ||
local argTables = {fargs} | local argTables = {fargs} | ||
argTables[#argTables + 1] = pargs | argTables[#argTables + 1] = pargs | ||
argTables[#argTables + 1] = luaArgs | argTables[#argTables + 1] = luaArgs | ||
--[[ | --[[ | ||
-- Generate the tidyVal function. If it has been specified by the user, we | -- Generate the tidyVal function. If it has been specified by the user, we | ||
Line 187: | Line 112: | ||
end | end | ||
end | end | ||
--[[ | --[[ | ||
-- Set up the args, metaArgs and nilArgs tables. args will be the one | -- Set up the args, metaArgs and nilArgs tables. args will be the one | ||
Line 196: | Line 121: | ||
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {} | local args, metaArgs, nilArgs, metatable = {}, {}, {}, {} | ||
setmetatable(args, metatable) | setmetatable(args, metatable) | ||
local function mergeArgs(tables) | local function mergeArgs(iterator, 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 | ||
if metaArgs[key] == nil | if metaArgs[key] == nil then | ||
local tidiedVal = tidyVal(key, val) | local tidiedVal = tidyVal(key, val) | ||
if tidiedVal == nil then | if tidiedVal == nil then | ||
nilArgs[key] = | nilArgs[key] = true | ||
else | else | ||
metaArgs[key] = tidiedVal | metaArgs[key] = tidiedVal | ||
Line 217: | Line 143: | ||
end | end | ||
end | end | ||
--[[ | --[[ | ||
-- Define metatable behaviour. Arguments are memoized in the metaArgs table, | -- Define metatable behaviour. Arguments are memoized in the metaArgs table, | ||
Line 229: | Line 155: | ||
-- the arguments will already have been copied over. | -- the arguments will already have been copied over. | ||
--]] | --]] | ||
metatable.__index = function (t, key) | metatable.__index = function (t, key) | ||
--[[ | --[[ | ||
Line 242: | Line 168: | ||
-- must be nil. | -- must be nil. | ||
--]] | --]] | ||
local val = metaArgs[key] | local val = metaArgs[key] | ||
if val ~= nil then | if val ~= nil then | ||
Line 253: | Line 176: | ||
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 | ||
nilArgs[key] = true | |||
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) | ||
-- This function is called when a module tries to add a new value to the | -- This function is called when a module tries to add a new value to the | ||
-- args table, or tries to change an existing value. | -- args table, or tries to change an existing value. | ||
if options.readOnly then | if options.readOnly then | ||
error( | error( | ||
Line 291: | Line 212: | ||
--]] | --]] | ||
metaArgs[key] = nil | metaArgs[key] = nil | ||
nilArgs[key] = | nilArgs[key] = true -- Memoize nils. | ||
else | else | ||
metaArgs[key] = val | metaArgs[key] = val | ||
end | end | ||
end | end | ||
metatable.__pairs = function () | metatable.__pairs = function () | ||
-- Called when pairs is run on the args table. | -- Called when pairs is run on the args table. | ||
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 | end | ||
return | return pairs(metaArgs) | ||
end | end | ||
metatable.__ipairs = function () | |||
-- | -- Called when ipairs is run on the args table. | ||
if not metatable.doneIpairs then | |||
if | mergeArgs(ipairs, argTables) | ||
metatable.doneIpairs = true | |||
end | end | ||
return ipairs(metaArgs) | |||
end | end | ||
return args | return args | ||
end | end | ||
return arguments | return arguments |