Módulo:Testes/Gkiyoshinishimoto/Category handler

Documentação do módulo[ver] [editar] [histórico] [purgar]

Erro de comando: Não existe nenhum módulo "Testes/Gkiyoshinishimoto/Lua banner".

Este módulo implementa a predefinição {{Teste/Gkiyoshinishimoto/Category handler}}. A predefinição para lidar com categorias ajuda outras predefinições a automatizar tanto a categorização quanto a supressão da categorização [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 categorização 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:", "Usuário Discussão:", "Ficheiro Discussão:" e assim por diante.

user, wikipedia, file ... = Os outros espaços nomeados exceto as páginas de discussão. Os nomes alternativos dos 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`
`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:Testes/Gkiyoshinishimoto/Category handler' ).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:Testes/Gkiyoshinishimoto/Category handler' ).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 O parâmetro "nocat" abaixo.) Assim:

== Meu novo módulo ==
Ei pessoal, vocês viram meu novo módulo?
{{#invoke:Testes/Gkiyoshinishimoto/Meu módulo|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:Testes/Gkiyoshinishimoto/Category handler' ).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 categorização quando em 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:Testes/Gkiyoshinishimoto/Category handler' ).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:Testes/Gkiyoshinishimoto/Category handler' ).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 quando no espaço principal
        other = '[[Categoria:Alguma categoria 3]]', -- E adiciona isso quando 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:Testes/Gkiyoshinishimoto/Category handler' ).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 quando 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 este módulo não categorizará em subpáginas. Nas raras ocasiões em que você apenas deseja categorizar em subpáginas, use "subpage='only'". Se "subapge" estiver vazio ou indefinido, então este módulo 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, as predefinuções que usam este metamódulo, 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" na predefinição ao colocá-la 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 este módulo não categoriza.
Se "nocat" for nil, então este módulo categoriza como de costume.
Se "nocat = false", então este módulo 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:Testes/Gkiyoshinishimoto/Yesno, 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 {{Teste/Gkiyoshinishimoto/Category handler}} 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 este módulo não categoriza.
Se "categories" estiver vazio ou indefinido, então este módulo categoriza como de costume.
Se "categories = true", então este módulo 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:Testes/Gkiyoshinishimoto/Yesno, por exemplo: "yes", "y", "true" e "1" para true 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 este módulo não categoriza.

Se "category2" for indefinido ou se "category2 = '¬'", então este módulo categoriza como de costume.
Se "category2 = 'yes'", então este módulo 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:Testes/Gkiyoshinishimoto/Category handler' ).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 o módulo oculta o texto, assim como suprime qualquer categorização.

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:Testes/Gkiyoshinishimoto/Category handler' ).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 seu módulo categorizará em páginas diferentes, sem precisar editar essas páginas. Então faça assim:

p = {}
local categoryHandler = require( 'Módulo:Testes/Gkiyoshinishimoto/Category handler' ).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:Testes/Gkiyoshinishimoto/Namespace detect esteja disponível na wiki local.

Ver também[editar código-fonte]

{{Teste/Gkiyoshinishimoto/Category handler}} – 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.

A documentação acima é transcluída de Módulo:Testes/Gkiyoshinishimoto/Category handler/doc. (editar | histórico)
Editores podem experimentar nas páginas de teste (criar | espelhar) e de exemplos para testes (criar) deste módulo.
Subpáginas deste módulo.

--------------------------------------------------------------------------------
--                                                                            --
--                              Category handler                              --
--                                                                            --
--      Este módulo implementa a predefinição                                 --
--      {{Teste/Gkiyoshinishimoto/Category handler}} em Lua, com algumas      --
--      melhorias: todos os espaços nomeados ('namespaces') e todos os        --
--      'aliases' de espaços nomeados ('namespace') são suportados e os       --
--      nomes de espaços nomeados ('namespace') são detectados                --
--      automaticamente para a wiki local. Este módulo requer                 --
--      [[Módulo:Testes/Gkiyoshinishimoto/Namespace detect]] e                --
--      [[Módulo:Testes/Gkiyoshinishimoto/Yesno]] para estar disponível       --
--      na wiki local. Ele pode ser configurado, para diferentes wikis,       --
--      alterando os valores em                                               --
--      [[Módulo:Testes/Gkiyoshinishimoto/Category handler/config]],          --
--      e as páginas podem ser colocadas na lista negra da categorização      --
--      usando                                                                --
--      [[Módulo:Testes/Gkiyoshinishimoto/Category handler/blacklist]].       --
--                                                                            --
--------------------------------------------------------------------------------

-- Carrega os módulos necessários
local yesno = require('Módulo:Testes/Gkiyoshinishimoto/Yesno')

-- Carrega lentamente 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 ('status') 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:Testes/Gkiyoshinishimoto/Category handler/shared')
		return mShared.matchesBlacklist(
			self.title.prefixedText,
			mw.loadData('Módulo:Testes/Gkiyoshinishimoto/Category handler/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:Testes/Gkiyoshinishimoto/Category handler/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 ('namespace') foi especificado.
	-- Usamos a ordem "all" --> parâmetros de espaços nomeados ('namespace') --> "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/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 ('namespace') - 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 ('namespace') 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:Testes/Gkiyoshinishimoto/Category handler/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:Testes/Gkiyoshinishimoto/Category handler/data')
	local args = require('Módulo:Testes/Gkiyoshinishimoto/Arguments').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