Módulo:Category handler/Testes
![]() | Esta é a página de testes de módulos de Módulo:Category handler (dif). Ver também exemplos para testes na subpágina acompanhante (executar). |
![]() | Este módulo depende dos seguintes outros módulos: |
Este módulo implementa a predefinição {{Category handler/Testes}}. A predefinição para lidar com categorias ajuda outras predefinições a automatizar tanto a categorização quanto a supressão de categoria [en]. Para obter informações sobre como usar a predefinição para lidar com categorias em outras predefinições, consulte a documentação da predefinição. Continue lendo para obter informações sobre como usar o módulo para lidar com categorias em outros módulos Lua ou para obter informações sobre como exportar este módulo para outras wikis.
Uso a partir de outros módulos Lua
[editar código-fonte]Quando não usar este módulo
[editar código-fonte]Para os casos em que um módulo só precisa categorizar em, um dos espaços nomeados, "Principal" (artigos), "Ficheiro" (imagens) ou "Categoria", usar este módulo é um exagero. Em vez disso, você pode simplesmente obter um objeto de título usando "mw.title.getCurrentTitle" e verificar o campo "nsText
". Por exemplo:
local title = mw.title.getCurrentTitle()
if title.nsText == 'Ficheiro' then
-- fazer algo
end
No entanto, se o seu módulo precisar categorizar em qualquer outro espaço nomeado, recomendamos que você use este módulo, pois ele fornece supressão de categoria adequada e facilita a seleção de como categorizar em espaços nomeados diferentes.
Espaços nomeados
[editar código-fonte]Este módulo detecta e agrupa todos os diferentes espaços nomeados usados na Wikipédia em vários tipos. Esses tipos são usados como nomes de parâmetros neste módulo.
- main = Espaço principal/artigo, como nos artigos normais da Wikipédia.
- talk = Qualquer espaço de discussão, como nomes de páginas que começam com "Discussão:", "Discussão Usuário:", "Discussão Ficheiro:" e assim por diante.
- user, wikipedia, file ... = Os outros espaços nomeados exceto as páginas de discussão. Nomes alternativos de espaços nomeados também são aceitos. Consulte a tabela abaixo para obter a lista completa.
- other = Quaisquer espaços nomeados que não foram especificados como um parâmetro para a predefinição. Consulte os exemplos abaixo.
- Lista de possíveis parâmetros de espaços nomeados
(excluindo talk
e other
)
Espaço nomeado | Nome(s) alternativo(s) |
---|---|
main
|
principal
|
usuário(a)
|
user , utilizador , usuário , usuária , utilizador(a) , utilizadora
|
wikipédia
|
project , wikipedia , wp
|
ficheiro
|
file , imagem , arquivo , image
|
mediawiki
|
|
predefinição
|
template
|
ajuda
|
help
|
categoria
|
category
|
portal
|
|
livro
|
|
education program
|
|
timedtext
|
|
módulo
|
module
|
tópico
|
topic
|
Uso básico
[editar código-fonte]Este módulo leva dois ou mais parâmetros. Aqui está um exemplo usando um programa "Hello world":
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Hello world!'
local category = categoryHandler{
'[[Categoria:Alguma categoria]]',
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
O exemplo acima usa as configurações padrões para o módulo que lida com categorias. Isso significa que o módulo de exemplo categorizará as páginas nos seguintes espaços nomeados:
- main, file, help, category, portal e book
Mas ele não categorizará em nenhum outro espaço nomeado, por exemplo:
- talk, user, wikipedia, mediawiki, template ...
E ele não categorizará em páginas da lista negra. (Consulte a seção Lista negra abaixo.)
A razão pela qual o módulo para lidar com categorias não categoriza em alguns dos espaços nomeados é que nesses espaços nomeados a maioria dos módulos e das predefinições são apenas demonstrados ou listados, não usados. Portanto, a maioria dos módulos e predefinições não devem ser categorizados nesses espaços nomeados.
Quaisquer módulos ou predefinições, destinados a um ou mais dos espaços nomeados onde esse módulo categoriza, podem usar a sintaxe básica mostrada acima.
Uso avançado
[editar código-fonte]Este módulo recebe um ou mais parâmetros nomeados de acordo com os diferentes tipos de página listados na seção espaços nomeados acima. Ao usar esses parâmetros, você pode especificar exatamente em quais espaços nomeados sua predefinição deve categorizar. Assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Este é um módulo destinado a artigos e páginas de discussão.'
local category = categoryHandler{
main = '[[Categoria:Alguma categoria 1]]', -- Categoriza no espaço principal (artigo)
talk = '[[Categoria:Alguma categoria 2]]', -- Categoriza no espaço de discussão
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
O módulo acima categorizará apenas no espaço principal e de discussão. Mas não irá categorizar nas páginas "/arquivo", pois elas estão na lista negra. (Consulte a seção lista negra abaixo.) E se você precisar demonstrar (discutir) o módulo em uma página de discussão, poderá alimentar "nocat='true'
" para evitar que a predefinição a categorize. (Consulte a seção nocat abaixo.) Assim:
== Meu novo módulo == Ei pessoal, vocês viram meu novo módulo? {{#invoke:Mymodule|main|nocat=true}} Legal, não é? --~~~~
Às vezes queremos usar a mesma categoria em vários espaços nomeados, então fazemos assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Este é um módulo usado em vários espaços nomeados.'
local category = categoryHandler{
main = '[[Categoria:Alguma categoria 1]]',
[ 1 ] = '[[Categoria:Alguma categoria 2]]', -- Para os espaços de "ajuda" e "usuário"
help = 1,
user = 1,
talk = '', -- Nenhuma categoria nas páginas de discussão
other = '[[Categoria:Alguma categoria 3]]', -- Para todos os outros espaços nomeados
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
No exemplo acima, usamos um parâmetro numerado para alimentar uma das categorias e, em seguida, dizemos a este módulo para usar esse parâmetro numerado tanto para o espaço ajuda quanto para usuário.
O módulo que lida com categorias compreende um número ilimitado de parâmetros numerados.
O parâmetro "other" define o que deve ser usado nos espaços nomeados restantes que não foram explicitamente alimentados com dados.
Observe o parâmetro "talk" vazio, mas definido. Isso impede que este módulo mostre o que foi alimentado ao parâmetro "other", quando no espaço de discussão.
O módulo que lida com categorias também possui um parâmetro chamado "all". Funciona assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Este é um módulo usado em todos os espaços nomeados.'
local category = categoryHandler{
all = '[[Categoria:Alguma categoria 1]]', -- em todos os espaços nomeados
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
O exemplo acima categorizará em todos os espaços nomeados, mas não nas páginas da lista negra. Se você deseja demonstrar esse módulo em uma página, use "nocat=true
" para evitar que a predefinição categorize.
Sugerimos evitar o parâmetro "all", já que os módulos e as predefinições devem preferencialmente ser categorizados apenas nos espaços nomeados que eles precisam.
O parâmetro "all" também pode ser combinado com os demais parâmetros. Assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Este é um módulo usado em todos os espaços nomeados'
local category = categoryHandler{
all = '[[Categoria:Alguma categoria 1]]', -- Categoriza em todos os espaços nomeados
main = '[[Categoria:Alguma categoria 2]]', -- E adiciona isso no espaço principal
other = '[[Categoria:Alguma categoria 3]]', -- E adiciona isso em todos os outros espaços nomeados
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
Se o módulo acima for colocado em um artigo, ele adicionará as categorias "Alguma categoria 1" e "Alguma categoria 2". Mas em todos os outros tipos de páginas, ele adicionará "Alguma categoria 1" e "Alguma categoria 3". Como mostra o exemplo, o parâmetro "all" funciona independentemente do restante dos parâmetros.
Subpáginas
[editar código-fonte]O módulo para lidar com categorias entende o parâmetro "subpage". Assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Este é um módulo usado em todos os espaços nomeados.'
local category = categoryHandler{
subpage = 'no' -- Não categoriza em subpáginas
wikipedia = '[[Categoria:Alguma categoria]]',
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
Se "subpage='no'
", então esta predefinição não categorizará em subpáginas. Nas raras ocasiões em que você apenas deseja categorizar em subpáginas, use "subpage='only'
". Se "subpage" estiver vazio ou indefinido, então esta predefinição categoriza tanto em páginas base quanto em subpáginas.
Lista negra
[editar código-fonte]Este módulo possui uma lista negra das páginas e tipos de página onde as predefinições não devem categorizar automaticamente. Assim, os módulos que usam esta meta-predefinição, por exemplo, não categorizarão nas páginas "/arquivo" e nas subpáginas de Wikipédia:Lista de predefinições.
Se você deseja que uma predefinição categorize em uma página da lista negra, insira "nocat = false
" no módulo ao colocá-lo na página, ignorando assim a verificação da lista negra. Observe que este módulo só categoriza se tiver dados para o espaço nomeado. Por exemplo, se a sintaxe básica for usada (consulte uso básico acima), mesmo que você defina "nocat = false
" a predefinição não categorizará em uma página de discussão , pois não possui dados para páginas de discussão. Mas ela possui dados para o espaço de ajuda, portanto, em uma página de ajuda na lista negra, ela categorizará.
A lista negra está localizada na tabela de configuração "cfg.blacklist
" próximo ao topo do código do módulo.
O parâmetro "nocat"
[editar código-fonte]Este módulo entende o parâmetro "nocat":
- Se "
nocat = true
", então esta predefinição não categoriza. - Se "nocat" for
nil
, então esta predefinição categoriza como de costume. - Se "
nocat = false
", então esta predefinição categoriza mesmo quando em páginas da lista negra. (Consulte a seção lista negra acima.) - O parâmetro "nocat" também aceita nomes alternativos para "
true
" e "false
" conforme definido por Módulo:Yesno/Testes, por exemplo: "yes", "y", "true" e "1" para "true
" e "no", "n", "false" e "0" para "false
".
Os módulos e as predefinições que usam {{Category handler/Testes}} devem encaminhar "nocat", para que eles também entendam "nocat". O código "nocat = frame.args.nocat
" mostrado nos exemplos desta página faz isso.
O parâmetro "categories"
[editar código-fonte]Para compatibilidade com versões anteriores, este módulo também entende o parâmetro "categories". Funciona da mesma forma que "nocat". Assim:
- Se "
categories = false
", então esta predefinição não categoriza. - Se "categories" estiver vazio ou indefinido, então esta predefinição categoriza como de costume.
- Se "
categories = true
", então esta predefinição categoriza mesmo quando em páginas da lista negra. - O parâmetro "categories" também aceita nomes alternativos para "
true
" e "false
" conforme definido por Módulo:Yesno/Testes, por exemplo: "yes", "y", "true" e "1" paratrue
e "no", "n", "false" e "0" para "false
".
O parâmetro "category2"
[editar código-fonte]Para compatibilidade com versões anteriores, esta predefinição oferece suporte ao antigo parâmetro "category =". Mas o nome do parâmetro "category" já é usado neste módulo para alimentar os dados de categoria quando estiver no espaço de categoria. Então, em vez disso, esta predefinição usa "category2" para o uso semelhante ao de "nocat". Assim:
Se "category2 = "
" (vazio, mas definido), ou "category2 = 'no'
", ou se "category2" for alimentado com qualquer outro dado ( exceto conforme descrito nos próximos dois pontos), então esta predefinição não categoriza.
- Se "category2" for indefinido ou se "
category2 = '¬'
", então esta predefinição categoriza como de costume. - Se "
category2 = 'yes'
", então esta predefinição categoriza mesmo quando em páginas na lista negra.
Categorias e texto
[editar código-fonte]Além das categorias, você pode alimentar qualquer outra coisa para este módulo, por exemplo, algum texto. Assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local result = 'Este é um módulo usado em páginas de discussão.'
local category = categoryHandler{
talk = '[[Categoria:Alguma categoria]]',
other = '<p class="error">Este módulo só deve ser usado em páginas de discussão.</p>',
nocat = frame.args.nocat -- Então "nocat=true/false" funciona
}
category = category or '' -- Verifica se não temos um valor nulo para a variável de categoria.
return result .. category
end
return p
Quando o código do módulo acima for usado em algo que não seja uma página de discussão, ele ficará assim:
- Este é um módulo usado em páginas de discussão.
Este módulo só deve ser usado em páginas de discussão.
Esse texto não aparecerá nas páginas da lista negra, portanto, não use esse método para mostrar informações importantes. Alimentar "nocat = 'true'
" para a predefinição oculta o texto, assim como suprime quaisquer categorias.
O parâmetro "page"
[editar código-fonte]Para fins de teste e demonstração, este módulo pode receber um parâmetro chamado "page". Assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local category = categoryHandler{
main = 'Categoria:Alguma categoria',
talk = 'Categoria:Categoria de discussão',
nocat = frame.args.nocat, -- Então "nocat=true/false" funciona
page = 'Usuário Discussão:Exemplo'
}
return category
end
return p
No código acima, de propósito, deixamos de fora os colchetes ao redor dos nomes das categorias para que possamos ver a saída na página. Não importa em que tipo de página o código acima é usado, ele retornará isso:
- Categoria:Categoria de discussão
O parâmetro "page" faz com que este módulo se comporte exatamente como se estivesse naquela página. Até a lista negra funciona. O nome da página não precisa ser uma página existente.
Se o parâmetro "page" estiver vazio ou indefinido, o nome da página atual determinará o resultado.
Você pode fazer com que seu módulo também entenda o parâmetro "page". Isso significa que você pode testar como sua predefinição categorizará em páginas diferentes, sem precisar editar essas páginas. Então faça assim:
p = {}
local categoryHandler = require( 'Módulo:Category handler/Testes' ).main
function p.main( frame )
local category = categoryHandler{
main = 'Categoria:Alguma categoria',
talk = 'Categoria:Categoria de discussão',
nocat = frame.args.nocat, -- Então "nocat=true/false" funciona
page = frame.args.page -- Para teste
}
return category
end
return p
Parâmetros
[editar código-fonte]Lista de todos os parâmetros:
- Primeiro parâmetro posicional - para configurações padrão
- subpage = 'no' / 'only'
- 1, 2, 3 ...
- all = '[[Categoria:Alguma categoria']]' / 'Texto'
- main = 1, 2, 3 ... / '[[Categoria:Alguma categoria']]' / 'Texto'
- ...
- other = 1, 2, 3 ... / '[[Categoria:Alguma categoria']]' / 'Texto'
- nocat = frame.args.nocat / true / false / 'yes' / 'no' / 'y' / 'n' / 'true' / 'false' / 1 / 0
- categories = frame.args.categories / false / true / 'no' / 'yes' / 'n' / 'y' / 'false' / 'true' / 0 / 1
- category2 = frame.args.category or '¬' / 'no' / 'not defined' / '¬' / 'yes'
- page = frame.args.page / 'Usuário:Exemplo'
Observe que valores vazios para os parâmetros "main" ... "other" têm um significado especial (consulte os exemplos acima). O parâmetro "all" não entende parâmetros numerados, pois nunca deveria haver necessidade disso.
Exportando para outras wikis
[editar código-fonte]Este módulo pode ser exportado para outras wikis alterando os valores de configuração na tabela "cfg
". Todos os valores das variáveis são configuráveis, portanto, após os valores de configuração terem sido definidos, não haverá necessidade de alterar o código do módulo principal. Os detalhes de cada valor de configuração estão incluídos nos comentários do código do módulo. Além disso, este módulo requer que Módulo:Namespace detect/Testes esteja disponível na wiki local.
Ver também
[editar código-fonte]- {{Category handler/Testes}} – para usar este módulo com predefinições, em vez de com módulos Lua.
- Supressão de categoria [en] – O guia de como fazer.
- Projeto Wiki Supressão de categoria [en] – O projeto wiki.
- Wikipédia:Domínio – Lista todos os espaços nomeados.
--------------------------------------------------------------------------------
-- --
-- Category handler --
-- --
-- Este módulo implementa a predefinição {{Category handler/Testes}} --
-- em Lua, com algumas melhorias: todos os espaços nomeados e todos os --
-- nomes alternativos de espaços nomeados são suportados e os nomes de --
-- espaços nomeados são detectados automaticamente para a wiki local. --
-- Este módulo requer [[Módulo:Namespace detect/Testes]] e --
-- [[Módulo:Yesno/Testes]] para estar disponível na wiki local. Ele pode --
-- ser configurado, para diferentes wikis, alterando os valores em --
-- [[Módulo:Category handler/Testes/config]], e as páginas podem ser --
-- colocadas na lista negra da categorização usando --
-- [[Módulo:Category handler/Testes/blacklist]]. --
-- --
--------------------------------------------------------------------------------
-- Carrega os módulos necessários
local yesno = require('Módulo:Yesno/Testes')
-- Carrega "preguiçosamente" coisas que nem sempre precisamos
local mShared, mappings
local p = {}
--------------------------------------------------------------------------------
-- Funções auxiliares
--------------------------------------------------------------------------------
local function trimWhitespace(s, removeBlanks)
if type(s) ~= 'string' then
return s
end
s = s:match('^%s*(.-)%s*$')
if removeBlanks then
if s ~= '' then
return s
else
return nil
end
else
return s
end
end
--------------------------------------------------------------------------------
-- CategoryHandler class
--------------------------------------------------------------------------------
local CategoryHandler = {}
CategoryHandler.__index = CategoryHandler
function CategoryHandler.new(data, args)
local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
-- Define o objeto de título
do
local pagename = obj:parameter('demopage')
local success, titleObj
if pagename then
success, titleObj = pcall(mw.title.new, pagename)
end
if success and titleObj then
obj.title = titleObj
if titleObj == mw.title.getCurrentTitle() then
obj._usesCurrentTitle = true
end
else
obj.title = mw.title.getCurrentTitle()
obj._usesCurrentTitle = true
end
end
-- Define os valores dos parâmetros de supressão
for _, key in ipairs{'nocat', 'categories'} do
local value = obj:parameter(key)
value = trimWhitespace(value, true)
obj['_' .. key] = yesno(value)
end
do
local subpage = obj:parameter('subpage')
local category2 = obj:parameter('category2')
if type(subpage) == 'string' then
subpage = mw.ustring.lower(subpage)
end
if type(category2) == 'string' then
subpage = mw.ustring.lower(category2)
end
obj._subpage = trimWhitespace(subpage, true)
obj._category2 = trimWhitespace(category2) -- não remove valores em branco
end
return obj
end
function CategoryHandler:parameter(key)
local parameterNames = self._data.parameters[key]
local pntype = type(parameterNames)
if pntype == 'string' or pntype == 'number' then
return self._args[parameterNames]
elseif pntype == 'table' then
for _, name in ipairs(parameterNames) do
local value = self._args[name]
if value ~= nil then
return value
end
end
return nil
else
error(string.format(
'chave de configuração inválida "%s"',
tostring(key)
), 2)
end
end
function CategoryHandler:isSuppressedByArguments()
return
-- Vê se um argumento de supressão de categoria foi definido.
self._nocat == true
or self._categories == false
or (
self._category2
and self._category2 ~= self._data.category2Yes
and self._category2 ~= self._data.category2Negative
)
-- Verifica se estamos em uma subpágina e vê se as categorias foram
-- suprimidas com base no estado de nossa subpágina.
or self._subpage == self._data.subpageNo and self.title.isSubpage
or self._subpage == self._data.subpageOnly and not self.title.isSubpage
end
function CategoryHandler:shouldSkipBlacklistCheck()
-- Verifica se os argumentos de supressão de categoria indicam que nós
-- devemos pular a verificação da lista negra.
return self._nocat == false
or self._categories == true
or self._category2 == self._data.category2Yes
end
function CategoryHandler:matchesBlacklist()
if self._usesCurrentTitle then
return self._data.currentTitleMatchesBlacklist
else
mShared = mShared or require('Módulo:Category handler/Testes/shared')
return mShared.matchesBlacklist(
self.title.prefixedText,
mw.loadData('Módulo:Category handler/Testes/blacklist')
)
end
end
function CategoryHandler:isSuppressed()
-- Localiza se as categorias são suprimidas pelos argumentos ou pela
-- correspondência com a lista negra.
return self:isSuppressedByArguments()
or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end
function CategoryHandler:getNamespaceParameters()
if self._usesCurrentTitle then
return self._data.currentTitleNamespaceParameters
else
if not mappings then
mShared = mShared or require('Módulo:Category handler/Testes/shared')
mappings = mShared.getParamMappings(true) -- obtém os mapeamentos com "mw.loadData"
end
return mShared.getNamespaceParameters(
self.title,
mappings
)
end
end
function CategoryHandler:namespaceParametersExist()
-- Localiza se algum parâmetro de espaço nomeado foi especificado.
-- Usamos a ordem "all" --> parâmetros de espaços nomeados --> "other"
-- pois era isso que a predefinição antiga fazia.
if self:parameter('all') then
return true
end
if not mappings then
mShared = mShared or require('Módulo:Category handler/Testes/shared')
mappings = mShared.getParamMappings(true) -- obtém os mapeamentos com "mw.loadData"
end
for ns, params in pairs(mappings) do
for i, param in ipairs(params) do
if self._args[param] then
return true
end
end
end
if self:parameter('other') then
return true
end
return false
end
function CategoryHandler:getCategories()
local params = self:getNamespaceParameters()
local nsCategory
for i, param in ipairs(params) do
local value = self._args[param]
if value ~= nil then
nsCategory = value
break
end
end
if nsCategory ~= nil or self:namespaceParametersExist() then
-- Existem parâmetros de espaços nomeados - uso avançado.
if nsCategory == nil then
nsCategory = self:parameter('other')
end
local ret = {self:parameter('all')}
local numParam = tonumber(nsCategory)
if numParam and numParam >= 1 and math.floor(numParam) == numParam then
-- "nsCategory" é um número inteiro
ret[#ret + 1] = self._args[numParam]
else
ret[#ret + 1] = nsCategory
end
if #ret < 1 then
return nil
else
return table.concat(ret)
end
elseif self._data.defaultNamespaces[self.title.namespace] then
-- Parâmetros de espaços nomeados não existem, uso simples.
return self._args[1]
end
return nil
end
--------------------------------------------------------------------------------
-- Exportações
--------------------------------------------------------------------------------
local p = {}
function p._exportClasses()
-- Usado para fins de teste.
return {
CategoryHandler = CategoryHandler
}
end
function p._main(args, data)
data = data or mw.loadData('Módulo:Category handler/Testes/data')
local handler = CategoryHandler.new(data, args)
if handler:isSuppressed() then
return nil
end
return handler:getCategories()
end
function p.main(frame, data)
data = data or mw.loadData('Módulo:Category handler/Testes/data')
local args = require('Módulo:Arguments/Testes').getArgs(frame, {
wrappers = data.wrappers,
valueFunc = function (k, v)
v = trimWhitespace(v)
if type(k) == 'number' then
if v ~= '' then
return v
else
return nil
end
else
return v
end
end
})
return p._main(args, data)
end
return p