Módulo:Argumentos/doc

Este módulo provee un procesamiento fácil a los argumentos que pasan de #invoke. Es un metamódulo, pensado para ser usado por otros módulos, y no debería ser llamado directamente desde #invoke. Entre sus características se incluyen:

• Eliminar espacios en blanco al principio y final de los valores (no implementado todavía)
• Eliminar parámetros vacíos (no implementado todavía)
• Los argumentos pueden ser pasados por el marco actual y el marco padre a la vez (no implementado todavía)
• Los argumentos pueden ser pasados por otro módulo Lua o desde la consola de depuración.
• La mayoría de las características pueden ser personalizadas.

Uso básico

Para empezar, se debe cargar el módulo. Contiene una función, llamada obtenerArgumentos.

local dameArgs = require('Módulo:Argumentos').obtenerArgumentos

En el escenario más básico, se puede usar obtenerArgumentos dentro de la función principal (usualmente main). La variable args es una tabla que contiene los argumentos de #invoke.

local dameArgs = require('Módulo:Argumentos').obtenerArgumentos
local p = {}

function p.main(marco)
	local args = dameArgs(marco)
	-- El código principal del módulo vas acá
end

return p

Sin embargo, se recomienda usar una función solo para procesar los argumentos de #invoke. Esto significa que si se llama al módulo desde otro módulo Lua, no es necesario tener un objeto marco disponible, mejorando el rendimiento.

local dameArgs = require('Módulo:Argumentos').obtenerArgumentos
local p = {}

function p.main(marco)
	local args = dameArgs(marco)
	return p._main(args)
end

function p._main(args)
	-- El código principal del módulo vas acá
end

return p

Si se quiere múltiples funciones que usen los argumentos, y que también sean accesibles desde #invoke, puede usarse una función envolvente.

local dameArgs = require('Módulo:Argumentos').obtenerArgumentos

local function hazFuncInvoke(fn)
	return function (marco)
		local args = dameArgs(marco)
		return p[fn](args)
	end
end

local p = {}

p.func1 = hazFuncInvoke('_func1')

function p._func1(args)
	-- El código de la primera función va acá
end

p.func2 = hazFuncInvoke('_func2')

function p._func2(args)
	-- El código de la segunda función va acá
end

return p

Opciones

Las siguientes opciones están disponible, y son explicadas en las secciones de abajo.

local args = dameArgs(marco, {
	limpiarEspacios = false,
	removerVacios   = false,
	fnValores       = function (clave, valor)
		-- Código para procesar un argumento
            end,
	soloMarco       = true,
	soloPadre       = true,
	padrePrimero    = true,
	envolventes     = {
		'Plantilla:Una plantilla envolvente',
		'Plantilla:Otra plantilla envolvente'
            },
	soloLectura     = true,
	noSobreescribir = true
})

Eliminar espacios y vacios

local args = dameArgs(marco, {
	limpiarEspacios = false,
	removerVacios   = false
})

Personalización del formato de los argumentos

Algunas veces se desea remover algunos argumentos en blanco pero no otros, o tal vez poner todos los argumentos posicionales en minúscula. Para hacer cosas como estas, se usa la opción fnValores. La entrada a esta opción debe ser una función que toma dos parámetros, clave and value, y devuelve un valor sencillo. Este valor es lo que se obtiene cuando acceda al campo clave en la tabla de args

Ejemplo 1: esta función preserva los espacio en blanco para el primer argumento posicional, pero los elimina de los otros argumentos, y los elimina si quedan vacíos:

local args = dameArgs(marco, {
	fnValores       = function (clave, valor)
		if 1 == clave then
			return valor
		elseif valor then
			valor = mw.text.trim(valor) -- Elimina los espacios al comienzo y final del valor
			if '' ~= valor then         -- Si el valor no quedó vacío
				return valor        -- Lo devuelve
			end
		end
		return nil                          -- En otros casos, devuelve el valor nulo (es decir, no incluir el valor)
	end
})

Ejemplo 2: esta función elimina los argumentos vacíos y convierte todos los argumentos a minúsculas, pero no elimina los espacios del comienzo y final de los parámetros posicionales.

local args = dameArgs(marco, {
	fnValores       = function (clave, valor)
		if not valor then
			return nil
		end
		value = mw.ustring.lower(valor)
		if mw.ustring.find(valor, '%S') then
			return valor
		end
		return nil
	end
})

Nota: las funciones de arriba fallarán si se les pasa una entrada que no sea de tipo string or nil. Esto puede suceder si se usa la función dametArgs en la función principal del módulo, y esa función es llamada desde otro módulo Lua. En este caso, es necesario comprobar el tipo de la entrada. Esto no es un problema cuando se usa una función específicamente para obtener los argumentos de #invoke; por ejemplo, cuando se usa una función para ese caso (usualmente p.main) y otra ser usada por otros módulos (usualmente p._main).

También, es importante destacar que la función fnValores es llamada aproximadamente cada vez que se pide un argumento de la tabla args. Por lo tanto, si se quiere mejorar el rendimiento debería verificarse no estar haciando nada ineficiente en ese código.

Marcos y marcos padre

Los argumentos de la tabla args pueden ser pasados desde el marco actual o del marco padre a la vez. Para enteder qué significa esto, es más fácil dar un ejemplo. Digamos que tenemos un módulo llamado Módulo:EjemploArgs, qu eimprime los primeros dos parámetros posicionales que se le pasen:

Envolventes

La opción envolventes se usa para indicar un número limitado de plantillas que funcionan como envolentes; es decir, cuyo único propósito es llamar al módulo. Si el módulo detecta que es llamado desde una de estas plantillas, solo comprobará los argumentos del marco padre; de lo contrario solo lo hará con el marco pasado a dameArgs. Esto le permite al módulo ser llamado tanto desde #invoke como desde una envolvente sin la pérdida de rendimiento asociada a tener que comprobar ambos marcos (el actual y el padre) por cada argumento.