Module:Arguments: Difference between revisions
Jump to navigation
Jump to search
m Reverted edits by 76.164.234.13 (talk) to last revision by Hashar |
MeowyCats2 (talk | contribs) m 61 revisions imported |
||
(29 intermediate revisions by 21 users not shown) | |||
Line 47: | Line 47: | ||
return val | return val | ||
end | 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) | function arguments.getArgs(frame, options) | ||
Line 53: | Line 60: | ||
frame = frame or {} | frame = frame or {} | ||
options = options or {} | options = options or {} | ||
--[[ | |||
-- Set up argument translation. | |||
--]] | |||
options.translate = options.translate or {} | |||
if getmetatable(options.translate) == nil then | |||
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 | |||
--[[ | --[[ | ||
Line 82: | Line 114: | ||
local title = parent:getTitle():gsub('/sandbox$', '') | local title = parent:getTitle():gsub('/sandbox$', '') | ||
local found = false | local found = false | ||
if type(options.wrappers) == 'table' then | if matchesTitle(options.wrappers, title) then | ||
found = true | |||
elseif type(options.wrappers) == 'table' then | |||
for _,v in pairs(options.wrappers) do | for _,v in pairs(options.wrappers) do | ||
if v | if matchesTitle(v, title) then | ||
found = true | found = true | ||
break | break | ||
end | end | ||
end | end | ||
end | end | ||
-- We test for false specifically here so that nil (the default) acts like true. | -- We test for false specifically here so that nil (the default) acts like true. | ||
if found or options.frameOnly == false then | if found or options.frameOnly == false then | ||
Line 117: | Line 149: | ||
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 | ||
Line 165: | Line 197: | ||
setmetatable(args, metatable) | setmetatable(args, metatable) | ||
local function mergeArgs( | 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 | -- into one table. If a value is already present it is not overwritten; | ||
-- tables listed earlier have precedence. We are also memoizing nil | |||
-- values, which can be overwritten if they are 's' (soft). | |||
--]] | --]] | ||
for _, t in ipairs(tables) do | for _, t in ipairs(tables) do | ||
for key, val in | for key, val in pairs(t) do | ||
if metaArgs[key] == nil then | if metaArgs[key] == nil and nilArgs[key] ~= 'h' then | ||
local tidiedVal = tidyVal(key, val) | local tidiedVal = tidyVal(key, val) | ||
if tidiedVal == nil then | if tidiedVal == nil then | ||
nilArgs[key] = | nilArgs[key] = 's' | ||
else | else | ||
metaArgs[key] = tidiedVal | metaArgs[key] = tidiedVal | ||
Line 211: | Line 242: | ||
-- must be nil. | -- must be nil. | ||
--]] | --]] | ||
if type(key) == 'string' then | |||
key = options.translate[key] | |||
end | |||
local val = metaArgs[key] | local val = metaArgs[key] | ||
if val ~= nil then | if val ~= nil then | ||
Line 219: | Line 253: | ||
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] = argTableVal | metaArgs[key] = argTableVal | ||
return argTableVal | return argTableVal | ||
end | end | ||
end | end | ||
nilArgs[key] = 'h' | |||
return nil | return nil | ||
end | end | ||
Line 232: | Line 265: | ||
-- 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 type(key) == 'string' then | |||
key = options.translate[key] | |||
end | |||
if options.readOnly then | if options.readOnly then | ||
error( | error( | ||
Line 255: | Line 291: | ||
--]] | --]] | ||
metaArgs[key] = nil | metaArgs[key] = nil | ||
nilArgs[key] = | nilArgs[key] = 'h' | ||
else | else | ||
metaArgs[key] = val | metaArgs[key] = val | ||
end | |||
end | |||
local function translatenext(invariant) | |||
local k, v = next(invariant.t, invariant.k) | |||
invariant.k = k | |||
if k == nil then | |||
return nil | |||
elseif type(k) ~= 'string' or not options.backtranslate then | |||
return k, v | |||
else | |||
local backtranslate = options.backtranslate[k] | |||
if backtranslate == nil then | |||
-- Skip this one. This is a tail call, so this won't cause stack overflow | |||
return translatenext(invariant) | |||
else | |||
return backtranslate, v | |||
end | |||
end | end | ||
end | end | ||
Line 264: | Line 318: | ||
-- 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( | mergeArgs(argTables) | ||
metatable.donePairs = true | metatable.donePairs = true | ||
end | end | ||
return | return translatenext, { t = metaArgs } | ||
end | end | ||
metatable.__ipairs = function () | local function inext(t, i) | ||
-- This uses our __index metamethod | |||
local v = t[i + 1] | |||
if v ~= nil then | |||
return i + 1, v | |||
end | |||
end | |||
metatable.__ipairs = function (t) | |||
-- Called when ipairs is run on the args table. | -- Called when ipairs is run on the args table. | ||
return inext, t, 0 | |||
end | end | ||