Este módulo implementa la plantilla {{ category handler }} . La plantilla category handler ayuda a otras plantillas a automatizar tanto la categorización como la supresión de categorías . Para obtener información sobre el uso de la plantilla category handler en otras plantillas, consulte la documentación de la plantilla . Siga leyendo para obtener información sobre el uso del módulo category handler en otros módulos de Lua o para obtener información sobre cómo exportar este módulo a otras wikis.
En los casos en los que un módulo solo necesita categorizarse en uno de los espacios de nombres principal (artículos), archivo (imágenes) o categoría, entonces usar este módulo es excesivo. En su lugar, puede simplemente obtener un objeto de título usando mw.title.getCurrentTitle y verificar el nsTextcampo. Por ejemplo:
.svg/1280px-Test_Template_Info-Icon_-_Version_(2).svg.png){kind=icon}
título local = mw . título . getCurrentTitle () si título . nsText == 'Archivo' entonces -- hacer algo finSin embargo, si su módulo necesita categorizarse en cualquier otro espacio de nombres, le recomendamos que utilice este módulo, ya que proporciona una supresión de categoría adecuada y facilita la selección de cómo categorizar en los diferentes espacios de nombres.
Este módulo detecta y agrupa todos los diferentes espacios de nombres utilizados en Wikipedia en varios tipos. Estos tipos se utilizan como nombres de parámetros en este módulo.
(excluyendo talky other)
Este módulo acepta dos o más parámetros. A continuación, se muestra un ejemplo en el que se utiliza un programa de Hola mundo:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = '¡Hola mundo!' local category = categoryHandler { '[[Category:Somecat]]' , nocat = frame . args . nocat -- Entonces "nocat=true/false" funciona } category = category o '' -- Verificamos que no tengamos un valor nulo para la variable category . return result .. category endvolver pEl ejemplo anterior utiliza la configuración predeterminada para el módulo de control de categorías. Esto significa que el módulo de ejemplo categorizará las páginas en los siguientes espacios de nombres:
Pero no se categorizará en ningún otro espacio de nombres, por ejemplo:
Y no se categorizará en páginas incluidas en la lista negra. (Ver la sección de lista negra a continuación).
El motivo por el que el módulo de control de categorías no categoriza en algunos de los espacios de nombres es que en esos espacios la mayoría de los módulos y plantillas solo se muestran o enumeran, no se utilizan. Por lo tanto, la mayoría de los módulos y plantillas no deberían categorizarse en esos espacios de nombres.
Cualquier módulo o plantilla destinado a uno o más de los espacios de nombres donde este módulo categoriza puede utilizar la sintaxis básica como se muestra arriba.
Este módulo toma uno o más parámetros que llevan el nombre de los diferentes tipos de páginas que se enumeran en la sección de espacios de nombres anterior. Al usar esos parámetros, puede especificar exactamente en qué espacios de nombres debe categorizarse su plantilla. De esta manera:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = 'Este es un módulo pensado para artículos y páginas de discusión.' local category = categoryHandler { main = '[[Category:Somecat1]]' , -- Categorizar en el espacio main (article) talk = '[[Category:Somecat2]]' , -- Categorizar en el espacio de discusión nocat = frame . args . nocat -- Entonces "nocat=true/false" funciona } category = category o '' -- Verificamos que no tenemos un valor nulo para la variable category. return result .. category endvolver pEl módulo anterior solo categorizará en el espacio principal y de discusión. Pero no categorizará en las páginas /archive ya que están en la lista negra. (Ver la sección lista negra a continuación). Y si necesita demostrar (discutir) el módulo en una página de discusión, puede introducir " nocat='true'" para evitar que esa plantilla categorice. (Ver la sección nocat a continuación). De esta manera:
== Mi nuevo módulo ==Hola chicos, ¿habéis visto mi nuevo módulo?{{#invoke:mymodule|principal|nocat=true}}Bonito, ¿no?--~~~~A veces queremos usar la misma categoría en varios espacios de nombres, entonces hacemos lo siguiente:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = 'Este es un módulo usado en varios espacios de nombres.' local category = categoryHandler { main = '[[Category:Somecat1]]' , [ 1 ] = '[[Category:Somecat2]]' , -- Para ayuda y espacio de usuario help = 1 , user = 1 , talk = '' , -- No hay categorías en las páginas de discusión other = '[[Category:Somecat3]]' , -- Para todos los demás espacios de nombres nocat = frame . args . nocat -- Entonces "nocat=true/false" funciona } category = category or '' -- Verificamos que no tenemos un valor nulo para la variable category. return result .. category endvolver pEn el ejemplo anterior, usamos un parámetro numerado para alimentar una de las categorías y luego le indicamos a este módulo que use ese parámetro numerado tanto para la ayuda como para el espacio de usuario.
El módulo controlador de categorías entiende una cantidad ilimitada de parámetros numerados.
El otro parámetro define lo que se debe utilizar en los espacios de nombres restantes a los que no se les han suministrado datos explícitamente.
Tenga en cuenta que el parámetro de conversación está vacío pero definido . Esto impide que este módulo muestre lo que se ha ingresado en el otro parámetro cuando se está en el espacio de conversación.
El módulo de control de categorías también tiene un parámetro llamado all . Funciona de la siguiente manera:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = 'Este es un módulo usado en todos los espacios de nombres.' local category = categoryHandler { all = '[[Category:Somecat1]]' , -- Categorizar en todos los espacios de nombres nocat = frame . args . nocat -- Para que "nocat=true/false" funcione } category = category o '' -- Verificar que no tenemos un valor nulo para la variable category. return result .. category endvolver pEl ejemplo anterior categorizará en todos los espacios de nombres, pero no en las páginas incluidas en la lista negra. Si desea demostrar ese módulo en una página, utilice " nocat=true" para evitar que la plantilla realice la categorización.
Sugerimos evitar el parámetro all , ya que los módulos y las plantillas deberían categorizarse preferiblemente solo en los espacios de nombres que necesitan.
El parámetro all también se puede combinar con el resto de parámetros, de la siguiente manera:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = 'Este es un módulo usado en todos los espacios de nombres.' local category = categoryHandler { all = '[[Category:Somecat1]]' , -- Categorizar en todos los espacios de nombres main = '[[Category:Somecat2]]' , -- Y agregar esto en el espacio principal other = '[[Category:Somecat3]]' , -- Y agregar esto en todos los demás espacios de nombres nocat = frame . args . nocat -- Entonces "nocat=true/false" funciona } category = category o '' -- Verificar que no tenemos un valor nulo para la variable category. return result .. category endvolver pSi el módulo anterior se coloca en un artículo, se agregarán las categorías "Somecat1" y "Somecat2". Pero en todos los demás tipos de páginas, se agregarán "Somecat1" y "Somecat3". Como muestra el ejemplo, el parámetro all funciona independientemente del resto de los parámetros.
El módulo de control de categorías comprende el parámetro de subpágina . De esta manera:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = 'Este es un módulo usado en todos los espacios de nombres.' local category = categoryHandler { subpage = 'no' -- No categorizar en subpáginas wikipedia = '[[Category:Somecat]]' , nocat = frame . args . nocat -- Entonces "nocat=true/false" funciona } category = category o '' -- Verificar que no tenemos un valor nulo para la variable category. return result .. category endvolver pSi se selecciona " subpage='no'", esta plantilla no categorizará en subpáginas. En las raras ocasiones en las que solo desee categorizar en subpáginas, utilice " subpage='only'". Si la subpágina está vacía o no está definida, esta plantilla categoriza tanto en páginas base como en subpáginas.
Este módulo tiene una lista negra de páginas y tipos de páginas en los que las plantillas no deberían categorizar automáticamente. Por lo tanto, los módulos que usan esta metaplantilla no categorizarán, por ejemplo, las páginas /archive y las subpáginas de Wikipedia:Mensajes de plantilla .
Si desea que una plantilla se clasifique en una página incluida en la lista negra, introduzca " nocat = false" en el módulo cuando lo coloque en la página, omitiendo así la comprobación de la lista negra. Tenga en cuenta que este módulo solo categoriza si tiene datos para el espacio de nombres. Por ejemplo, si se utiliza la sintaxis básica (consulte el uso básico más arriba), incluso si establece " nocat = false", la plantilla no se categorizará en una página de discusión, ya que no tiene datos para páginas de discusión. Pero tiene datos para el espacio de ayuda, por lo que se categorizará en una página de ayuda incluida en la lista negra.
La lista negra se encuentra en la tabla de configuración cfg.blacklistcerca de la parte superior del código del módulo.
Este módulo entiende el parámetro nocat :
nocat = true" entonces esta plantilla no categoriza.nil , esta plantilla se categoriza como de costumbre.nocat = false", esta plantilla categoriza incluso cuando se encuentra en páginas incluidas en la lista negra. (Consulte la sección de lista negra más arriba).truey falsesegún lo definido por Módulo:Yesno , por ejemplo, "sí", "y", "verdadero" y 1 para true, y "no", "n", "falso" y 0 para false.Los módulos y plantillas que usan {{category handler}} deben reenviar nocat para que ellos también comprendan nocat . El código " nocat = frame.args.nocat" que se muestra en los ejemplos de esta página hace eso.
Para compatibilidad con versiones anteriores, este módulo también comprende el parámetro categorías . Funciona igual que nocat . De esta manera:
categories = false" entonces esta plantilla no categoriza.categories = true" esta plantilla clasifica incluso cuando está en páginas incluidas en la lista negra.truey falsesegún lo definido por Módulo:Yesno , por ejemplo, "sí", "y", "verdadero" y 1 para true, y "no", "n", "falso" y 0 para false.Para compatibilidad con versiones anteriores, esta plantilla admite el antiguo parámetro "category =". Pero el nombre del parámetro "category" ya se usa en este módulo para introducir datos de categorías cuando se está en el espacio de categorías. Por lo tanto, esta plantilla usa category2 para un uso similar a nocat . De esta manera:
category2 = "" (vacío pero definido), o " category2 = 'no'", o si se introducen otros datos en category2 (excepto como se describe en los dos puntos siguientes), esta plantilla no realiza la categorización.category2 = '¬'", entonces esta plantilla categoriza como de costumbre.category2 = 'yes'" esta plantilla clasifica incluso cuando está en páginas incluidas en la lista negra.Además de las categorías, puedes introducir cualquier otra cosa en este módulo, por ejemplo, texto. Así:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal function p . main ( frame ) local result = 'Este es un módulo usado en páginas de discusión.' local category = categoryHandler { talk = '[[Category:Somecat]]' , other = '<p class="error">Este módulo solo debe usarse en páginas de discusión.</p>' , nocat = frame . args . nocat -- Entonces "nocat=true/false" funciona } category = category o '' -- Verificamos que no tenemos un valor nulo para la variable category. return result .. category endvolver pCuando el código del módulo anterior se utiliza en cualquier cosa que no sea una página de discusión, se verá así:
Este módulo sólo debe utilizarse en páginas de discusión.
Ese texto no se mostrará en las páginas incluidas en la lista negra, por lo que no utilice este método para mostrar información importante. Si agrega " nocat = 'true'" a la plantilla, ocultará el texto y suprimirá las categorías.
Para fines de prueba y demostración, este módulo puede tomar un parámetro llamado página . De esta manera:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal función p . main ( frame ) categoría local = categoryHandler { main = 'Categoría:Algún gato' , talk = 'Categoría:Talk gato' , nocat = frame . args . nocat , -- Entonces "nocat=true/false" funciona page = 'Usuario talk:Ejemplo' } return category end volver pEn el código anterior, omitimos a propósito los corchetes que rodean los nombres de las categorías para que podamos ver el resultado en la página. Independientemente del tipo de página en la que se utilice el código anterior, devolverá lo siguiente:
El parámetro de página hace que este módulo se comporte exactamente como si estuviera en esa página. Incluso la lista negra funciona. El nombre de la página no tiene que ser una página existente.
Si el parámetro de página está vacío o no está definido, el nombre de la página actual determina el resultado.
Puedes hacer que tu módulo también comprenda el parámetro de página . Esto significa que puedes probar cómo se categorizará tu plantilla en diferentes páginas, sin tener que editarlas. Haz lo siguiente:
p = {} categoryHandler local = require ( 'Módulo:Manejador de categorías' ). principal función p . main ( frame ) categoría local = categoryHandler { main = 'Categoría:Algún gato' , talk = 'Categoría:Talk gato' , nocat = frame . args . nocat , -- Entonces "nocat=true/false" funciona page = frame . args . page -- Para probar } return category end volver pLista de todos los parámetros:
Tenga en cuenta que los valores vacíos de los parámetros "principal" ... "otros" tienen un significado especial (consulte los ejemplos anteriores). El parámetro "todos" no entiende los parámetros numerados, ya que nunca debería ser necesario.
Este módulo se puede exportar a otras wikis modificando los valores de configuración en la cfgtabla. Todos los valores de las variables son configurables, por lo que una vez que se hayan establecido los valores de configuración no debería ser necesario modificar el código principal del módulo. Los detalles de cada valor de configuración se incluyen en los comentarios del código del módulo. Además, este módulo requiere que Module:Namespace detect esté disponible en la wiki local.
-------------------------------------------------------------------------------- -- -- -- MANEJADOR DE CATEGORÍAS -- -- -- -- Este módulo implementa la plantilla {{category handler}} en Lua, -- -- con algunas mejoras: se admiten todos los espacios de nombres y todos los alias de espacios de nombres -- -- y los nombres de espacios de nombres se detectan automáticamente para -- -- el wiki local. Este módulo requiere que [[Module:Namespace detect]] -- -- y [[Module:Yesno]] estén disponibles en el wiki local. Se puede -- -- configurar para diferentes wikis modificando los valores en -- -- [[Module:Category handler/config]], y las páginas se pueden incluir en la lista negra de la categorización usando [[Module:Category handler/blacklist]]. -- -- -- -------------------------------------------------------------------------------- -- Cargar módulos requeridos local yesno = require ( 'Module:Yesno' ) -- Cargar de forma diferida cosas que no siempre necesitamos local mShared , mappings local p = {} -------------------------------------------------------------------------------- -- Funciones auxiliares -------------------------------------------------------------------------------- función local 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 -------------------------------------------------------------------------------- -- Clase CategoryHandler -------------------------------------------------------------------------------- local CategoryHandler = {} CategoryHandler .__ index = CategoryHandler función CategoryHandler . new ( data , args ) local obj = setmetatable ({ _data = data , _args = args }, CategoryHandler ) -- Establece el objeto de título do local pagename = obj : parameter ( 'demopage' ) local success , titleObj si pagename entonces success , titleObj = pcall ( mw . title . new , pagename ) fin si success y titleObj entonces obj . title = titleObj si titleObj == mw . title . getCurrentTitle () entonces obj . _usesCurrentTitle = true fin de lo contrario obj . title = mw . title . getCurrentTitle () obj . _usesCurrentTitle = true end end -- Establecer valores de parámetros de supresión para _ , clave en 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 ( subpágina ) fin si tipo ( categoría2 ) == 'cadena' entonces subpágina = mw . ustring . lower ( categoría2 ) fin obj . _subpágina = trimWhitespace ( subpágina , verdadero ) obj . _categoría2 = trimWhitespace ( categoría2 ) -- no eliminar valores en blanco fin devolver obj fin función CategoryHandler : parámetro ( clave ) local parameterNames = self . _data . parámetros [ clave ] local pntype = tipo ( parameterNames ) si pntype == 'cadena' o pntype == 'número' entonces devolver self . _args [ parameterNames ] de lo contrario si pntype == 'tabla' entonces para _ , nombre en ipairs ( parameterNames ) hacer valor local = self . _args [ nombre ] si valor ~= nulo entonces devuelve valor fin fin devuelve nulo de lo contrario error ( string.format ( 'clave de configuración no válida "%s"' , tostring ( clave ) ), 2 ) fin fin función CategoryHandler : isSuppressedByArguments () devuelve - Verifica si se ha establecido un argumento de supresión de categoría. self . _nocat == true o self . _categories == false o ( self . _category2 y self . _category2 ~= self . _data . category2Yes y self . _category2 ~= self . _data . category2Negative ) - Verifica si estamos en una subpágina y ve si las categorías están suprimidas en función de nuestro estado de subpágina. o self . _subpage == self . _data . subpageNo y self . title . isSubpage o self . _subpage == self . _data . subpageOnly y no self . title . isSubpage fin de la función CategoryHandler : shouldSkipBlacklistCheck () - Verifica si los argumentos de supresión de categoría indican que debemos omitir la verificación de la lista negra. return self . _nocat == false o self . _categories == true o self . _category2 == self . _data . category2Yes fin de la función CategoryHandler : matchesBlacklist () si self . _usesCurrentTitle entonces devuelve self . _data . currentTitleMatchesBlacklist else mShared = mShared o require ( 'Module:Category handler/shared' ) return mShared . matchesBlacklist ( self . title . prefixedText , mw . loadData ( 'Module:Category handler/blacklist' ) ) end end function CategoryHandler : isSuppressed () -- Encuentra si las categorías están suprimidas por los argumentos o por -- que coinciden con la lista negra. return self : isSuppressedByArguments () o not self : shouldSkipBlacklistCheck () y self : matchesBlacklist () fin de la función CategoryHandler : getNamespaceParameters () si self._usesCurrentTitle entonces devuelve self._data.currentTitleNamespaceParameters de lo contrario si no mappings entonces mShared = mShared o require ( 'Module:Category handler / shared' ) mappings = mShared.getParamMappings ( true ) -- obtiene los mappings con mw.loadData fin devuelve mShared.getNamespaceParameters ( self.title , mappings ) fin fin de la función CategoryHandler : namespaceParametersExist ( ) -- Encuentra si se ha especificado algún parámetro de espacio de nombres. -- Usamos el orden "all" --> namespace params --> " other " ya que esto es lo que -- hacía la plantilla anterior. si self : parámetro ( 'all' ) entonces devuelve verdadero fin si no mappings entonces mShared = mShared o require ( 'Module:Category handler/shared' ) mappings = mShared . getParamMappings ( true ) -- obtiene mappings con mw. loadData fin para ns , parámetros en pairs ( mappings ) hacer para i , parámetro en ipairs ( parámetros ) hacer si self . _args [ parámetro ] entonces devuelve verdadero fin fin fin si self : parámetro ( 'other' ) entonces devuelve verdadero fin devuelve falso fin función CategoryHandler : getCategories () local params = self : getNamespaceParameters ( ) local nsCategory para i , parámetro en ipairs ( parámetros ) hacer local valor = self._args [ parámetro ] si valor ~= nulo entonces nsCategory = valor break end end si nsCategory ~= nulo o self : namespaceParametersExist ( ) then : los parámetros del espacio de nombres existen - uso avanzado . si nsCategory == nulo entonces nsCategory = self : parámetro ( ' otro' ) end local ret = { self : parámetro ( 'todos' )} local numParam = tonumber ( nsCategory ) si numParam y numParam >= 1 y math.floor ( numParam ) == numParam entonces : nsCategory es un entero 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 -- Los parámetros de espacio de nombres no existen, uso simple. return self . _args [ 1 ] end return nil end -------------------------------------------------------------------------------- -- Exportaciones -------------------------------------------------------------------------------- local p = {} función p . _exportClasses () - Se utiliza para fines de prueba. return { CategoryHandler = CategoryHandler } fin de la función p . _main ( args , data ) data = data o mw . loadData ( 'Módulo:Categoría manejador/datos' ) manejador local = CategoryHandler . new ( data , args ) si manejador : isSuppressed () entonces devuelve nil fin de retorno manejador : getCategories () fin de la función p . main ( frame , data ) data = data o mw . loadData ( 'Módulo:Categoría manejador/datos' ) args local = require ( 'Módulo:Argumentos' ). getArgs ( frame , { wrappers = data.wrappers , valueFunc = function ( k , v ) v = trimWhitespace ( v ) si tipo ( k ) == ' número' entonces si v ~ = ' ' entonces devuelve v de lo contrario devuelve nil fin de lo contrario devuelve v fin fin }) devuelve p._main ( args , data ) fin devuelve p