Módulo:Namespace detect

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

Este módulo permite que sejam apresentados textos distintos dependendo do domínio ao qual pertence uma certa página. Ele é uma implementação em lua da predefinição {{Namespace detect}}, com algumas melhorias: há suporte para todos os domínios e todos os nomes alternativos, e os nomes dos domínios são detectados automaticamente na wiki local.

Uso

{{#invoke: Namespace detect | main
| página       = <!-- página cujo domínio será detectado, se não for a página atual -->
| principal    = <!-- texto a ser retornado para o domínio principal -->
| discussão    = <!-- texto a ser retornado nos domínios de discussão -->

<!-- texto a ser retornado para domínios de conteúdo específicos -->
| portal       = 
| categoria    = 
| usuário(a)   = 
| wikipédia    = 
| wp           = 
| ensino       = 
| mediawiki    = 
| livro        = 
| timedtext    = 
| predefinição = 
| especial     = 
| multimédia   = 
| ficheiro     = 
| imagem       = 
| ajuda        = 
| module       = 

| outro        = <!-- texto a ser retornado para domínios não especificados -->
| domínio para demonstração = <!-- domínio para o qual será mostrado o texto -->

| domínio de conteúdo = <!-- defina como "sim" para tratar páginas de discussão como se fossem os domínios de conteúdo correspondente -->
}}

Parâmetros

• principal - texto a ser retornado se a página estiver no domínio principal.
• discussão - texto a ser retornado se a página estiver em um domínio de discussão. Este pode ser qualquer dos domínios de discussão - serão detectados quaisquer das opções "Discussão:", "Wikipédia Discussão:", "Usuário(a) Discussão:", etc.
• Parâmetros dos domínios de conteúdo, tais como wikipédia, usuário(a), ficheiro... - o texto a ser retornado se a página estiver no domínio correspondente. Este módulo aceita todos os domínios de conteúdo como parâmetros, incluindo os seus nomes alternativos e os domínios virtuais. Veja abaixo uma lista dos valores suportados.
• outro - texto a ser retornado se não foi especificado nenhum parâmetro para o domínio da página. Esse texto também é retornado se |domínio para demonstração= for definido com um valor que não seja um domínio válido.
• domínio de conteúdo - se estiver em uma página de discussão, use a página de conteúdo correspondente. Pode ser definido com os valores "sim", "yes", "true" ou "1".
• página - especifica a página cujo domínio será detectado. Se não for especificada, e se |domínio para demonstração= não estiver definido, então o módulo utiliza a página atual.
• domínio para demonstração - força o módulo a se comportar como se a página estivesse no domínio especificado. Frequentemente utilizado para demonstrações.

Parâmetros de domínios

Os possíveis valores para os parâmetros de domínios são os seguintes:

Domínio	Nomes alternativos
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

Função table

Utilize o seguinte código para mostrar uma tabela com os possíveis domínios distintos que podem ser utilizados como parâmetros:

{{#invoke:Namespace detect|table|discussão=yes}}

Para incluir os parâmetros para páginas de discussão, utilize |discussão=sim.

Adaptação para outras wikis

Este módulo foi projetado para ser portável. Para utilizá-lo em uma wiki diferente, tudo o que precisará fazer é trocar os valores no Módulo:Namespace detect/config. Há instruções naquela página.

Detalhes técnicos

O módulo utiliza a página Módulo:Namespace detect/data. Essa página é carregadas com mw.loadData, o que significa que ela é processada uma vez por página em vez de uma vez a cada #invoke. Isso foi feito por questões de eficiência.

--[[
--------------------------------------------------------------------------------
--                                                                            --
--                            NAMESPACE DETECT                                --
--                                                                            --
-- This module implements the {{namespace detect}} template in Lua, with a    --
-- few improvements: all namespaces and all namespace aliases are supported,  --
-- and namespace names are detected automatically for the local wiki. The     --
-- module can also use the corresponding subject namespace value if it is     --
-- used on a talk page. Parameter names can be configured for different wikis --
-- by altering the values in the "cfg" table in                               --
-- Module:Namespace detect/config.                                            --
--                                                                            --
--------------------------------------------------------------------------------
--]]

local data = mw.loadData('Módulo:Namespace detect/data')
local argKeys = data.argKeys
local cfg = data.cfg
local mappings = data.mappings

local yesno = require('Módulo:Yesno')
local mArguments -- Lazily initialise Module:Arguments
local mTableTools -- Lazily initilalise Module:TableTools
local ustringLower = mw.ustring.lower

local p = {}

local function fetchValue(t1, t2)
	-- Fetches a value from the table t1 for the first key in array t2 where
	-- a non-nil value of t1 exists.
	for i, key in ipairs(t2) do
		local value = t1[key]
		if value ~= nil then
			return value
		end
	end
	return nil
end

local function equalsArrayValue(t, value)
	-- Returns true if value equals a value in the array t. Otherwise
	-- returns false.
	for i, arrayValue in ipairs(t) do
		if value == arrayValue then
			return true
		end
	end
	return false
end

function p.getPageObject(page)
	-- Get the page object, passing the function through pcall in case of
	-- errors, e.g. being over the expensive function count limit.
	if page then
		local success, pageObject = pcall(mw.title.new, page)
		if success then
			return pageObject
		else
			return nil
		end
	else
		return mw.title.getCurrentTitle()
	end
end

-- Provided for backward compatibility with other modules
function p.getParamMappings()
	return mappings
end

local function getNamespace(args)
	-- This function gets the namespace name from the page object.
	local page = fetchValue(args, argKeys.demopage)
	if page == '' then
		page = nil
	end
	local demospace = fetchValue(args, argKeys.demospace)
	if demospace == '' then
		demospace = nil
	end
	local subjectns = fetchValue(args, argKeys.subjectns)
	local ret
	if demospace then
		-- Handle "demospace = main" properly.
		if equalsArrayValue(argKeys.main, ustringLower(demospace)) then
			ret = mw.site.namespaces[0].name
		else
			ret = demospace
		end
	else
		local pageObject = p.getPageObject(page)
		if pageObject then
			if pageObject.isTalkPage then
				-- Get the subject namespace if the option is set,
				-- otherwise use "talk".
				if yesno(subjectns) then
					ret = mw.site.namespaces[pageObject.namespace].subject.name
				else
					ret = 'talk'
				end
			else
				ret = pageObject.nsText
			end
		else
			return nil -- return nil if the page object doesn't exist.
		end
	end
	ret = ret:gsub('_', ' ')
	return ustringLower(ret)
end

function p._main(args)
	-- Check the parameters stored in the mappings table for any matches.
	local namespace = getNamespace(args) or 'other' -- "other" avoids nil table keys
	local params = mappings[namespace] or {}
	local ret = fetchValue(args, params)
	--[[
	-- If there were no matches, return parameters for other namespaces.
	-- This happens if there was no text specified for the namespace that
	-- was detected or if the demospace parameter is not a valid
	-- namespace. Note that the parameter for the detected namespace must be
	-- completely absent for this to happen, not merely blank.
	--]]
	if ret == nil then
		ret = fetchValue(args, argKeys.other)
	end
	return ret
end

function p.main(frame)
	mArguments = require('Módulo:Arguments')
	local args = mArguments.getArgs(frame, {removeBlanks = false})
	local ret = p._main(args)
	return ret or ''
end

function p.table(frame)
	--[[
	-- Create a wikitable of all subject namespace parameters, for
	-- documentation purposes. The talk parameter is optional, in case it
	-- needs to be excluded in the documentation.
	--]]
	
	-- Load modules and initialise variables.
	mTableTools = require('Módulo:TableTools')
	local namespaces = mw.site.namespaces
	local cfg = data.cfg
	local useTalk = type(frame) == 'table' 
		and type(frame.args) == 'table' 
		and yesno(frame.args.talk) -- Whether to use the talk parameter.
	
	-- Get the header names.
	local function checkValue(value, default)
		if type(value) == 'string' then
			return value
		else
			return default
		end
	end
	local nsHeader = checkValue(cfg.wikitableNamespaceHeader, 'Namespace')
	local aliasesHeader = checkValue(cfg.wikitableAliasesHeader, 'Aliases')

	-- Put the namespaces in order.
	local mappingsOrdered = {}
	for nsname, params in pairs(mappings) do
		if useTalk or nsname ~= 'talk' then
			local nsid = namespaces[nsname].id
			-- Add 1, as the array must start with 1; nsid 0 would be lost otherwise.
			nsid = nsid + 1 
			mappingsOrdered[nsid] = params
		end
	end
	mappingsOrdered = mTableTools.compressSparseArray(mappingsOrdered)

	-- Build the table.
	local ret = '{| class="wikitable"'
		.. '\n|-'
		.. '\n! ' .. nsHeader
		.. '\n! ' .. aliasesHeader
	for i, params in ipairs(mappingsOrdered) do
		for j, param in ipairs(params) do
			if j == 1 then
				ret = ret .. '\n|-'
					.. '\n| <code>' .. param .. '</code>'
					.. '\n| '
			elseif j == 2 then
				ret = ret .. '<code>' .. param .. '</code>'
			else
				ret = ret .. ', <code>' .. param .. '</code>'
			end
		end
	end
	ret = ret .. '\n|-'
		.. '\n|}'
	return ret
end

return p