|
Módulo:Arguments
Uso básicoPrimeiro, você precisa carregar o módulo. Ele contém uma função, chamada local getArgs = require('Module:Arguments').getArgs
No cenário mais básico, você pode utilizar local getArgs = require('Module:Arguments').getArgs
local p = {}
function p.main(frame)
local args = getArgs(frame)
-- O código principal do módulo vai aqui.
end
return p
No entanto, a prática recomendada é utilizar uma função apenas para o processamento dos argumentos de local getArgs = require('Module:Arguments').getArgs
local p = {}
function p.main(frame)
local args = getArgs(frame)
return p._main(args)
end
function p._main(args)
-- O código principal do módulo vai aqui.
end
return p
Se você quer que várias funções utilizem os argumentos, e você também quer que eles sejam acessíveis a partir de local getArgs = require('Module:Arguments').getArgs
local function makeInvokeFunc(funcName)
return function (frame)
local args = getArgs(frame)
return p[funcName](args)
end
end
local p = {}
p.func1 = makeInvokeFunc('_func1')
function p._func1(args)
-- O código para a primeira função vai aqui.
end
p.func2 = makeInvokeFunc('_func2')
function p._func2(args)
-- O código para a segunda função vai aqui.
end
return p
OpçõesEstão disponíveis as seguintes opções. Elas são explicadas nas seções abaixo. local args = getArgs(frame, {
trim = false,
removeBlanks = false,
valueFunc = function (key, value)
-- Código para processar um argumento
end,
frameOnly = true,
parentOnly = true,
parentFirst = true,
wrappers = {
'Predefinição:Um invólucro',
'Predefinição:Outro invólucro'
},
readOnly = true,
noOverwrite = true
})
Remoção de espaços e parâmetros em brancoArgumentos em branco geralmente confundem os programadores que tentam converter predefinições do MediaWiki para Lua. Na sintaxe das predefinições, as strings vazias e aquelas que consistem apenas de espaços em branco são consideradas equivalentes a falso. No entanto, em Lua, tais strings são consideradas equivalentes a verdadeiro. Isso significa que se você não prestar atenção ao lidar com estes argumentos durante o desenvolvimento de módulos em Lua, você pode tratar algo como verdadeiro quando na verdade deveria ser falso. Para evitar isso, por padrão este módulo remove todos os argumentos em branco. Analogamente, espaços em branco podem causar problemas ao lidar com argumentos posicionais. Embora eles sejam removidos de parâmetros com nome vindos de No entanto, algumas vezes você quer aceitar argumentos em branco como entrada e algumas vezes você quer manter espaços extras. Isso pode ser necessário para converter algumas predefinições exatamente da forma como foram escritas. Se você quer fazer isso, você pode definir os parâmetros local args = getArgs(frame, {
trim = false,
removeBlanks = false
})
Formatação personalizada dos argumentosAlgumas vezes você quer remover alguns argumentos em branco mas não outros, ou talvez converter os valores de todos os argumentos posicionais para minúsculas. Para fazer coisas deste tipo você pode usar a opção Exemplo 1: esta função preserva os espaços em branco para o primeiro argumento posicional, mas remove-os dos demais e também remove os demais argumentos em branco. local args = getArgs(frame, {
valueFunc = function (key, value)
if key == 1 then
return value
elseif value then
value = mw.text.trim(value)
if value ~= '' then
return value
end
end
return nil
end
})
Exemplo 2: esta função remove parâmetros em branco e converte todos os argumentos para minúsculas, mas não remove espaços dos argumentos posicionais. local args = getArgs(frame, {
valueFunc = function (key, value)
if not value then
return nil
end
value = mw.ustring.lower(value)
if mw.ustring.find(value, '%S') then
return value
end
return nil
end
})
Nota: a função acima falhará se receber como entrada algo que não seja do tipo
Além disso, por favor note que a função Frames e frames paisOs argumentos da tabela
O Agora, se chamarmos a
Há três opções que você pode definir para alterar este comportamento: frameOnly
parentOnly
parentFirst
Notas:
InvólucrosA opção wrappers é utilizada para especificar um número limitado de predefinições de invólucro, isto é, predefinições cujo único objetivo é chamar um módulo. Se o módulo detecta que está sendo chamado de uma predefinição de invólucro, ele procurará apenas argumentos do frame pai; caso contrário ele procurará apenas argumentos no frame passado para getArgs. Isso permite que os módulos sejam chamados tanto por #invoke quanto através de uma predefinição de invólucro sem a perda de desempenho associada à chacagem tanto do frame quanto do frame pai ao verificar cada argumento. Por exemplo, o conteúdo da en:Template:Side box (excluindo o conteúdo das tags Os invólucros podem ser especificados tanto como uma cadeia de caracteres (string) quanto como uma array de cadeias de caracteres. local args = getArgs(frame, {
wrappers = 'Predefinição:Predefinição de invólucro'
})
local args = getArgs(frame, {
wrappers = {
'Predefinição:Um invólucro',
'Predefinição:Outro invólucro',
-- Pode-se inserir qualquer número de invólucros aqui.
}
})
Notas:
Escrevendo na tabela de argumentosAlgumas vezes pode ser útil escrever novos valores na tabela de argumentos. Isso é possível com a configuração padrão do módulo. (No entanto, tenha em mente que geralmente um estilo de programação melhor seria criar uma nova tabela com os seus novos argumentos e copiar os argumentos da tabela args.foo = 'algum valor'
É possível alterar este comportamento com as opções Elementos "ref"Este módulo utiliza metatables para obter argumentos de Assim que os elementos Este módulo resolve esse problema permitindo o acesso tanto aos argumentos do frame atual quanto aos do frame pai, ao mesmo tempo em que só requisita esses argumentos quando são necessários. No entanto, o problema ainda ocorrerá se você utilizar Limitações conhecidasO uso de metatables também tem aspectos negativos. A maioria das ferramentas normais para tabelas em Lua não funcionarão adequadamente na tabela Ver também
-- Este módulo fornece processamento fácil de argumentos passados para a Scribunto
-- a partir de #invoke. Ele destina-se ao uso por outros módulos Lua e não
-- deve ser chamado diretamente a partir de #invoke.
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local arguments = {}
-- Gera quatro funções "tidyVal" diferentes, para que não tenhamos que verificar
-- as opções todas vezes que chamamos.
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
local function tidyValRemoveBlanksOnly(key, val)
if type(val) == 'string' then
if val:find('%S') then
return val
else
return nil
end
else
return val
end
end
local function tidyValNoChange(key, val)
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 {}
--[[
-- Define a tradução de argumentos.
--]]
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
--[[
-- Obtém as tabelas de argumentos. Se nos foi passado um objeto de quadro válido,
-- obtemos os argumentos do quadro ("fargs") e os argumentos do quadro parental ("pargs"),
-- dependendo das opções definidas e da disponibilidade do quadro parental. Se não nos
-- foi passado um objeto de quadro válido, estamos sendo chamados de outro módulo Lua
-- ou do console de depuração, então assume que uma tabela de argumentos nos foi passada
-- diretamente e a atribui a uma nova variável ("luaArgs").
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- A opção "wrappers" faz o Módulo:Arguments procurar argumentos na
-- tabela de argumentos do quadro ou na tabela de argumentos parental, mas
-- mas não em ambas. Isso significa que os usuários podem usar a sintaxe
-- "#invoke" ou uma predefinição "wrapper" sem a perda de desempenho
-- associada à procura de argumentos no quadro e no quadro parental.
-- O Módulo:Arguments procurará argumentos no quadro parental
-- se encontrar o título do quadro parental em "options.wrapper";
-- caso não, ele procurará argumentos no objeto de quadro passado
-- para "getArgs".
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/Testes$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end
-- Nós testamos "false" especificamente aqui para que
-- "nil" (o padrão) aja como "true".
if found or options.frameOnly == false then
pargs = parent.args
end
if not found or options.parentOnly == false then
fargs = frame.args
end
end
else
-- "options.wrapper" não está definido, portanto verifica as
-- outras opções.
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end
-- Define a ordem de precedência das tabelas de argumentos. Se as variáveis
-- forem "nil", nada será adicionado à tabela, que é como evitamos confrontos
-- entre os argumentos do quadro/parental e os argumentos Lua.
local argTables = {fargs}
argTables[#argTables + 1] = pargs
argTables[#argTables + 1] = luaArgs
--[[
-- Gera a função "tidyVal". Se tiver sido especificado pelo usuário, nós
-- usamos isso; caso não, escolhemos uma das quatro funções dependendo das
-- opções escolhidas. Isso é para que não tenhamos que chamar a tabela de
-- opções toda vez que a função for chamada.
--]]
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(
"valor inválido atribuído à opção 'valueFunc'"
.. '(função esperada, obteve '
.. type(tidyVal)
.. ')',
2
)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end
--[[
-- Define as tabelas "args", "metaArgs" e "nilArgs". "args" será a única
-- acessada a partir de funções e "metaArgs" manterá os argumentos reais.
-- Os argumentos nulos são memorizados em "nilArgs" e a metatabela
-- conecta todos eles juntos.
--]]
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)
local function mergeArgs(tables)
--[[
-- Aceita várias tabelas como entrada e mescla suas chaves e valores
-- em uma tabela. Se um valor já estiver presente, ele não será substituído;
-- as tabelas listadas anteriormente têm precedência. Também estamos memorizando
-- valores nulos, que podem ser sobrescritos se forem "s" ('soft').
--]]
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end
--[[
-- Define o comportamento da metatabela. Os argumentos são memorizados na tabela "metaArgs",
-- e são buscados apenas uma vez nas tabelas de argumentos. Obter os argumentos
-- a partir das tabelas de argumentos é o passo mais intensiva em recursos neste
-- módulo, então tentamos evitá-lo sempre que possível. Por este motivo, os argumentos nulos
-- também são memorizados, na tabela "nilArgs". Além disso, mantemos um registro
-- na metatabela de quando "pairs" e "ipairs" foram chamadas, então nós não
-- executamos "pairs" e "ipairs" nas tabelas de argumentos mais de uma vez. Nós também
-- não executamos "ipairs" em "fargs" e "pargs" se "pairs" já tiver sido executada,
-- pois todos os argumentos já terão sido copiados.
--]]
metatable.__index = function (t, key)
--[[
-- Busca um argumento quando a tabela "args" é indexada. Primeiro nós verificamos
-- para ver se o valor está memorizado e, caso não, tentamos buscá-lo a partir
-- das tabelas de argumentos. Quando nós verificamos a memorização, nós precisamos verificar
-- "metaArgs" antes de "nilArgs", pois ambas podem não ser nulas ('nil') ao mesmo tempo.
-- Se o argumento não estiver presente em "metaArgs", nós também verificamos se
-- "pairs" já foi executada. Se "pairs" já tiver sido executada, retornamos "nil" (nulo).
-- Isso ocorre porque todos os argumentos já terão sido copiados para
-- "metaArgs" pela função "mergeArgs", significando que quaisquer outros
-- argumentos devem ser "nil" (nulos).
--]]
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end
metatable.__newindex = function (t, key, val)
-- Esta função é chamada quando um módulo tenta adicionar um novo
-- valor à tabela "args" ou tenta alterar um valor existente.
if type(key) == 'string' then
key = options.translate[key]
end
if options.readOnly then
error(
'não foi possível gravar na chave da tabela de argumentos "'
.. tostring(key)
.. '"; a tabela é somente leitura',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'não foi possível gravar na chave da tabela de argumentos "'
.. tostring(key)
.. '"; sobrescrever argumentos existentes não é permitido',
2
)
elseif val == nil then
--[[
-- Se o argumento for substituído por "nil", nós precisamos apagar
-- o valor em "metaArgs", para que "__index", "__pairs" e "__ipairs"
-- não usem um valor existente anterior, se presente; e nós também precisamos
-- memorizar "nil" (nulo) em "nilArgs", para que o valor não seja procurado
-- nas tabelas de argumentos se for acessado novamente.
--]]
metaArgs[key] = nil
nilArgs[key] = 'h'
else
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
-- Ignora este. Esta é uma chamada final, então isso não causará
-- estouro de pilha
return translatenext(invariant)
else
return backtranslate, v
end
end
end
metatable.__pairs = function ()
-- Chamada quando "pairs" é executada na tabela "args".
if not metatable.donePairs then
mergeArgs(argTables)
metatable.donePairs = true
end
return translatenext, { t = metaArgs }
end
local function inext(t, i)
-- Isso usa nosso metamétodo "__index"
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end
metatable.__ipairs = function (t)
-- Chamada quando "ipairs" é executada na tabela "args".
return inext, t, 0
end
return args
end
return arguments
|
Portal di Ensiklopedia Dunia
