Módulo:Zona de pruebas/Eloy/Ficha fácil
A continuación se muestra la documentación transcluida desde la subpágina /doc. [salta a la caja de código]
Descripción
Este módulo intenta ofrecer una alternativa más versátil y legible a Ficha. Está en prueba, por lo que está completamente sujeta a cambios.
Características
- No hace falta renombrar otros campos, cuando se hace una modificación a la estructura (agregar, quitar o cambiar de lugar campos). Esto sí sucede con
{{Ficha}}, donde si se agrega un campo hay que cambiar la numeración de los subsiguientes. - Fácil de reestructurar. Se indica directamente el orden de los campos que incluye cada sección.
- Nombres internos fáciles. En lugar de usar una numeración para hacer referencia a cada campo, se usa un nombre a elección del usuario.
- Autocarga de parámetros: Si el nombre interno del campo es el mismo que el parámetro, permite la carga automática cuando no se especifique un valor.
- Infinitos campos similares: Permite la expansión de una regla mediante expresiones regulares. De esta manera se especifica una sola vez el comportamiento que pueden adquirir campos con nombres similares.
- Estilos fácil: Además de poder indicar las clases y estilos a cada nombre y valor de campo, se puede crear clases para reusar dentro de la ficha.
Uso
El módulo comienza cargando los campos indicados en :hijos; y en cada campo que funcione como sección, tiene su propio parámetro <*>:hijos para incluir campos adentro. El orden en el que se indican los hijos determina el orden en el que se muestran; pero el orden de los parámetros no afecta al comportamiento, por lo que puede incorporarse de la forma que sea más legible.
Campos
Los posibles valores para cada campo son:
campo:clase: Clases de la o las filas del campo.campo:def: Valor y comportamiento por defecto si el valor indicado está vacío.- Puede cargar una propiedad desde Wikidata, incluso puede concatenar las consultas (por ejemplo, P2P1 significa la propiedad 1 del valor de la propiedad 2 del objeto actual).
- Puede incorporar {{{parámetros|}}}
campo:enlazar: Si es 1 y hay un nombre, pero no contiene enlaces, le añade corchetes.campo:estilo: Estilo de la o las filas del campo.campo:mostrar: Indica si el campo se muestra..- 0: Se oculta siempre.
- 1: (por defecto) Se oculta si el texto está vacío.
- 2: Se muestra siempre. Si está vacío podría mostrar opciones para completarlo más fácilmente.
campo:nombrar: Según sus valores, puede añadir un texto (antes de procesar:enlazar) cuando no se haya indicado ninguno.- 0: Sin nombre por defecto.
- 1: Usa el nombre interno del campo, sin modificaciones.
- 2: Usa el nombre interno del campo, con mayúscula inicial.
campo:nombre: Indica el texto a mostrar como nombre del campo (salvo título y subtítulo) o el pie de imagen (en caso de ser una). Su comportamiento depende también de las opciones vigentes en ese momento.campo:nombre:clase: Clases de la celda que muestra el nombre.campo:nombre:estilo: Estilo de la celda que muestra el nombre.campo:tipo: Indica el tipo de campo:campo: Es el campo normal, que tiene el nombre en una columna (mediante TH) y el valor en la otra (TD).largo: Es un campo para textos más largos, que tiene el nombre en una fila, y el valor en la inferior.título: Especial para títulos de fichas.subtítulo: Permite la inclusión de subtítulo a la ficha.imagen: Muestra una imagen tomando el nombre de archivo indicado en el valor, y el nombre del campo como pie de imagen. Si la imagen no existe, se comporta como "largo" (salvo que sea indicado otro comportamiento):imagen ocultar: Si la imagen no existe, se oculta el campo.imagen campo: Si la imagen no existe, se muestra como "campo".imagen título: Si la imagen no existe, se muestra como "título". Es útil para permitir el uso de imágenes en lugar de texto en el título.sección: Se comporta como una sección.
campo:prefijo: Texto que se añade antes del valor, si es que se indicó alguno.campo:sufijo: Texto que se añade después del valor, si es que se indicó alguno.campo:valor: Indica el valor del campo. Si no se indica puede intentar completarlo según distintas opciones. Si así y todo no hay valor, el campo es ocultado (depende de opciones).campo:valor:clase: Clases de la celda que muestra el valor.campo:valor:estilo: Estilo de la celda que muestra el valor.
Secciones
Las secciones, además de poder tener las opciones anteriores, también tienen campos hijos y opciones por defecto para aquéllos. De hecho, el procesamiento de la ficha comienza desde la sección raíz, que es la que no tiene nombre interno. Las opciones adicionales son las siguientes:
sección:hijos: Una lista separada por comas de los campos hijos. También se permiten expresiones regulares, en ese caso se tomaran como hijos todos los campos que la acepten.- '
sección:hijos:opción: Indica el valor por defecto (para sus hijos) para la opción indicada.
Ejemplos
| Código | Resultado | ||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Uso{{…
|subtítulo=Sal, colorante coloidal
|UNII=3U05FHG59S
|IUPAC=3,3'-([1,1'-bifenil]-4,4'-diil)bis(4-aminonaftaleno-1-sulfonato) disódico
}}
|
| ||||||||||||||||
|
| ||||||||||||||||
|
| ||||||||||||||||
Hoja de ruta de desarrollo
- dameNombre(): Usa el valor de regla si está disponible, y sino nombre.
- dameNombre(): obtener texto directo o nada.
- dameValor(): obtener texto directo o nada.
- dameTipo(): obtener texto directo o nada.
- popOpc(): Tirar de la pila.
- pushOpc(): obtener texto directo o nada, no procesar.
- pushOpc(): Empujar la pila.
- pushOpc(): Procesar texto a opciones.
- procCampo(): Obtener opciones para hijos.
- procCampo(): Obtener tipo como texto directo o nada.
- procCampo(): Si tipo no indicado, usa opciones.
- procCampo(): Si tipo desconocido, produce error.
- procCampo(): Agregar nodo según tipo "sección", "campo", "largo", "título" y "subtítulo".
- procCampo(): Si valor es vacío, no agregar.
- procCampo(): Si valor es vacío, comportarse según
:mostrar. - procCampo(): Agregar nodo según tipo "imagen" (sin demás opciones).
- procCampo(): Si tipo imagen, comprueba que imagen exista (en cuyo caso convierte en imagen), o reprocesa según variable "img_def".
- procCampo(): Toma img_def del tipo, o de las opciones heredadas.
- dameNombre(): Si es vacío, comprueba (no hace nada) opción
:nombrardel elemento, y sino en opciones heredadas. - dameNombre(): Al comprobar
:nombrar, modifica comportamiento. - dameNombre(): Si no tiene enlaces, comprueba opción
:enlazardel elemento, y sino en opciones heredadas. - dameValor(): Si es vacío, comprueba opción
:defdel elemento, y sino en opciones heredadas. - dameValor(): Si no es vacío, añade
:sufijo. - dameValor(): Si no es vacío, añade
:prefijo. - dameHijos(): Obtiene texto directo o nada.
- dameHijos(): Crea tabla con elementos separados por coma, y elimina espacios al comienza y fin de cada uno (trim). A cada elemento le asigna el valor
reglacon su mismo nombre. - procCampo(): Llamar a procCampo() con el nombre de cada hijo de dameHijos(), y el elemento para que se agreguen.
- procCampo(): Si es imagen y hay nombre, lo añade como descripción de la imagen.
- procCampo(): Si es imagen, comprueba opción
:tamaño, o busca en opciones heredadas. - dameClases(): Obtiene el texto directo de
:claseso nada. - dameEstilos():Obtiene el texto directo de
:estiloso nada. - dameClases(): Convierte texto en tabla.
- dameEstilo(): Convierte texto en tabla.
- dameAtributos(): Pega dameClases() y dameEstilos() para devolver los atributos en forma de texto HTML (
class="…" style="…"). - dameAtributos(): Por cada clase de cl=dameClases() busca en local clases, si la encuentra la elimina de cl.
- dameAtributos(): Antes de eliminar la clase de cl, agrega su texto en clases a variable local
e_cl. Luego agrega e_cl al comienzo de estilo. - procCampo(): Añade llaves como
:clase:nombre=valoren variable localclases - dameHijos(): Comprueba por cada elemento si es expresión regular.
- dameHijos(): Si es expresión regular, añade todos los parámetros que concuerden, pero en
reglamantiene la expresión regular. - Hacer Test cases.
- Incluir datos de WikiData.
- Hacer tutorial.
- Crear plantilla
{{Ficha de compuesto químico/zona de pruebas}}para probar.
Esta documentación está transcluida desde Módulo:Zona de pruebas/Eloy/Ficha fácil/doc.
Por favor, añade las categorías en la subpágina de documentación y los interwikis en Wikidata. Subpáginas de este módulo.
Por favor, añade las categorías en la subpágina de documentación y los interwikis en Wikidata. Subpáginas de este módulo.
local p = {}
local HtmlBuilder = require('Module:HtmlBuilder')
local args = {raiz={hijos={}},otro={hijos={}}}
local root
local opc = {}
local opcs = {}
local dbg = ''
local function htmlize(s)
return tostring(s):gsub('&', '&'):gsub('<', '<'):gsub('>', '>')
end
--! Convierte una tabla en lista HTML
local function table_out(t)
if(type(t)~='table') then return tostring(t) end
local x = '<ul>'
for k,v in pairs(t) do
x = x .. '<li><b>' .. htmlize(tostring(k)) .. '</b> ' ..htmlize(tostring(v))
if(type(v)=='table') then x = x .. '['..tostring(#v)..']' .. table_out(v) end
x = x .. '</li>\n'
end
return x..'</ul>'
end
--! \brieg Tira opciones
--! Tira las últimas opciones guardadas y las guarda como actuales,
--! descartando las que eran actuales hasta ese momento.
local function popOpc()
local o = opcs[#opcs]
table.remove(opcs,#opcs)
opc = o
return opc
end
--! \brief Obtiene el wikitexto para el nombre del campo.
--! Si no está definido, y está la opción auto:nombrar, toma como nombre a mostrar el nombre interno.
--! Si auto:nombrar es 2, pone mayúscula a la primera letra.
--! Si auto:enlazar está activado, y el nombre no contiene enlaces, se añade [[…]]
local function dameNombre(nom)
--! \todo Todo.
return args[nom..':nombre']
end
--! \brief Obtiene el wikitexto para el valor del campo.
--! Si no está definido, y está la opción auto:valorar, toma el valor del parámetro de mismo nombre.
--! Si no está definido, toma el valor de <*>:def, que puede hacer referencia a WikiData.
--! Si está definido, agrega si existen los valores <*>:prefijo y <*>:sufijo
--! Como parámnetro vacío se convierte en nil, en los demás debería haber diferencia
local function dameValor(nom)
--! \todo Todo.
return args[nom..'valor']
end
--! \brief Obtiene el tipo de campo en formato de texto.
--! Si no está definido, usa la opción hijo:tipo
local function dameTipo(nom)
--! \todo Todo.
return args[nom..':tipo']
end
--! \brief Convierte los parámetros en un árbol (usando : para separar hijos).
--! Por ejemplo, dada la siguiente lista de argumentos
--! :hijos=uno,dos
--! uno:nombre=Uno
--! uno:hijos=tres
--! dos:valor=2
--! tres:nombre=Tres
--! Produciría la siguiente tabla
--! args={
--! raiz={
--! hijos={
--! hijos={valor='uno,dos'}
--! }
--! },
--! otro={
--! hijos={
--! uno={
--! hijos={
--! nombre={valor='Uno'},
--! hijos={valor='tres'}
--! }
--! },
--! dos={
--! hijos={
--! valor={valor='2'}
--! }
--! },
--! tres={
--! hijos={
--! nombre={valor='Tres'}
--! }
--! }
--! }
--! }
--! }
local function dameArg(l,n)
local este
local bl=(n==nil) or (#n==0)
if bl then return l.raiz end
if (n:sub(1,1) == ':') then
este = l.raiz
else
este = l.otro
end
for i in string.gmatch(n,"[^:]+") do
este = este.hijos
if(este[i] == nil) then
este[i] = {valor=nil,hijos={}}
end
este = este[i]
end
return este
end
--! \brief Empuja opciones
--! Guarda las opciones actuales en opcs, y las modifica incorporando las nuevas opciones
local function pushOpc(nom)
-- Guarda las opciones actuales
table.insert(opcs,mw.clone(opc))
-- Obtiene las nuevas opciones
local nuevas = dameArg(args,(nom or '')..':hijos')
if(nuevas.hijos == nil) then nuevas.hijos={} end
-- Por cada una de ellas, sobreescribe el valor en
for k,v in pairs(nuevas) do
opc.otro.hijos[k] = mw.clone(v)
end
return opc
end
--! \brief Devuelve una opción, buscándola primero en el objeo y luego en las opciones.
local function dameOpc(nom,op,def)
local x=dameArg(args,nom..':'..op)
if(x == nil) then x=dameArg(opc,op) end
if(x ~= nil) then x=x.valor end
if(x == nil) then return def else return x end
end
local function sumaA(l,t,a)
local x=''
local s=''
if (l ~= nil) and (#l>0) then
for k,v in pair(l) do
if(v~=nil) and (#v>0) then
x=x..s..tostring(v)
s=t
end
end
end
if (#x>0) then
x=' '..a..'="'..x..'"'
end
return x
end
--! \brief Procesa un campo según su nombre interno. Devuelve código html en caso de ser visible, nil en caso de no haber nada.
local function procCampo(nom)
dbg = dbg .. '<ul><li>procCampo(' .. tostring(nom) .. ',' .. tostring(r)..'):</li>\n'
-- Toma la opción mostrar
local mostrar = dameOpc(nom,'mostrar',1)
--if (mostrar == nil) then mostrar = 1 end
-- Si mostrar es 0 termina sí o sí.
if (mostrar == 0) then return nil; end
dbg = dbg .. '<li>130</li>'
-- Toma el nombre del campo, todavía usando las opciones del campo padre
local nombre = dameNombre(nom)
-- Toma el valor del campo, todavía usando las opciones del campo padre
local valor = dameValor(nom)
-- Toma el tipo del campo, todavía usando las opciones del campo padre
local tipo = dameTipo(nom)
--! \todo ¿Es sección?
local es_secc = true
dbg = dbg .. tostring(nombre)..','.. tostring(valor)..','.. tostring(tipo)..','.. tostring(es_secc)..','.. tostring(mostrar)..','.. ''
-- Si mostrar es 1 y no hay valor ni es sección, termina (no lo muestra).
if (mostrar == 1) and (valor == nil) and (not es_secc) then return nil; end
dbg = dbg .. '<li>143</li>'
local html = ''
if(es_secc) then
-- Actualiza las opciones para sus campos hijos
pushOpc(nom)
-- Procesa hijos
local i=0
local H = dameArg(args,nom .. ':hijos')
dbg = dbg .. '<li>H=' .. table_out(H) ..'</li><li>h[]=<ul>'
if (next(H or {})~=nil) then
for h in string.gmatch(H.valor or '',"[^,]+") do
dbg = dbg .. '<li>h=' .. table_out(h) ..'</li>'
local r = (procCampo(h) or '')
dbg = dbg .. '<li>r=' .. table_out(r) ..'</li>'
html = html .. r
i = i+1
end
end
dbg = dbg .. '</ul></li>'
-- Devuelve las opciones a su estado anterior
popOpc()
-- Si tenía hijos, pero no muestra nada, termina
dbg = dbg .. '<li>157: i='..tostring(i)..', #html='..tostring(#html)..'</li>'
if (i>0) and (#html<1) then return nil end
end
X={
[0]={s='',d='',H='',R='',D=''},
[1]={s='</tr>\n<tr>',d=' colspan="2"',H='',R='',D=''}
}
Y={
['campo'] ={0,nombre,valor},
['largo'] ={1,nombre,valor},
['título'] ={1,valor, nil, 'cabecera'},
['subtítulo']={1,nil, valor}
}
Y=Y[tostring(tipo)] or Y.campo
dbg = dbg .. '<li>Y='..table_out(Y)..'</li>'
X=X[Y[1] or 0]
clases = dameOpc(nom,'clases')
estilo = dameOpc(nom,'estilo')
--! \todo Quitar clases especiales de "clases" y poner su correspondencia en estilo
X.R='<tr'..sumaA({Y[4],clases},';','class')..sumaA({Y[5],estiloC,estilo},';','style')..'>'
if(Y[2] ~= nil) then
clases = dameOpc(nom,'nombre:clases')
estilo = dameOpc(nom,'nombre:estilo')
X.H = '<th'.. X.d .. sumaA({Y[6],clases},';','class') .. sumaA({Y[7],estiloC,estilo},';','style') ..'>'..Y[2]..'</th>'
end
if(Y[3] ~= nil) then
clases = dameOpc(nom,'valor:clases')
estilo = dameOpc(nom,'valor:estilo')
X.D = '<td'.. X.d .. sumaA({Y[8],clases},';','class') .. sumaA({Y[9],estiloC,estilo},';','style') ..'>'..Y[3]..'</td>'
end
if (X.s ~= nil) and ((Y[2]==nil) or (Y[3]==nil)) then
X.s = ''
end
dbg = dbg .. '<li>X=<ul>'..table_out(X)..'</ul>.</li>\n'
html = X.R..X.H..X.s..X.D..'</tr>'..html
dbg = dbg .. '<li>html='..tostring(html)..'.</li>\n'
dbg = dbg .. '<li>:procCampo().</li></ul>\n'
return html
end
--!
local function procArgs(a)
for k,v in pairs(a) do -- Por cada parámetro
este = dameArg(args,k)
este.valor = mw.clone(v)
end
end
function p.infobox(frame)
opc={
[':enlazar']=0
}
local a
-- if frame == mw.getCurrentFrame() then
-- a = frame:getParent().args
-- else
a = frame.args
-- end
if true then
-- return type(a)..table_out(a)
end
procArgs(a)
opc={otro={hijos=mw.clone(dameArg(args,':hijos').hijos)}}
--! \todo Procesar clases especiales
--! \todo root.addClass(…).cssText(…)
--return tostring(args[':hijos'])
root=procCampo('')
return (root or 'nil')..dbg..'<hr><ul><li>frame='..table_out(frame)..'</li><li>frame:getParent()='..table_out(frame:getParent())..'</li><li>a['..tostring(#a)..']='..table_out(a)..'</li><li>args['..#args..']='..table_out(args)..'</li><li>opc['..#opc..']='..table_out(opc)..'</li></ul>\n'
end
return p