Módulo:Argumentos

Documentación del módulo


Uso

Para lógica interna de módulos y plantillas. Ver documentación completa en wikipedia.
Esta documentación está transcluida desde Módulo:Argumentos/doc.
Los editores pueden experimentar en la zona de pruebas de este módulo.
Por favor, añade las categorías e interwikis a la subpágina de documentación. Subpáginas de este módulo.

local z = {}

function z.obtenerArgumentos(frame)
	if frame.args[1] then 
		return frame.args
	end

	return frame:getParent().args
end

function z.obtenerArgumentosConValor(frame)
	if frame == mw.getCurrentFrame() then
		argumentos = frame:getParent().args
	else
		argumentos = frame.args or frame
	end

	return require('Módulo:Tablas').copiarElementosConValor(argumentos)
end

-- Obtiene los argumentos con valores de la plantilla en minúsculas y con las
-- tildes removidas, en caso de que las tenga de forma que sea más sencillo
-- trabajar con las distintas variantes en los módulos.
-- 
-- Nota: En caso de que haya parámetros duplicados tras la normalización solo
-- se mantendrá el último valor procesado por la función.
--
-- Parámetros de entrada:
--    frame: El marco utilizado por el módulo
--
-- Parámetros de salida:
--    argumentosNormalizados: los argumentos con valor y nombre normalizado
--    argumentosDuplicados: si la plantilla tiene varias veces el mismo 
--        argumento tras la normalización o no
function z.obtenerArgumentosConValorNormalizados(frame)
	local argumentos = z.obtenerArgumentosConValor(frame)
	local argumentosNormalizados = {}
	local nombreNormalizado
	local argumentosDuplicados = false
	
	for nombre, valor in pairs(argumentos) do
		
		nombreNormalizado = nombre
		
		nombreNormalizado = mw.ustring.lower( nombreNormalizado )
		nombreNormalizado = string.gsub(nombreNormalizado, "[á]", "a")
		nombreNormalizado = string.gsub(nombreNormalizado, "[é]", "e")
		nombreNormalizado = string.gsub(nombreNormalizado, "[í]", "i")
		nombreNormalizado = string.gsub(nombreNormalizado, "[ó]", "o")
		nombreNormalizado = string.gsub(nombreNormalizado, "[úü]", "u")
		
		if argumentosNormalizados[nombreNormalizado] then
			argumentosDuplicados = true
		end
		argumentosNormalizados[nombreNormalizado] = valor
	end
	
	return argumentosNormalizados, argumentosDuplicados
end

--[[
	@name	obtenerTablaDeArgumentos
	@global	args
	@param	frame
	@return	table
	@descr	Obtiene una tabla de argumentos tomando los parámetros recibidos
			tando desde la plantilla como desde la invocación de un módulo.
			En caso de duplicado tiene preferencia el valor de la invocación.
			Por ejemplo:
				con la plantilla:	{{Plantilla |campo=valor |key=clave }}
				y la invocación:	{{#invoke:Módulo |key=value }}
				se obtiene:			{ ['campo'] = 'valor', ['key'] = 'value' }
--]]
function z.obtenerTablaDeArgumentos(frame)
	-- global args
	args = {}
	local function paramMerge(orig, copy)
		local data = {}
		for key, val in pairs(orig) do
			data[key] = val
		end
		for key, val in pairs(copy) do
			data[key] = val
		end
		return data
	end
	if frame then
		-- parentArgs = frame:getParent().args or {}
		if type(frame.getParent) == 'function' then
			local parent = frame:getParent()
			if parent then
				args = paramMerge(args, parent.args)
			end
		end
		-- invokeArgs = frame.args or frame or {}
		if type(frame.args) == 'table' then
			args = paramMerge(args, frame.args)
		elseif type(frame) == 'table' then
			args = paramMerge(args, frame)
		end
	end
	return args
end

--[[
	@name	obtenerValorDeArgumentos
	@global	args
	@param	list
	@return	string or nil
	@descr	Obtiene el primer argumento válido desde una tabla de parámetros.
			Esta tabla de parámetros es una lista que contiene los nombres
			de los argumentos u otras tablas con las funciones para obtenerlos.
	Parámetros:
		con los argumentos:		{ ['campo'] = 'valor', ['key'] = 'value' }
		y usando la llamada:	obtenerValorDeArgumentos{'dato', 'campo', 'key'}
		se obtiene el valor:	'valor'
		pues 'dato' no es un argumento y 'campo' es el primero encontrado
	Funciones:
		también se puede llamar con una función de la forma
			obtenerValorDeArgumentos{'dato', { obtenerDato, '1', '2' }}
		de forma que si el argumento 'dato' no existe se llama a la función
			obtenerDato('1', '2')
--]]
function z.obtenerValorDeArgumentos(list)
	-- global args
	local lang = mw.language.getContentLanguage()
	local err, key
	if type(list) == 'number' then
		key = args[list]
	elseif type(list) == 'string' then
		key = args[list] or args[lang:ucfirst(list)]
	elseif type(list) == 'table' then
		for num, val in ipairs(list) do
			if type(val) == 'string' or type(val) == 'number' then
				key = z.obtenerValorDeArgumentos(val)
			elseif type(val) == 'function' then
				err, key = pcall(val)
				if err ~= true then
					key = nil
				end
			elseif type(val) == 'table' then
				if val[1] and type(val[1]) == 'function' then
					err, key = pcall(val[1], unpack(val, 2))
					if err ~= true then
						key = nil
					end
				end
			end
			if key ~= nil and key ~= '' then
				return key -- break
			end
		end
	end
	return key
end

return z