Este módulo se debe utilizar en plantillas envolventes para permitir que dichas plantillas proporcionen valores de parámetros predeterminados y permitan a los editores pasar parámetros adicionales a la plantilla de trabajo subyacente.
Al escribir una plantilla contenedora, proporcione a este módulo todos los parámetros predeterminados normalmente requeridos necesarios para utilizar la plantilla contenedora en su forma básica. Los editores luego utilizan la plantilla contenedora tal como está o pueden proporcionar parámetros contenedor y canónicos adicionales. Cualquiera de los parámetros canónicos admitidos por la plantilla de trabajo se puede agregar a la plantilla contenedora o los editores pueden proporcionarlos en el espacio del artículo. Cuando un editor proporciona un parámetro que tiene un valor predeterminado en la plantilla contenedora, el valor proporcionado por el editor anula el valor predeterminado. Cuando es necesario eliminar un parámetro predeterminado, los editores pueden establecer el valor del parámetro en la palabra clave especial unsetque hará que este módulo contenedor borre el valor predeterminado de la plantilla contenedora para ese parámetro. Este módulo descarta los parámetros con nombre vacíos.
Los parámetros posicionales normalmente no se pasan a la plantilla de trabajo. La configuración |_include-positional=yespasará todos los parámetros posicionales a la plantilla de trabajo. Los parámetros posicionales no se pueden excluir; los parámetros posicionales se pueden unset.
Los parámetros que utiliza únicamente el contenedor deben ser posicionales ( ) o estar enumerados en (una lista de parámetros con nombre separados por comas). Este módulo no pasará parámetros a la plantilla de trabajo.{{{n}}}|_exclude=_excluded
{{#invoke:Template wrapper|wrap|_template=working template|_exclude=named parameter, named parameter, ...|_reuse=named parameter, named parameter, ...|_alias-map=alias parameter:canonical parameter|_include-positional=yes|<default parameter>|<default parameter>|...}}
.svg/1280px-Test_Template_Info-Icon_-_Version_(2).svg.png){kind=icon}
|_template=– (obligatorio) el nombre, sin espacio de nombres, de la plantilla de trabajo (la plantilla que está envuelta); consulte §_template a continuación|_exclude=– lista separada por comas de nombres de parámetros utilizados por la plantilla contenedora que no se deben pasar a la plantilla de trabajo; consulte §_exclude a continuación|_reuse=– lista separada por comas de nombres canónicos que tienen significado tanto para la plantilla contenedora como para la plantilla de trabajo; consulte §_reuse a continuación|_alias-map=– lista separada por comas de nombres de parámetros de plantilla de contenedor que se deben tratar como alias de parámetros canónicos de plantilla de trabajo especificados; consulte §_alias-map a continuación|_include-positional=– pasar todos los parámetros posicionales a la plantilla de trabajo; ver §_include-positional a continuaciónEl único parámetro obligatorio |_template=proporciona el nombre, sin espacio de nombres, de la plantilla de trabajo (la plantilla que se encapsula). Si se omite este parámetro, el contenedor Module:Template emitirá el mensaje de error:
|_template=Falta o vacio|_alias-map=Toma una lista separada por comas de parámetros de plantilla de contenedor que se deben tratar como alias de parámetros canónicos de plantilla de trabajo especificados. Cada elemento de mapeo de la lista tiene el formato:
<from>:<to>– donde: es un nombre de parámetro contenedor y es un nombre de parámetro canónico<from><to>En este ejemplo, puede ser preferible utilizar una plantilla contenedora |assessor=que puede ser desconocida para la plantilla de trabajo, pero la plantilla de trabajo puede tener un equivalente, |author=por lo que {{#invoke:}}escribiríamos:
|_alias-map=assessor:authorLos parámetros posicionales también pueden asignarse a parámetros canónicos:
|_alias-map=1:author, 2:title, 3:languageLos parámetros de envoltura enumerados se pueden asignar a parámetros canónicos enumerados utilizando el #especificador de enumerador:
|_alias-map=assessor#:author#Dado el ejemplo anterior, |assessor2=se asignará a |author2=; también, |assessor=y |assessor1=se asignará a|author1=
Varios parámetros de envoltura se pueden asignar a un único parámetro canónico:
|_alias-map=1:author, assessor:authorLos parámetros de contenedor que se enumeran en |alias-map=no se pasan a la plantilla de trabajo. La asignación de parámetros posicionales cuando |_include-positional=yespuede dar resultados no deseados. |_alias-map=1:authory |_include-positional=yeshará que todos los demás parámetros posicionales se pasen a la plantilla de trabajo tal como está: la plantilla de contenedor {{{2}}}se convierte en plantilla de trabajo {{{2}}}, etc.; la plantilla de trabajo no obtendrá {{{1}}}aunque obtendrá |author=.
|_reuse=toma una lista separada por comas de parámetros canónicos que tienen significado tanto para la plantilla contenedora como para la plantilla de trabajo
En los casos más simples, un parámetro canónico que se pasa a la plantilla contenedora anula un parámetro predeterminado que se proporciona en la plantilla contenedora. A veces, un parámetro contenedor es el mismo que un parámetro canónico y la plantilla contenedora necesita modificar el valor del parámetro antes de pasarlo a la plantilla de trabajo. En este ejemplo, |title=es tanto un parámetro contenedor como un parámetro canónico que la plantilla contenedora necesita modificar antes de pasarlo a la plantilla de trabajo. Para ello, primero escribimos:
|_reuse=titleLuego, en la plantilla del contenedor {{#invoke:Template wrapper|wrap|_template=...|...}}escribimos:
|title=Modified {{{title}}}Los parámetros _reutilizados no se pueden anular.
|_exclude=toma una lista separada por comas de parámetros utilizados por la plantilla contenedora que no se deben pasar a la plantilla de trabajo. Esta lista se aplica a todos los parámetros contenedor y canónicos (incluidos aquellos parámetros canónicos que se renombran como parámetros de alias) recibidos de la plantilla contenedora.
A modo de ejemplo, una plantilla contenedora podría utilizarse |id=para proporcionar una parte del valor asignado al parámetro predeterminado, |url=por lo que escribiríamos:
|_exclude=idLuego, en la plantilla del contenedor {{#invoke:Template wrapper|wrap|_template=...|...}}escribimos:
|url=https://example.com/{{{id}}}El |url=valor modificado se pasa a la plantilla de trabajo pero |id=su valor no.
Los parámetros _reused y predeterminados no se pueden excluir.
|_include-positional=es un parámetro booleano que solo acepta un valor: yes; el valor predeterminado (vacío, faltante) es no(normalmente se excluyen los parámetros posicionales). Cuando se establece en yes, el contenedor Module:Template pasará todos los parámetros posicionales a la plantilla de trabajo.
Véase también §_alias-map.
Los editores pueden anular los parámetros predeterminados simplemente configurando el parámetro predeterminado con el valor deseado en la plantilla contenedora. Este módulo ignora los parámetros vacíos (aquellos parámetros que tienen nombre pero que no tienen un valor asignado). Cuando se desea anular un parámetro predeterminado y dejarlo sin valor, se utiliza la palabra clave especial unset. Los parámetros predeterminados con este valor se pasan a la plantilla de trabajo como parámetros vacíos (sin valor asignado).
Los parámetros _reutilizados no se pueden unsetanular.
Este módulo tiene dos puntos de entrada. Una plantilla contenedora podría utilizar un módulo {{#invoke:}}escrito de la siguiente manera:
{{#invoke:Template wrapper|{{#if:{{{_debug|}}}|list|wrap}}|_template=<working template>|_exclude=_debug, ...|...}}donde el |_debug=parámetro contenedor, establecido en cualquier valor, hará que el módulo represente la llamada a la plantilla de trabajo sin llamar realmente a la plantilla de trabajo.
A modo de ejemplo, se trata de una plantilla contenedora que utiliza como plantilla de trabajo . acepta parámetros posicionales pero no los convierte en parámetros nombrados, lo que hace utilizando el parámetro:{{cite wikisource}}{{citation}}{{cite wikisource}}{{citation}}|_alias-map=
{{ #invoke : envoltura de plantilla |{{ #if :{{{ _debug |}}}| lista | envoltura }}| _template = cita | _exclude = ..., _debug <!-- se omitieron detalles innecesarios --> | _alias-map = 1:título, 2:autor, 3:idiomaEste ejemplo utiliza parámetros posicionales y conjuntos |_debug=yespara mostrar que la {{citation}}plantilla está formada correctamente:
{{cite wikisource|Sentido y sensibilidad|Jane Austen|es|_debug=yes}}{{citation|author=Jane Austen|language=es|mode=cs1|title=[[s:es:Sentido y sensibilidad|Sentido y sensibilidad]]|via=[[Wikisource]]}} y, con |_debug=unset:
{{cite wikisource|Sentido y sensibilidad|Jane Austen|es|_debug=}}El |_debug=nombre se elige aquí por conveniencia, pero puede ser cualquier cosa siempre que coincida con el {{#if:}}del {{#invoke:}}.
También puedes llamar a la linkfunción para obtener algo como el lado izquierdo de Template:yy . Básicamente, esta es la listfunción con el nombre de la plantilla convertido en un enlace.
require ( 'strict' ); error_msg local = '<span style= \" font-size:100% \" class= \" error \" ><code style= \" color:inherit; border:inherit; padding:inherit; \" >|_template=</code> falta o está vacío</span>' ; --[[--------------------------< IS _ IN _ TABLE >-------------------------------------------------------- escanea la tabla en busca de un valor; devuelve verdadero si lo encuentra, falso en caso contrario ]] función local is_in_table ( tbl , value ) para k , v en pares ( tbl ) hace si v == value entonces devuelve verdadero fin fin devuelve falso ; fin --[[--------------------------< ADD _ PARAMETER >-------------------------------------------------------- agrega el nombre del parámetro y su valor a la tabla args según el estado del argumento de lista booleana; par kv para ejecución de plantilla; cadena k=v para listado de plantilla. ]] función local add_parameter ( k , v , args , list ) si lista entonces tabla.insert ( args , tabla.concat ({ k , '=' , v })); -- escribe los nombres de los parámetros y los valores en la tabla args como cadena de caracteres de lo contrario args [ k ] = v ; -- copia los parámetros en la tabla args fin fin --[[---------------------------< ALIAS _ MAP _ GET >---------------------------------------------------- devuelve una tabla de nombres de parámetros de plantilla local (marco principal) y los nombres de plantilla de destino que coinciden con donde en pares [clave]=<valor> donde: [clave] es el nombre del parámetro de plantilla local (un alias) <valor> es el nombre del parámetro de plantilla de destino (el nombre del parámetro canónico usado en la plantilla de trabajo) El parámetro |_alias-map= tiene el formato: |_alias-map=<lista> donde <lista> es una lista separada por comas de pares de alias/nombre de parámetro canónico en el formato <desde> : <hasta> donde:<from> es el nombre del parámetro de la plantilla local (alias) <to> es el nombre del parámetro de la plantilla de destino (canónico) para los parámetros enumerados, coloque un octothorp (#) donde se colocan los dígitos del enumerador en los nombres de los parámetros: <from#> : <to#> ]] función local alias_map_get ( _alias_map ) local T = mw . text . split ( _alias_map , '%s*,%s*' ); -- convierte la lista separada por comas en una tabla de pares de alias local mapped_aliases = {}; -- los alias mapeados irán aquí local l_name , t_name ; -- nombres de parámetros para _ , alias_pair en ipairs ( T ) hacer -- recorrer la tabla de pares de alias l_name , t_name = alias_pair : match ( '(.-)%s*:%s*(.+)' ); -- de cada par, obtiene los nombres de los parámetros locales y de destino si l_name y t_name entonces -- si ambos están configurados si tonumber ( l_name ) entonces l_name = tonumber ( l_name ); -- convierte número como texto en un número end mapped_aliases [ l_name ] = t_name ; -- los agrega a la tabla de mapas end end return mapped_aliases ; end --[[--------------------------< FRAME _ ARGS _ GET >-------------------------------------------------- Obtiene los parámetros 'predeterminados' y de control de la plantilla contenedora; agrega parámetros predeterminados a args devuelve el contenido de |_template= parámetro (nombre de la plantilla de trabajo); nil else ]] función local frame_args_get ( frame_args , args , list ) plantilla local ; para k , v en pares ( frame_args ) hacer -- aquí obtenemos los parámetros 'predeterminados' de la plantilla contenedora si 'string' == type ( k ) y ( v y ( '' ~= v )) entonces -- no pasar parámetros posicionales o vacíos si '_template' == k entonces plantilla = v ; -- guardar el nombre de la plantilla que estamos envolviendo elseif '_exclude' ~= k y '_reuse' ~= k y '_include-positional' ~= k y '_alias-map' ~= k entonces -- estos ya se manejaron así que ignórelos aquí; add_parameter ( k , v , args , list ); -- agregar todos los demás parámetros a args en el estilo dictado por la lista end end end return template ; -- devolver el contenido de |_template= parámetro end --[=[--------------------------< PFRAME _ ARGS _ GET >------------------------------------------------ Obtiene los parámetros 'en vivo' de la plantilla contenedora; agrega parámetros en vivo que no son miembros de la tabla de exclusión a la tabla args; los parámetros posicionales no pueden excluirse sin valor de retorno ]=] función local pframe_args_get ( pframe_args , args , include , _include_positional , list ) para k , v en pares ( pframe_args ) hacer if 'string' == type ( k ) and not is_in_table ( include , k ) then -- no pasar los parámetros excluidos if v and ( '' ~= v ) then -- pasar solo aquellos parámetros que tienen valores asignados if 'unset' == v : lower () then -- palabra clave especial para anular los parámetros 'predeterminados' establecidos en la plantilla contenedora v = '' ; -- anular el valor en la tabla args end add_parameter ( k , v , args , list ) -- agrega todos los demás parámetros a args en el estilo dictado por la lista; alias map solo compatible con parámetros de plantilla local end end end if _include_positional then for i , v in ipairs ( pframe_args ) do -- pasa parámetros posicionales if 'unset' == v : lower () then -- palabra clave especial para anular los parámetros 'predeterminados' establecidos en la plantilla contenedora v = '' ; -- anula el valor en la tabla args end add_parameter ( i , v , args , list ); end end end -- [[--------------------------< _ MAIN >-------------------------------------------------------------------- Recopila los diversos parámetros predeterminados y activos en args con estilo de acuerdo con la lista booleana. devuelve el nombre de la plantilla de trabajo o listada o nil para un mensaje de error ]] función local _main ( frame , args , list ) plantilla local ; local excluir = {}; -- tabla de nombres de parámetros para parámetros que no se pasan a la plantilla de trabajo local reuse_list = {}; -- tabla de nombres de parámetros pframe cuyos valores se modifican antes de pasarlos a la plantilla de trabajo con el mismo nombre local alias_map = {}; -- tabla que asigna alias de parámetros a nombres de parámetros canónicos de la plantilla de trabajo local _include_positional ; si frame . args . _exclude y ( '' ~= frame . args . _exclude ) entonces -- si hay |_exclude= y no está vacío include = mw . text . split ( frame . args . _exclude , "%s*,%s*" ); -- crea una tabla a partir de su contenido end -- TODO: |_reuse= necesita un nombre mejor (|_reuse=) si frame . args . _reuse y ( '' ~= frame . args . _reuse ) entonces -- si hay |_reuse= y no está vacío reuse_list = mw . text . split ( frame . args . _reuse , "%s*,%s*" ); -- crea una tabla a partir de su contenido end if frame . args [ '_alias-map' ] and ( '' ~= frame . args [ '_alias-map' ]) entonces -- si hay |_alias-map= y no está vacío alias_map = alias_map_get ( frame . args [ '_alias-map' ]); -- crea una tabla a partir de su contenido end template = frame_args_get ( frame . args , args , list ); -- obtiene los parámetros provistos en el {{#invoke:template wrapper|...|...}} if nil == template or '' == template entonces -- este es el único parámetro que requiere este módulo return nil ; -- no presente, le dice a la función que llama que emita un mensaje de error end _include_positional = 'yes' == frame . args [ '_include-positional' ]; -- cuando es verdadero, pasa todos los parámetros posicionales junto con los parámetros nombrados no excluidos a ... -- ... la plantilla de trabajo; los parámetros posicionales no son excluibles local _pframe_args = frame : getParent (). args ; -- aquí obtenemos los parámetros 'activos' de la plantilla contenedora de pframe.args local pframe_args = {}; -- una tabla local que podemos modificar para k , v en pares ( _pframe_args ) do -- hace una copia que podemos modificar pframe_args [ k ] = v ; end -- aquí buscamos parámetros pframe que sean alias de nombres de parámetros canónicos; cuando se encuentran -- reemplazamos el alias con el canónico. Hacemos esto aquí porque reuse_list funciona en nombres de parámetros canónicos, por lo que primero convertimos los nombres de parámetros de alias en nombres canónicos y luego eliminamos esos nombres canónicos de la tabla pframe que se reutilizan (se proporcionan a la plantilla de trabajo a través de la tabla de argumentos del marco) para k , v en pares ( alias_map ) hacemos k es el nombre del alias, v es el nombre canónico si pframe_args [ k ] entonces si pframe_args tiene un parámetro con nombre de alias pframe_args [ v ] = _pframe_args [ k ]; -- crea un nuevo nombre canónico con el valor del alias pframe_args [ k ] = nil ; -- anula el alias end end para k , v en pares ( pframe_args ) do -- hace alias de parámetro enumerado -> traducción canónica if 'string' == type ( k ) then -- solo se pueden enumerar parámetros nombrados if alias_map [ k .. '#' ] then -- ¿el alias no enumerado coincide con el patrón del parámetro enumerado? enumerador solo al final pframe_args [ alias_map [ k .. '#' ]: gsub ( '#' , '' )] = v ; -- elimina '#' y copia el parámetro a la tabla pframe_args pframe_args [ k ] = nil ; -- anula el alias elseif k : match ( '%d+' ) then -- si este nombre de parámetro contiene dígitos local temp = k : gsub ( '%d+' , '#' ); -- hace una copia; dígitos reemplazados con un solo '#' local enum = k : match ( '%d+' ); -- obtener el enumerador si alias_map [ temp ] entonces -- si este parámetro es un alias enumerado reconocido pframe_args [ alias_map [ temp ]: gsub ( '#' , enum )] = v ; -- usa el nombre canónico y reemplaza '#' con el enumerador y agrega a pframe_args pframe_args [ k ] = nil ; -- desconfigura el alias end end end end -- los parámetros pframe que son _reutilizados son 'reutilizados' y tienen una forma similar a esta: -- |chapter=[[wikisource:{{{chapter}}}|{{{chapter}}}]] -- donde un parámetro en la plantilla de envoltura se modifica y luego se pasa a la plantilla de trabajo -- usando el mismo nombre de parámetro (en este ejemplo |chapter=) -- elimina los parámetros que serán reutilizados para k , v en ipairs ( reuse_list ) do -- k es el índice numérico, v es el nombre del parámetro canónico a ignorar if pframe_args [ v ] then -- si pframe_args tiene un parámetro que debe ignorarse pframe_args [ v ] = nil ; -- anula el parámetro ignorado end end pframe_args_get ( pframe_args , args , include , _include_positional , list ); -- agrega parámetros y valores a args que no están listados en la tabla de exclusión return template ; -- args ahora tiene todos los parámetros predeterminados y activos, devuelve el nombre de la plantilla de trabajo end --[[---------------------------< WRAP >---------------------------------------------------------------------- Punto de entrada de la plantilla. Llame a esta función para 'ejecutar' la plantilla de trabajo ]] función local wrap ( frame ) local args = {}; -- tabla de parámetros predeterminados y activos y sus valores que se pasarán a la plantilla envuelta local template ; -- el nombre de la plantilla de trabajo template = _main ( frame , args , false ); -- obtiene los parámetros predeterminados y activos y el nombre de la plantilla de trabajo si no es template entonces -- se requiere el nombre de la plantilla return error_msg ; -- emite un mensaje de error y abandona si el nombre de la plantilla no está presente end return frame : expandTemplate { title = template , args = args }; -- renderiza la plantilla de trabajo end --[[---------------------------< LIST >---------------------------------------------------------------------- Punto de entrada de la plantilla. Llama a esta función para 'mostrar' la fuente de la plantilla de trabajo. Esta función se agregó como resultado de un TfD aquí: Wikipedia:Templates_for_discussion/Log/2018_April_28#Module:PassArguments Esta función reemplaza una función con un nombre similar que se usó en {{cite compare}} y {{cite compare2}} Los valores en la tabla args son cadenas indexadas numéricamente en el formato 'nombre=valor' ]] función local list ( frame , do_link ) args local = {}; -- tabla de parámetros predeterminados y activos y sus valores que se pasarán a la plantilla listada plantilla local ; -- el nombre de la plantilla listada plantilla = _main ( frame , args , true ); -- obtener los parámetros predeterminados y activos y el nombre de la plantilla listada si no es una plantilla entonces -- se requiere el nombre de la plantilla return error_msg ; -- emitir un mensaje de error y abandonar si el nombre de la plantilla no está presente end if do_link then template = ( '[[%s|%s]]' ): format ( frame : expandTemplate { title = 'Transclude' , args = { template } }, template ) end table.sort ( args ) for i = 1 , # args do local stripped = args [ i ]: match ( '^' .. i .. '=([^=]*)$' ) if stripped then args [ i ] = stripped else break end end retorna marco : preproceso ( tabla.concat ({ '<code style="color:inherit; background:inherit; border:none;">{{' , plantilla , ( '<wbr><nowiki>|%s</nowiki>' ): rep ( # args ): formato ( unpack ( args )), '}}</code>' })); -- renderiza la plantilla fin función local enlace ( marco ) retorna lista ( marco , verdadero ) fin --[[---------------------------<EXPORTEDFUNCTIONS >------------------------------------------ ]] retorna { enlace = enlace , lista = lista , envoltura = envoltura , };