stringtranslate.com

Módulo: Caso de prueba de plantilla 

--[[  Un módulo para generar plantillas de casos de prueba.  Este módulo incorpora código del  módulo "Tabla de casos de prueba" de la Wikipedia en inglés,[1] escrito por Frietjes [2] con contribuciones de Stradivarius [3]  y Jackmcbarn,[4] y el módulo "Filas de casos de prueba" de la Wikipedia en inglés,[5]  escrito por Stradivarius.  Los módulos "Tabla de casos de prueba" y "Filas de casos de prueba" se publican bajo la  licencia CC BY-SA 3.0 [6] y la GFDL.[7]  Licencia: CC BY-SA 3.0 y GFDL  Autor: Sr. Stradivarius  [1] https://en.wikipedia.org/wiki/Module:Template_test_case/Module:Testcase_table  [2] https://en.wikipedia.org/wiki/Module:Template_test_case/User:Frietjes  [3] https://en.wikipedia.org/wiki/Module:Template_test_case/User:Mr._Stradivarius  [4] https://en.wikipedia.org/wiki/Module:Template_test_case/User:Jackmcbarn  [5] https://en.wikipedia.org/wiki/Module:Template_test_case/Module:Testcase_rows  [6] https://en.wikipedia.org/wiki/Module:Template_test_case/Wikipedia:Text_of_Creative_Commons_Attribution-ShareAlike_3.0_Unported_License  [7] https://en.wikipedia.org/wiki/Module:Template_test_case/Wikipedia:Text_of_the_GNU_Free_Documentation_License ]] -- Cargar módulos requeridos local yesno = require ( 'Módulo:Yesno' ) -- Establecer constantes local DATA_MODULE = 'Módulo:Plantilla caso de prueba/datos' ------------------------------------------------------------------------------- -- Métodos compartidos ------------------------------------------------------------------------------- función local message ( self , key , ...) -- Este método se agrega a las clases que necesitan tratar con mensajes del módulo -- config . local msg = self . cfg . msg [ key ] if select ( 1 , ...) then return mw . message . newRawMessage ( msg , ...): plain () else return msg end end ------------------------------------------------------------------------------- -- Clase de plantilla ------------------------------------------------------------------------------- local Template = {} Template . memoizedMethods = {                        -- Nombres de los métodos que se memorizarán en cada objeto. Esta tabla solo debe -- contener métodos sin parámetros. getFullPage = true , getName = true , makeHeader = true , getOutput = true } function Template . new ( invocationObj , options ) local obj = {} -- Establecer la entrada para k , v en pares ( options o {}) do if not Template [ k ] then obj [ k ] = v end end obj . _invocation = invocationObj -- Validar la entrada si no es obj . template y no obj . título entonces error ( 'no se especificó plantilla o título' , 2 ) fin - Memorizar llamadas a métodos costosos local memoFuncs = {} return setmetatable ( obj , { __index = function ( t , key ) if Template . memoizedMethods [ key ] then local func = memoFuncs [ key ] if not func then local val = Template [ key ]( t ) func = function () return val end memoFuncs [ key ] = func end return func else return Template [ key ] end end }) fin función Template : getFullPage () if not self . template then return self . title                                                                     . prefixedText elseif self . template : sub ( 1 , 7 ) == '#invoke' entonces devuelve 'Módulo' .. self . template : sub ( 8 ): gsub ( '|.*' , '' ) de lo contrario local strippedTemplate , hasColon = self . template : gsub ( '^:' , '' , 1 ) hasColon = hasColon > 0 local ns = strippedTemplate : match ( '^(.-):' ) ns = ns y mw . site . namespaces [ ns ] si ns entonces devuelve strippedTemplate elseif hasColon entonces devuelve strippedTemplate -- Espacio de nombres principal de lo contrario devuelve mw . site . namespaces [ 10 ]. nombre .. ':' .. strippedTemplate fin fin fin función Plantilla : getName () si self . template entonces devuelve self . plantilla de lo contrario devolver require ( 'Módulo: Invocación de plantilla' ). nombre ( self . título ) fin fin función Plantilla : makeLink ( mostrar ) si mostrar entonces devolver cadena. formato ( '[[:%s|%s]]' , self : getFullPage (), mostrar ) de lo contrario devolver cadena. formato ( '[[:%s]]' , self : getFullPage ()) fin fin función Plantilla : makeBraceLink (                                                    mostrar ) mostrar = mostrar o self : getName () local link = self : makeLink ( mostrar ) return mw.text.nowiki ( ' { {' ) .. link .. mw.text.nowiki ( '}}' ) fin de la función Plantilla : makeHeader () return self.heading o self : makeBraceLink ( ) fin de la función Plantilla : getInvocation ( formato ) local invocación = self._invocación : getInvocation { plantilla = self : getName (), requireMagicWord = self.requireMagicWord , } si formato == ' código ' entonces invocación = ' < código > ' .. mw.text.nowiki ( invocación ) .. ' </code>' de lo contrario si formato == ' kbd ' entonces invocación = ' <kbd> ' .. mw.text . nowiki ( invocación ) .. '</kbd>' elseif format == 'plain' then invocación = mw . text . nowiki ( invocación ) else -- El valor predeterminado es pre tags invocación = mw . text . encode ( invocación , '&' ) invocación = '<pre style="white-space: pre-wrap;">' .. invocación .. '</pre>' invocación = mw . getCurrentFrame ():preprocesar ( invocación ) fin retorno                                                              función de fin de invocación Plantilla : getOutput () local protect = require ( 'Module:Protect' ) -- llamando a self._invocation:getOutput{...} return protect ( self._invocation.getOutput ) ( self._invocation , { template = self : getName ( ) , requireMagicWord = self.requireMagicWord , } ) fin ------------------------------------------------------------------------------- -- Clase TestCase ------------------------------------------------------------------------------- local TestCase = {} TestCase.__index = TestCase TestCase.message = message -- agrega el método de mensaje TestCase.renderMethods = { -- Las claves en esta tabla son valores de la opción " format " , los valores son el -- método para representar ese formato. columnas = 'renderColumns' , filas = 'renderRows' , tablerows = 'renderRows' , en línea = 'renderInline', celdas = 'renderCells', predeterminado = 'renderDefault'} function TestCase.new(invocationObj, options, cfg) local obj = setmetatable ( { } , TestCase ) obj.cfg = cfg -- Separa las opciones generales de las opciones de plantilla . Las opciones de plantilla están numeradas , mientras que las generales no. local generalOptions , templateOptions = {}, {} para k , v en pares ( options ) do local prefix , num if type ( k ) == 'string' then                                                         prefijo ,  num  =  k : match ( '^(.-)([1-9][0-9]*)$' ) fin si prefijo entonces num = tonumber ( num ) templateOptions [ num ] = templateOptions [ num ] o {} templateOptions [ num ][ prefijo ] = v de lo contrario generalOptions [ k ] = v fin fin -- Establecer opciones generales generalOptions . showcode = yesno ( generalOptions . showcode ) generalOptions . showheader = yesno ( generalOptions . showheader ) ~= false generalOptions . showcaption = yesno ( generalOptions . showcaption ) ~= false generalOptions . collapsible = yesno ( generalOptions . collapsible ) generalOptions . notcollapsed = yesno ( generalOptions . notcollapsed ) generalOptions . wantdiff = yesno ( generalOptions.wantediff ) obj.options = generalOptions -- Preprocesar argumentos de plantilla para num , t en pares ( templateOptions ) do if t.showtemplate ~ = nil then t.showtemplate = yesno ( t.showtemplate ) end end -- Configurar las dos primeras tablas de opciones de plantilla, de modo que si solo se especifica " template3 " , no se convierta en la primera plantilla cuando se comprima la matriz de opciones de la tabla. templateOptions [ 1 ] = templateOptions [ 1                                            ]  o  {} templateOptions [ 2 ] = templateOptions [ 2 ] o {} - Permitir que la opción "template" anule la opción "template1" para - compatibilidad con versiones anteriores con [[Module:Testcase table]]. if generalOptions . template then templateOptions [ 1 ]. template = generalOptions . template end - Agregar opciones de plantilla predeterminadas if templateOptions [ 1 ]. template and not templateOptions [ 2 ]. template then templateOptions [ 2 ]. template = templateOptions [ 1 ]. template .. '/' .. obj . cfg . sandboxSubpage end if not templateOptions [ 1 ]. template then templateOptions [ 1 ]. title = mw . title . getCurrentTitle (). basePageTitle end if not templateOptions [ 2 ]. template then templateOptions [ 2 ]. title = templateOptions [ 1 ]. título : subPageTitle ( obj.cfg.sandboxSubpage ) fin : elimina las opciones de plantilla para cualquier plantilla en la que el argumento showtemplate sea falso . Esto evita cualquier salida para esa plantilla. for num , t in pairs ( templateOptions ) do if t.showtemplate == false then templateOptions [ num ] = nil fin fin : comprueba si faltan nombres de plantilla . for num , t in pairs ( templateOptions ) do if                                             no  t . plantilla  y  no  t . título  entonces error ( obj : mensaje ( 'error-de-opción-de-plantilla-faltante' , num , num ), 2 ) fin fin -- Comprime la tabla templateOptions para que podamos iterarla con ipairs. templateOptions = ( function ( t ) local nums = {} for num in pairs ( t ) do nums [ # nums + 1 ] = num fin tabla. sort ( nums ) local ret = {} for i , num in ipairs ( nums ) do ret [ i ] = t [ num ] fin return ret fin )( templateOptions ) -- No requiere la palabra mágica __TEMPLATENAME__ para invocaciones de nowiki si -- solo se está generando una plantilla. si # templateOptions <= 1 entonces templateOptions [ 1 ]. requireMagicWord = false fin mw . logObject ( templateOptions ) - Crea los objetos de plantilla obj.templates = { } for i , options in ipairs ( templateOptions ) do table.insert ( obj.templates , Template.new ( invocationObj , options ) ) end - Agrega categorías de seguimiento. Por el momento, solo estamos haciendo seguimiento de plantillas que usan cualquier parámetro de "encabezado" o un parámetro de "salida" . obj.categories = { } for k , v in pairs ( options ) do if type                                                  ( k )  ==  'string'  and  k : find ( 'heading' )  then obj . categorys [ 'Casos de prueba que usan parámetros de encabezado' ] = true elseif k == 'output' then obj . categorys [ 'Casos de prueba que usan parámetros de salida' ] = true end end return obj end function TestCase : getTemplateOutput ( templateObj ) local output = templateObj : getOutput () if self . options . resetRefs then mw . getCurrentFrame (): extensionTag ( 'references' ) end return output end function TestCase : templateOutputIsEqual () -- Devuelve un valor booleano que muestra si todas las salidas de la plantilla son iguales. -- Las partes aleatorias de los marcadores de tira (ver [[Help:Strip markers]]) son -- eliminadas antes de la comparación. Esto significa que un marcador de tira puede contener cualquier cosa -- y aún así ser tratado como igual, pero resuelve el problema de que un wikitexto que de otra manera sería idéntico no regrese como exactamente igual. función local normaliseOutput ( obj ) local out = obj : getOutput () - Elimina las partes aleatorias de los marcadores de tira. out = out : gsub ( '( \127 [^ \127 ]*UNIQ%-%-%l+%-)%x+(%-%-?QINU[^ \127 ]* \127 )' , ' %1 % 2 ' ) return out end local firstOutput = normaliseOutput ( self.templates [ 1 ] ) para i = 2 , # self.templates hacer local output = normaliseOutput ( self.templates [ i ] )                                     si  salida  ~   = firstOutput entonces devuelve falso fin fin devuelve verdadero fin función TestCase : makeCollapsible ( s ) título local = self.options.title o self.templates [ 1 ] : makeHeader ( ) si self.options.titlecode entonces título = self.templates [ 1 ] : getInvocation ( ' kbd ' ) fin local isEqual = self : templateOutputIsEqual ( ) raíz local = mw.html .​​​​​​​ crear ( 'div' ) raíz : addClass ( 'mw-collapsible' ) : css ( 'ancho' , '100%' ) : css ( 'borde' , 'plata sólida 1px' ) : css ( 'relleno' , '0.2em' ) : css ( 'borrar' , 'ambos' ) : addClass ( self . options . notcollapsed == false y 'mw-collapsed' o nulo ) si self . options . wantdiff entonces root : etiqueta ( 'div' ) : css ( 'color-de-fondo' , esIgual y 'amarillo' o '#90a8ee' ) : css ( 'color' , 'negro' ) : css ( 'peso-de-fuente' , 'negrita' ) : css ( 'relleno' , '0.2em' ) : wikitexto ( título ) :hecho () de lo contrario si                                       self.options.notcollapsed ~= true o false entonces      root : addClass ( isEqual y 'mw - collapsed' o nil ) fin root : tag ( 'div' ) : css ( 'background-color' , isEqual y ' lightgreen ' o ' yellow' ) : css ( 'color' , ' black' ) : css ( 'font-weight' , 'bold' ) : css ( 'padding' , '0.2em' ) : wikitext ( title ) : done () fin root : tag ( 'div' ) : addClass ( 'mw-collapsible- content ' ) : newline ( ) : wikitext ( s ) : newline ( ) devolver tostring ( root ) fin función TestCase : renderColumns ( ) raíz local = mw.html.create ( ) si self.options . showcode entonces root : wikitext ( self . templates [ 1 ] : getInvocation ()) : newline () fin local tableroot = root : tag ( 'tabla' ) si self . options . showheader entonces -- Título si self . options . showcaption entonces tableroot : addClass ( self . options . class ) : cssText ( self . options . style ) : tag                          ( 'caption' ) : wikitext ( self . options . caption o self : message ( 'columns-header' )) fin -- Encabezados local headerRow = tableroot : tag ( 'tr' ) si self . options . rowheader entonces -- rowheader es correcto aquí. Necesitamos agregar otra celda th si -- rowheader se establece más abajo, incluso si header0 falta. headerRow : tag ( 'th' ): wikitext ( self . options . header0 ) fin local width si # self . plantillas > 0 entonces ancho = tostring ( math.floor ( 100 / # self .templates )) .. '%' de lo contrario ancho = '100%' fin para i , obj en ipairs ( self .templates ) hacer headerRow : etiqueta ( 'th' ) : css ( 'width' , width ) : wikitext ( obj : makeHeader ()) fin fin -- Encabezado de fila local dataRow = tableroot : etiqueta ( ' tr' ): css ( 'vertical-align' , ' top' ) si self .options .rowheader entonces dataRow : etiqueta ( 'th' ) : attr ( ' scope ' , 'row' ) : wikitext ( self .options .rowheader ) fin -- Salida de plantilla para i ,obj en ipairs ( auto .                                     plantillas )  hacer si self.options.output == ' nowiki + ' entonces dataRow : etiqueta ( ' td ' ) : nueva línea ( ) : wikitexto ( self.options.before ) : wikitexto ( self : getTemplateOutput ( obj ) ) : wikitexto ( self.options.after ) : wikitexto ( ' < pre style = " white - space : pre - wrap ; " > ' ) : wikitexto ( mw.text.nowiki ( self.options.before o " " ) ) : wikitexto ( mw.text.nowiki ( self : getTemplateOutput ( obj ) ) ) : wikitexto ( mw.text.nowiki ( self.options.after o " " ) ) : wikitexto ( ' </pre> ' ) elseif self.options .​​ salida == 'nowiki' entonces dataRow : etiqueta ( 'td' ) : nueva línea () : wikitext ( mw . text . nowiki ( self . options . before o "" )) : wikitext ( mw . text . nowiki ( self : getTemplateOutput ( obj ))) : wikitext ( mw . text . nowiki ( self . options . after o "" )) de lo contrario dataRow :etiqueta ( 'td' ) :                newline ( ) : wikitext ( self.options.before ) : wikitext ( self : getTemplateOutput ( obj ) ) : wikitext ( self.options.after ) fin fin return tostring ( root ) fin función TestCase : renderRows ( ) local root = mw.html.create ( ) si self.options.showcode entonces root : wikitext ( self.templates [ 1 ] : getInvocation ( ) ) : newline ( ) fin local tableroot = root : tag ( ' tabla ' ) tableroot : addClass ( self.options.class ) : cssText ( self.options.style ) si self.options .​​​​​​​​​​​​​​​​​​ título entonces tableroot : etiqueta ( 'título' ) : wikitexto ( self . opciones . título ) fin para _ , obj en ipairs ( self . plantillas ) hacer local dataRow = tableroot : etiqueta ( 'tr' ) -- Encabezado si self . opciones . mostrar encabezado entonces si self . opciones . formato == 'tablerows' entonces dataRow : etiqueta ( 'th' ) : attr ( 'ámbito' , 'fila' ) : css ( 'alineación vertical'                           ,  'arriba' ) : css ( 'alineación-texto' , 'izquierda' ) : wikitexto ( obj : makeHeader ()) dataRow : etiqueta ( 'td' ) : css ( 'alineación-vertical' , 'arriba' ) : css ( 'padding' , '0 1em' ) : wikitexto ( '→' ) de lo contrario dataRow : etiqueta ( 'td' ) : css ( 'alineación-texto' , 'centro' ) : css ( 'peso-fuente' , 'bold' ) : wikitexto ( obj : makeHeader ()) dataRow = tableroot : etiqueta ( 'tr' ) fin fin -- Salida de plantilla if self . options . salida == 'nowiki+' entonces dataRow : etiqueta ( 'td' ) : nueva línea () : wikitexto ( self . options . before ) : wikitexto ( self : getTemplateOutput ( obj )) : wikitexto ( self . options . after ) : wikitexto ( '<pre style="white-space: pre-wrap;">' ) : wikitexto ( mw . text . nowiki ( self . options . before o "" )) : wikitexto ( mw . text . nowiki ( self : getTemplateOutput ( obj ))) : wikitexto ( mw . text . nowiki ( self . options .después o "" ))                       : wikitexto ( '</pre>' ) elseif self . options . output == 'nowiki' then dataRow : tag ( 'td' ) : nueva línea () : wikitexto ( mw . text . nowiki ( self . options . before o "" )) : wikitexto ( mw . text . nowiki ( self : getTemplateOutput ( obj ))) : wikitexto ( mw . text . nowiki ( self . options . after o "" )) else dataRow : tag ( 'td' ) : nueva línea () : wikitexto ( self . options . before ) : wikitexto ( self : getTemplateOutput ( obj )) : wikitexto ( self . options . after ) fin fin return tostring ( root ) fin función TestCase : renderInline () flecha local = mw . language . getContentLanguage ( ) : getArrow ( ' forwards ' ) local ret = { } para i , obj en ipairs ( self.templates ) hacer local línea = { } línea [ # línea + 1 ] = self.options.prefix o ' * ' si self.options.showcode entonces línea [ # línea +​​                                  1 ]  =  obj : getInvocation ( 'código' ) línea [ # línea + 1 ] = ' ' línea [ # línea + 1 ] = flecha línea [ # línea + 1 ] = ' ' fin si self . opciones . salida == 'nowiki+' entonces línea [ # línea + 1 ] = self . opciones . antes o "" línea [ # línea + 1 ] = self : getTemplateOutput ( obj ) línea [ # línea + 1 ] = self . opciones . después o "" línea [ # línea + 1 ] = '<pre style="white-space: pre-wrap;">' línea [ # línea + 1 ] = mw . texto . nowiki ( self . opciones . antes o "" ) línea [ # línea + 1 ] = mw . texto . nowiki ( self : getTemplateOutput ( obj )) línea [ # línea + 1 ] = mw . texto . nowiki ( self . options . after o "" ) línea [ # línea + 1 ] = '</pre>' elseif self . options .salida == 'nowiki' entonces línea [ # línea + 1 ] = mw                                                                . texto . nowiki ( self . opciones . antes  o  "" ) línea [ # línea + 1 ] = mw . texto . nowiki ( self : getTemplateOutput ( obj )) línea [ # línea + 1 ] = mw . texto . nowiki ( self . opciones . después o "" ) de lo contrario línea [ # línea + 1 ] = self . opciones . antes o "" línea [ # línea + 1 ] = self : getTemplateOutput ( obj ) línea [ # línea + 1 ] = self . opciones . después o "" fin ret [ # ret + 1 ] = tabla. concat ( línea ) fin si self . opciones . añadir línea entonces local línea = {} línea [ # línea + 1 ] = self . opciones . prefijo o '* ' línea [ # línea + 1 ] = self . opciones . addline ret [ # ret + 1 ] = table.concat ( line ) fin return table.concat ( ret , ' \n ' ) fin de la función TestCase : renderCells () raíz local = mw . html . create                                                       () local dataRow = root : tag ( 'tr' ) dataRow : css ( 'vertical-align' , 'top' ) : addClass ( self . options . class ) : cssText ( self . options . style ) -- Encabezado de fila si self . options . rowheader entonces dataRow : tag ( 'th' ) : attr ( 'scope' , 'row' ) : newline () : wikitext ( self . options . rowheader o self : message ( 'row-header' )) fin -- Título si self . options . showcaption entonces dataRow : tag ( 'th' ) : attr ( 'scope' , 'row' ) : newline () : wikitext ( self . options . caption o self : message ( 'columns-header' )) fin -- Mostrar código si self . options . showcode entonces dataRow : tag ( 'td' ) : newline () : wikitext ( self : getInvocation ( 'code' )) fin -- Salida de plantilla para i , obj en ipairs ( self . templates ) hacer si self . options . output == 'nowiki+' entonces dataRow : tag ( 'td' ) : newline () : wikitext ( self .                         opciones . antes ) : wikitexto ( self : getTemplateOutput ( obj )) : wikitexto ( self . opciones . después ) : wikitexto ( '<pre style="white-space: pre-wrap;">' ) : wikitexto ( mw . texto . nowiki ( self . opciones . antes o "" )) : wikitexto ( mw . texto . nowiki ( self : getTemplateOutput ( obj ))) : wikitexto ( mw . texto . nowiki ( self . opciones . después o "" )) : wikitexto ( '</pre>' ) elseif self . opciones . salida == ' nowiki ' entonces dataRow : etiqueta ( ' td ' ) : nueva línea ( ) : wikitexto ( mw.texto.nowiki ( self.opciones.antes o " " ) ) : wikitexto ( mw.texto.nowiki ( self : getTemplateOutput ( obj ) ) ) : wikitexto ( mw.texto.nowiki ( self.opciones.después o " " ) ) de lo contrario dataRow : etiqueta ( ' td ' ) : nueva línea ( ) : wikitexto ( self.opciones.antes ) : wikitexto ( self : getTemplateOutput ( obj ) ) : wikitexto ( self .​​​​​            opciones . después ) fin fin devolver tostring ( raíz ) fin función TestCase : renderDefault () local ret = {} si self . opciones . mostrar código entonces ret [ # ret + 1 ] = self . plantillas [ 1 ]: getInvocation () fin para i , obj en ipairs ( self . plantillas ) hacer ret [ # ret + 1 ] = '<div style="clear: both;"></div>' si self . opciones . mostrar encabezado entonces ret [ # ret + 1 ] = obj : makeHeader () fin si self . opciones . salida == 'nowiki+' entonces ret [ # ret + 1 ] = ( self . opciones . antes o "" ) .. self : getTemplateOutput ( obj ) .. ( self . opciones . después o "" ) .. '<pre style="white-space: pre-wrap;">' .. mw . texto . nowiki ( self . opciones . antes o "" ) .. mw . texto . nowiki ( self : getTemplateOutput ( obj )) .. mw . texto . nowiki ( self . opciones . después o "" ) .. '</pre>' elseif self . opciones .producción                                                    ==  'nowiki'  entonces ret [ # ret + 1 ] = mw . texto . nowiki ( self . opciones . antes o "" ) .. mw . texto . nowiki ( self : getTemplateOutput ( obj )) .. mw . texto . nowiki ( self . opciones . después o "" ) de lo contrario ret [ # ret + 1 ] = ( self . opciones . antes o "" ) .. self : getTemplateOutput ( obj ) .. ( self . opciones . después o "" ) fin fin devolver tabla. concat ( ret , ' \n\n ' ) fin función TestCase : __tostring () formato local = self . opciones . formato método local = formato y TestCase . renderMethods [ formato ] o 'renderDefault' ret local = self [ método ] ( self ) si self . opciones . colapsable entonces ret = self : makeCollapsible ( ret ) fin para cat en pares ( self . categorías ) hacer ret = ret .. string.format ( '[[Categoría:%s]]' , gato ) fin devolver ret fin ------------------------------------------------------------------------------- -- Clase de invocación de Nowiki                                                  ------------------------------------------------------------------------------- local NowikiInvocation = {} NowikiInvocation . __index = NowikiInvocation NowikiInvocation . message = message -- Agrega la función del método message NowikiInvocation . new ( invocation , cfg ) local obj = setmetatable ({}, NowikiInvocation ) obj . cfg = cfg invocation = mw . text . unstrip ( invocation ) -- Descodifica las entidades HTML para <, > y ". Esto significa que las entidades HTML en -- el código original deben ser escapadas como por ejemplo &lt;, lo cual es desafortunado, -- pero es lo mejor que podemos hacer ya que la distinción entre <, >, " y <, -- >, " se pierde durante la operación nowiki original. invocación = invocación : gsub ( '<' , '<' ) invocación = invocación : gsub ( ' >' , ' >' ) invocación = invocación : gsub ( ' "' , '"' ) obj.invocación = invocación return obj fin función NowikiInvocación : getInvocación ( opciones ) local plantilla = opciones.plantilla : gsub ( '%%' , '%%%%' ) -- Escapar " % " con " %% " local invocación , conteo = self.invocación : gsub ( self.cfg.templateNameMagicWordPattern , plantilla ) si opciones.requireMagicWord ~ = false y conteo < 1 entonces error ( self :mensaje ( 'nowiki-magic-word-error' ,                                                self.cfg.templateNameMagicWord ) ) fin return invocación fin función NowikiInvocation : getOutput ( opciones ) local invocación = self : getInvocation ( opciones ) return mw.getCurrentFrame ( ) : preprocess ( invocación ) fin ------------------------------------------------------------------------------- -- Clase de invocación de tabla ------------------------------------------------------------------------------- local TableInvocation = { } TableInvocation .__ index = TableInvocation TableInvocation.message = message -- Agrega el método de mensaje function TableInvocation.new ( invokeArgs , nowikiCode , cfg ) local obj = setmetatable ( { } , TableInvocation ) obj.cfg = cfg obj.invokeArgs = invokeArgs obj.code = nowikiCode return obj fin función TableInvocation : getInvocation ( opciones ) if self.code then local nowikiObj = NowikiInvocation .​ nuevo ( self.code , self.cfg ) return nowikiObj : getInvocation ( opciones ) de lo contrario return require ( ' Módulo : Plantilla invocación ' ) . invocación ( opciones.plantilla , self.invocateArgs ) fin fin función TableInvocation : getOutput ( opciones ) si ( opciones.plantilla : sub​​                                       ( 1 ,  7 )  ==  '#invoke' )  entonces local moduleCall = mw . text . split ( options . template , '|' , true ) local args = mw . clone ( self . activateArgs ) table. insert ( args , 1 , moduleCall [ 2 ]) return mw . getCurrentFrame (): callParserFunction ( moduleCall [ 1 ], args ) end return mw . getCurrentFrame (): expandTemplate { title = options . template , args = self . activateArgs } end ------------------------------------------------------------------------------- -- Funciones puente -- -- Estas funciones traducen los argumentos de plantilla en formatos que pueden ser aceptados -- por las diferentes clases, y devuelven los resultados. ------------------------------------------------------------------------------- local bridge = {} function bridge . table ( args , cfg ) cfg = cfg o mw . loadData ( DATA_MODULE ) opciones locales , invocarArgs = {}, {} para k , v en pares ( args ) hacer optionKey local = type ( k ) == 'string' y k : match ( '^_(.*)$' ) si optionKey entonces si type ( v ) == 'string' entonces v = v : match ( '^%s*(.-)%s*$' ) -- eliminar espacios en blanco                                                    end if v ~= '' then options [ optionKey ] = v end else invokeArgs [ k ] = v end end -- Permitir pasar una invocación de nowiki como una opción. Si bien esto significa que los usuarios -- tienen que pasar el código dos veces, se conservan los espacios en blanco y < etc. -- funcionará como se espera. local nowikiCode = options . code options . code = nil local invocationObj = TableInvocation . new ( invokeArgs , nowikiCode , cfg ) local testCaseObj = TestCase . new ( invocationObj , options , cfg ) return tostring ( testCaseObj ) end function bridge . nowiki ( args , cfg ) cfg = cfg o mw . loadData ( DATA_MODULE ) - Convierte los argumentos que comienzan con _ para mantener la coherencia con el puente normal local newArgs = { } para k , v en pares ( args ) hacer local normalName = type ( k ) == " string " y string.match ( k , "^_(. * )$" ) si normalName entonces newArgs [ normalName ] = v de lo contrario newArgs [ k ] = v fin fin local code = newArgs.code o newArgs [ 1 ] local invocationObj = NowikiInvocation.new ( code , cfg ) newArgs.code = nil newArgs [ 1 ]                                                                =  nil - Supongamos que queremos ver el código como ya lo pasamos. newArgs . showcode = newArgs . showcode o true local testCaseObj = TestCase . new ( invocationObj , newArgs , cfg ) return tostring ( testCaseObj ) end ------------------------------------------------------------------------------- -- Exportaciones ------------------------------------------------------------------------------- local p = {} function p . main ( frame , cfg ) cfg = cfg o mw . loadData ( DATA_MODULE ) - Cargar la configuración del contenedor, si hay alguna. local wrapperConfig if frame . getParent then local title = frame : getParent (): getTitle () local template = title : gsub ( cfg . sandboxSubpagePattern , '' ) wrapperConfig = cfg . wrappers [ template ] end -- Calcular la función que llamaremos, usarla para generar la configuración para -- Module:Arguments, y usar Module:Arguments para encontrar los argumentos pasados ​​-- por el usuario. local func = wrapperConfig and wrapperConfig . func or 'table' local userArgs = require ( 'Module:Arguments' ). getArgs ( frame , { parentOnly = wrapperConfig , frameOnly = not wrapperConfig , trim = func ~= 'table' , removeBlanks = func ~= 'table' }) -- Obtener los argumentos predeterminados y construir la tabla de argumentos. Los argumentos especificados por el usuario sobrescriben los argumentos predeterminados. local                                                        defaultArgs  =  wrapperConfig  y  wrapperConfig . args  o  {} argumentos locales = {} para k , v en pares ( defaultArgs ) do args [ k ] = v end for k , v en pares ( userArgs ) do args [ k ] = v end return bridge [ func ]( args , cfg ) función final p . _exportClasses () - Para probar return { Plantilla = Plantilla , TestCase = TestCase , NowikiInvocation = NowikiInvocation , TableInvocation = TableInvocation } end return p