Generación de páginas Web usando XSLT y XML

J. J. Merelo

Al igual que XML, XSLT es un lenguaje de programación. Forma parte de la trilogía transformadora de XML, compuesta por las CSS (Cascading Style Sheets, hojas de estilo en cascada), que permite dar una apariencia en el navegador determinada a cada una de las etiquetas XML; XSLT (XML Stylesheets Language for Transformation , o lenguaje de transformación basado en hojas de estilo); y XSL:FO, (Formatting Objects, objetos de formateo), o transformaciones para fotocomposición, o, en general, para cualquier cosa que no sea XML, como por ejemplo HTML "del viejo" o PDF (el formato de Adobe).

XSLT es pues, un lenguaje que se usa para convertir documentos XML en otros documentos XML; puede convertir un documento XML que obedezca a un DTD a otro que obedezca otro diferente, un documento XML bien formado a otro que siga un DTD, o, lo más habitual, convertirlo a "formatos finales", tales como WML (usado en los móviles WAP) o XHTML.

Los programas XSLT están escritos en XML, y generalmente, se necesita un procesador de hojas de estilo, o stylesheet processor para procesarlas, aplicándolas a un fichero XML.

El estilo de programación con las hojas XSLT es totalmente diferente a los otros lenguajes a los que estamos acostumbrados (tales como C++ o Perl), pareciéndose más a "lenguajes" tales como el AWK, o a otros lenguajes funcionales, tales como ML o Scheme. En la práctica, eso significa dos cosas:

• No hay efectos secundarios. Una instrucción debe de hacer lo mismo cualquier que sea el camino de ejecución que llegue hasta ella. O sea, no va a haber variables globales (¡Cielos!), ni bucles en los que se incremente el valor de una variable, o tenga un test de fin de bucle, ni nada por el estilo. En realidad, esto no es tan grave, y se puede simular usando recursión, como se verá.
• La programación está basada en reglas: cuando ocurre algo en la entrada, se hace algo en la salida. En eso, se parece al AWK, o a cierto estilo de programación en PERL, pero no en el resto de las cosas. Al fin y al cabo, no hay efectos secundarios.

En resumen, programar con las hojas XSLT (en inglés se les llama stylesheets o logicsheets) puede ser un poco frustante, pero cuando uno aprende a usarlas, no puede vivir sin ellas. En realidad, son la única alternativa cuando uno quiere adaptar un contenido descrito con XML a diferentes clientes (por ejemplo, móviles de diferente tamaño, diferentes navegadores), y la mejor alternativa cuando uno quiere procesar documentos XML (aunque haya otras: filtros SAX, expresiones regulares...). Otra alternativa, sobre todo si se está trabajando ya con un documento XML en forma de DOM (Document object model) es trabajar directamente sobre él. En este claso, de todas formas, se pueden usar transformaciones XSL, sólo que se aplicarán en memoria, en vez de leerlas desde un fichero.

Lo que consiguen las hojas de estilo es separar la información (almacenada en un documento XML) de su presentación, usando en cada caso las transformaciones que sean necesarias para que el contenido aparezca de la forma más adecuada en el cliente. Es más, se pueden usar diferentes hojas de estilo, o incluso la misma, para presentar la información de diferentes maneras dependiendo de los deseos o de las condiciones del usuario.

Aparte del hecho habitual de procesar documentos XML, XSLT es un lenguaje de programación, y por tanto se podría hacer cualquier cosa con ellas; incluso calcular la célebre criba de Eratóstenes o ejecutar un algoritmo genético. Pero a nosotros nos va a interesar más como simple herramienta de transformación de XML.

Actualmente hay varias versiones del estándar XSLT: la versión 1.0, que es la que implementan la mayoría de los procesadores, y se denomina "recomendación", es decir, para el consorcio W3, lo equivalente a un estándar, y la versión 2.0 , que, a fecha de 4 de noviembre del 2004, es un "working draft", o borrador de trabajo, que es el paso previo a un estándar. Algunos procesadores, tales como el Saxon, implementan ya esta última versión. Hay algunas diferencias importantes: el tratamiento uniforme de los árboles (técnicamente, se pueden convertir fragmentos de árboles de resultados en nodesets), uso de múltiples documentos de salida, y funciones definidas por el usuario que se pueden definir en XSLT, y no sólo en Java u otro lenguaje, como sucedía en estándares anteriores. .

Para Windows, en sus diferentes versiones, hay dos herramientas que permiten editar XML y hojas de estilo XSLT, y aplicar directamente la una a la otra. Una de ellas es XMLSpy, que tiene un IDE muy bonito, pero que casca con relativa frecuencia. De hecho, he sido incapaz de aplicar una hoja de estilo a un documento XML. Otra opción es usar eXcelon Stylus, un peaso de programa, pero que sólo está disponible para WindowsNT/2000 (y no sé si XP); la versión 3.0 beta es gratuita para desarrolladores.

En realidad, para editar XML y XSLT no hace falta ningún editor especial, pero viene bien un editor de XML o incluso un entorno integrado que te ayude a indentar bien el código, e incluso a cerrar las etiquetas en el orden correcto, o te saque la etiqueta y atributos admisibles en cada momento en función del DTD. En ese sentido, si se trabaja en Windows, el mejor es el eXcelon Stylus; en Linux, se puede uno apañar bien con el XEmacs (que te valida usando un DTD, si es necesario).

Este tutorial no pretende ser una introducción exhaustiva al XML, en realidad, para los efectos de este tutorial, hay que saber poco XML: sólo que hace falta emparejar bien las etiquetas, y la estructura de árbol que sigue un documento XML (es lo que se denomina XML bien formado). En realidad, HTML se puede definir como un documento bien formado, de hecho, la última versión de HTML, XHTML, también lo es, o sea que no es un salto grande pasar de WML/XHTML a XML. En todo caso, los que quieran saber un poco más sobre el tema, pueden consultar los diferentes tutoriales del curso GeNeura de XML.

Ejercicios
1. Crear un documento XML que describa una ficha de alumno. Tiene que tener una etiqueta raíz (por ejemplo, acta), una etiqueta por cada alumno, y dentro de ellas, etiquetas para el DNI, nombre, apellidos y nota.

Hay muchas formas de usar las hojas de estilo. Lo más normal es usarlas dentro de un entorno de publicación tal como el Cocoon, o el IBM Transcoding Publisher, AxKit u otros por el estilo. Un entorno de publicación de XML permite mantener sitios completos basados en XML, y generar páginas en diferentes formatos a partir de ellos. En general, recomendamos Cocoon, que es una herramienta gratuita y Open Source basada en Java, y además una de las más avanzadas en el sector. Para una solución profesional, es mejor el IBM TP, pues forma parte del servidor de aplicaciones WebSphere, y cuenta con interfaz gráfico avanzado; el problema es el coste.

En muchos casos, lo que se necesita es aplicar hojas de estilo dentro de una aplicación, o usarlas desde línea de comandos a partir de otra aplicación o otro lenguaje de programación. En ese caso, lo más útil es usar un procesador de hojas de estilo, que habitualmente se encuentra en conjunción con un parser XML, con o sin validación. De estos, hay los siguientes:

• Xalan, que será el que más usemos en este tutorial, y que además es gratuito. La versión actual es la 2.6. Es una herramienta escrita en Java, y lo único que se necesita para hacerla funcionar es una máquina virtual Java (JVM), tal como la de Microsoft, Sun o IBM. Xalan necesita un parser XML para funcionar, tal como el Xerces, aunque el fichero correspondiente (xerces.jar) viene incluido en la distribución.
• Saxon, un procesador bastante rápido, también escrito en Java, con su propio parser incluido, aunque se puede usar uno externo. Hay una versión denominada Instant Saxon, un procesador rápido, y fácil de usar, sólo para Windows. Por lo pronto, es el único que implementa la versión 2.0 de XSLT.
• Hay otros muchos procesadores, tales como el XT de James Clark, xsltproc o el Sablotron. Todos ellos y muchos más se pueden encontrar en la página de procesadores XSLT de XMLSoftware.com. En Linux recomiendo el xsltproc, basado en la librería XML/XSL de gnome; es muy rápido, es un ejecutable y no hace falta instalar Java para usarlo.
• A su vez, los procesadores de hojas de estilo se pueden usar como librerías de clases, o desde otros lenguajes. Por ejemplo, el módulo XML::XSLT para Perl. Estos módulos se pueden usar para poder trabajar con XSLT fuera de entornos de publicación, como por ejemplo un servidor web normal. xalan es en realidad una librería que se puede usar también desde programas en Java.
• Algunos navegadores también lo implementan, o lo harán en el futuro. En concreto, el Mozilla debería incluirlo a partir de la versión 0.9; desde la versión 0.7 se podía incluir un plugin llamado TransforMiiX, que teóricamente aplica XSLT. En realidad, casi todos los navegadores modernos, con mayor o menor fortuna, lo incluyen. Firefox, por ejemplo, lo toma sin problemas.

Finalmente, para este curso, se puede usar un formulario simple que aplica hojas de estilo XSLT a documentos XML usando Perl: aplicador de hojas de estilo.

Para empezar, vamos a tratar de presentar una hoja XML de lo más simple (tienda0.xml):

Este ejemplo lo iremos extendiendo hasta que contenga un catálogo de una tienda virtual. Por lo pronto incluimos solamente datos básicos sobre la tienda.

Para convertirlo en HTML, usaremos la siguiente hoja de estilo (tienda-html.xsl): 1 <?xml version="1.0" encoding="UTF-8"?> 3 <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 5 <xsl:template match='/'> 6 <html> 7 <head><title>Generado con tienda-html.xsl</title></head> 8 <body> 9 <h1> <xsl:apply-templates /> </h1> 10 </body> 11 </html> 12 </xsl:template> 13 </xsl:stylesheet>

Tal como está, se puede cargar directamente con Firefox, que mostrará algo similar a la imagen. Asimismo se puede usar cualquier entorno integrado que incluya la posibilidad de hacer transformaciones, como el XMLShell o XMLSpy mencionados anteriormente.

Para procesarlo con el Xalan, tendremos que hacer lo siguiente:

1. Añadir la máquina virtual Java al PATH: unix$ export PATH=$PATH:/usr/bin/java (o donde quiera que esté)
2. Añadir al CLASSPATH los .jar (ficheros de librería) que incluyen Xerces (el parser de XML) y Xalan (el procesador de XSLT): unix$ export CLASSPATH=$CLASSPATH:/usr/local/xalan/bin/xalan.jar:/usr/local/xalan/xerces.jar (o donde quiera que estén)
java org.apache.xalan.xslt.Process -IN tienda0.xml -XSL tienda-html.xsl -OUT tienda.html.

Esto debería dar como resultado algo como lo que hay en esta página web.

El saxon es otro procesador de hojas de estilo, que está disponible como un fichero .jar, y que por tanto se puede ejecutar en cualquier plataforma. Para usarlo, se escribe (después de definir el camino a la máquina virtual Java y al .jar correspondiente):

El Instant Saxon es una versión de Saxon que ocupa poco y es relativamente fácil de usar. Hay que tener instalada una máquina virtual Java en Windows para que funcione; si tenemos instalado el Internet Explorer, con eso vamos que ardemos. Una vez instalado el explorer, basta escribir:

Que nos dará el mismo resultado que anteriormente, con un poco de suerte.

También se puede usar el script en geneura, editando los ficheros anteriores y cortándolos y pegándolos en el sitio adecuado. Este script usa dos librerías de Perl: XML::LibXML y XML::LibXSLT, que a su vez están basadas en las librerías de Gnome LibXML2 equivalentes.

Para empezar, el código del documento XML contiene una etiqueta, tienda, que incluye otras dos etiquetas, nombre y telefono, que contienen el texto que queremos que aparezca en la página web. En el resto, la primera línea simplemente describe que el resto del documento es XML, y asocia la hoja de estilo XSLT (tienda0.xsl) al documento. Esta segunda línea se usa en entornos de publicación tales como el cocoon; algunos procesadores de XSLT la usan para tomar el nombre de la hoja de estilo que se va a usar; también lo suelen usar navegadores como el Mozilla/Netscape/Firefox o el Internet Explorer. Cada una de estas etiquetas se denominan elementos; y en principio, un documento puede tener tantas etiquetas como queramos.

El XML original, como se ve, es simplemente XML bien formado, no usa un DTD ni lo necesita: basta con que haya una etiqueta raíz (tienda, en nuestro caso), las etiquetas estén emparejadas correctamente y los atributos entre comillas. Diferentes documentos XML podrían ser procesados con la misma hoja de estilo, y darían diferente resultado. Ahora mismo, tal como está, un documento XML tiene asociada una sola hoja de estilo XSLT, y para ese viaje no hacen falta alforjas, salvo por el hecho de que muchos documentos XML pueden tener la misma hoja XSL y de esa forma mantener una apariencia común. También se verá más adelante la forma de que el procesador XSLT seleccione diferentes hojas XSLT dependiendo de las circunstancias (principalmente, el cliente).

La primera hoja de estilo con la que nos enfrentamos es relativamente simple. El "esqueleto" es un documento HTML normal, al cual tenemos que añadir "contenido dinámico", es decir, contenido generado a partir del XML original. Para hacernos una idea, en este caso simple, una hoja XSLT es como una plantilla sobre la que se cambian los contenidos por sus valores al aplicarla. En realidad, tendríamos que pensar en una hoja XSLT con en un jardinero que va podando árboles, partiendo de la raíz. Al llegar a una rama, hace algo con ella: la poda, inserta otra cosa, o simpelemente la deja tal cual; el árbol, en este caso, es realmente el árbol DOM del documento XML que está tratando.

Para empezar, se incluyen una serie de instrucciones, de la línea 1 a la 5: no son instrucciones en sí, sino que modifican el aspecto de la salida. La primera declara el documento XML y el tipo de codificación (que podría ser ISO-8859-1 en vez de UTF-8 si quisiéramos incluir acentos y demás caracteres idiosincráticos) y la segunda es la etiqueta raíz de la hoja de estilo (cerrada en la última línea; recordemos que una hoja de estilo XSL es también un documento XML y por tanto tiene que seguir todas sus convenciones), que declara la versión de XSLT que se está usando y el espacio de nombres (namespace) que vamos a usar, es decir, el prefijo que usarán todas las instrucciones propias de XSLT; en este caso, usamos xsl, pero cambiando esta instrucción podríamos usar otro cualquiera.

Ese esqueleto está organizado en "templates", que son partes de la hoja que se "disparan" cuando encuentran una etiqueta que corresponda a lo que hay en su atributo match. El primer y único template comienza en la línea 5, y, en este caso, el template que corresponde a la etiqueta raíz genera un esqueleto de página HTML. La "orden" en la línea 9 cede el control a los otros templates, es decir, trata de aplicar todos los demás templates que haya en el documento, incluyendo el resultado de aplicarlos precisamente en ese punto (es decir, entre las etiquetas h1. En este caso no hay más templates, salvo los llamados los templates por defecto, que lo único que hacen es incluir el contenido de las etiquetas en el documento de salida. Es decir, en la práctica lo que hemos hecho es decirle dónde tiene que incluir en el esqueleto los valores del documento original, sin procesarlos más.

La orden <xsl:apply-templates /> podría haberse sustituido, en este caso, por <xsl:value-of select='tienda' /> y habría tenido exactamente el mismo efecto, es decir, incluir el contenido de la etiqueta tienda (y todas las que descienden de ella).

Ejercicios
1. Crear un documento con otra etiqueta raíz, por ejemplo zzzxxx, y ver qué efecto tiene en la salida .
2. Crear un documento con varias etiquetas, con diferentes niveles de anidación, y aplicar la hoja de estilo, para ver qué efecto tiene.

Vamos a ver algún documento XML algo más complicado; en concreto, vamos a tratar de procesar documentos XML que describen diferentes artículos de una tienda. Una tienda virtual está formada por diferentes productos, que a su vez tienen una serie de características: código de producto, tipo de artículo, sección. Una tienda virtual se describiría en un fichero como el siguiente tienda1.xml

Este se transforma con la siguiente hoja XSLT tienda1-html.xsl:

Esta hoja, a la que se le han suprimido los elementos comunes con la hoja anterior (comienzo y final), se compone de cuatro templates diferentes, mientras que la anterior tenía solamente uno. Cada template trata elementos de diferente profundidad dentro del árbol del documento XML: el primer template trataría la raíz, el segundo las ramas que descienden de él, y el tercer y cuarto ramas progresivamente más bajas.

Por eso el primer template simplemente incluye el código de apertura y cierre del documento HTML, y cede control al siguiente template, que trata la primera etiqueta, tienda, tal como aparece en el atributo match. En este template se incluyen dentro del patrón en HTML el nombre y al telefono, usando xsl:value-of, que simplemente incluye el contenido del elemento correspondiente. También se crea el esqueleto de una tabla en HTML (líneas 19 en adelante), con su cabecera, y cede control al siguiente template, que se encargará de cada uno de los productos; para que se procesen sólo las etiquetas de este tipo que desciendan de tienda, y no las otras (nombre, telefono), que ya están incluidas en la salida, se usa el atributo select (línea 21): con xsl:apply-templates select='producto' se aplicarán sólo los templates que correspondan a este elemento.

Ese template comienza en la línea 26 y crea el esqueleto de una fila, cediendo el control a los templates que traten con los descendientes. Hay un sólo template que lo hace, el que comienza en la línea 30; en vez de procesar un sólo tipo de elemento, procesa 3, y para ello usamos | para indicar que puede procesar cualquiera de ellos, incluyéndolos dentro de un demarcador de celda de tabla en HTML

El orden en el que se incluyen los elementos en la salida es el mismo en el que se encuentran en la entrada, es lo que se denomina orden de documento. Este orden se puede alterar usando etiquetas value-of adecuadamente y usando otros métodos, que veremos a continuación.

Ejercicios
1. Crear un documento para una clasificación de equipos de fútbol en XML, y transformarlo mediante XSLT en una tabla HTML, con cada equipo en una fila, diferentes valores (puntuación, goles a favor y en contra) en columnas, con el nombre del equipo en negrita.

El XML es infinito, y tiene muchas más cualidades. Para empezar, los elementos pueden tener atributos, que se añaden dentro de la etiqueta para cualificarla <elemento atributo1='valor1' atributo2='valor2' />; en este sentido, funciona igual que el HTML, pero los atributos tienen que ir siempre entre comillas (simples o dobles). De la misma forma, cuando un elemento se repite varias veces, y hay que hacer algo diferenciado con cada una de ellas, conviene tener a mano bucles. Ambas estructuras las pondremos en práctica sobre el siguiente ejemplo tiendecilla.xml (que se muestra incompleto, porque es un rato largo): <tienda>   <nombre>La tiendecilla  </nombre>   <telefono>953 87 12 23  </telefono>   <url etiqueta="URL: ">http://www.tiendecilla.es  </url>   <url prefijo="mailto:" etiqueta="Informacion: ">info@tiendecilla.es  </url>   <producto>   <codigo>92  </codigo>   <cantidad>10  </cantidad>   <articulo>Radio-Casette  </articulo>   <seccion>Electrónica  </seccion>   <marca>Sony  </marca>   <modelo>MKJ-800  </modelo>   <caracteristicas>       <linea>Auto-reverse      </linea>       <linea>Dolby-sorround      </linea>       <linea>Doble pletina      </linea>       <linea>Ecualizador de cinco bandas      </linea>       <linea>Garantía de 9 meses.      </linea>   </caracteristicas>   <precio moneda="euro">90  </precio>   </producto>   <producto>   <codigo>103  </codigo>   <cantidad>50  </cantidad>   <articulo>Reloj Cocina  </articulo>   <seccion>Electrónica  </seccion>   <marca>Kenwood  </marca>   <modelo>Blue ONE  </modelo>   <caracteristicas>       <linea>Varios diseños      </linea>   </caracteristicas>   <opciones nombre="color" tipo="unica">       <opcion valor="rojo"/>       <opcion valor="azul"/>       <opcion valor="blanco"/>   </opciones>   <opciones nombre="forma" tipo="unica">       <opcion valor="cuadrado"/>       <opcion valor="triangular"/>       <opcion valor="redondo"/>       <linea>Garantía de 6 meses.      </linea>   </opciones>   <precio moneda="euro">12  </precio>   </producto> <!-- Más cosas por aquí... --> </tienda>

Este catálogo lo podemos presentar directamente como un formulario HTML, usando la hoja de estilo siguiente: (tiendecilla-html.xsl; sólo están las líneas que difieren de los ejemplos anteriores)

En la línea 18 (la tercera del ejemplo) aparece la primera estructura nueva: xsl:for-each, que realiza un bucle sobre una serie de elementos que cumplan la condición que pone en el atributo select; en este caso, todos los elementos url que desciendan del contexto actual (estamos al nivel de la etiqueta tienda). En este atributo se puede incluir cualquier XPath que dé como resultado un node-set, y se ejecutará una vez por cada elemento del mismo. Por ejemplo, si pusiéramos <xsl:for-each select='producto'> se ejecutaría una vez por cada producto, exactamente a como se hace arriba con xsl:apply-templates (en realidad, para lo que sabemos en este punto del tutorial, son prácticamente iguales).

Justamente dentro del bucle usamos atributos; en realidad, forman parte de la definición de XPath y no tienen mucha historia: para usar un atributo, se le pone la arroba delante y punto. En este caso, se ponen las llaves alrededor para separar el atributo del valor del elemento que se está procesando (., en la línea 19). Las características y opciones se procesan de manera análoga: se ejecuta un bucle para cada uno de los subelementos, generando elementos de una lista en un caso, y opciones de un formulario en otro caso.

Ejercicios
1. Hacer el ejercicio anterior, usando atributos para alguna de las cantidades.

Si sólo se pudieran generar páginas estáticas, poco habríamos ganado con respecto al HTML; la gracia del binomio XML/XSLT es que se puede generar contenido diferente dependiendo de las entradas. Para ello debe haber alguna forma de pasarle parámetros a las hojas, y eso se hace, cómo si no, con la orden xsl:param. A la vez, teniendo en cuenta las entradas, habrá que tomar decisiones; o quizás dependiendo de los atributos. Cambiaremos la hoja de estilo anterior para que liste sólo productos de una sección, y tomaremos decisiones sobre qué poner dependiendo de los valores de atributos: ( tiendecilla-html-1.xsl; mostramos como de costumbre sólo las líneas relevantes)

Para usar esta hoja pasándole parámetros desde la línea de órdenes, habrá que hacerlo así (usando saxon):

o bien, usando Xalan (para más información, mirar las instrucciones

Si se usa la hoja de estilo dentro de un entorno de publicación tal como el Cocoon, habrá que pasarle los parámetros al documento XML, bien directamente desde el URL o desde un formulario, algo así: http://misitio.com/cocoon/tiendecilla.xml?seccion=Muebles. En Mozilla/Firefox y otros navegadores debería funcionar algo similar, pero no funciona. Si alguien encuentra como se hace, que avise.

En cualquier caso, el resultado será una página que incluirá solamente los productos correspondientes a una sección.

El truco para hacer esto está en los primeros templates. Para empezar, XSLT es bastante idiosincrático, y no puede recoger los parámetros que se le pasan a no ser que se declare un parámetro interno, y se le asigne el nombre. Este parámetro es similar a las variables de los lenguajes de toda la vida, salvo que no se le puede cambiar el valor: una vez que se le asigna uno al principio, se queda con él; el ámbito del parámetro será toda la hoja, y mientras se esté ejecutando. Eso se hace en la línea 5; posteriormente, en la línea 16 se usa el valor de la variable en una sentencia xsl:value-of; para acceder a su valor, se usa $seccion.

En la línea 27 se usan los predicados de XPath para seleccionar sólo aquellos nodos en los que el elemento seccion tenga el mismo valor que la variable; en este atributo se puede usar cualquier XPath, incluyendo este tipo de decisiones; conocer XPath y usarlo con sabiduría nos puede ahorrar un montón de código.

Para tomar decisiones (más que para seleccionar) un poco más complejas, con diferentes opciones, XSLT incluye las órdenes xsl:choose/xsl:when, que se usan conjuntamente (como el switch/case en C), tal como se ve en la línea 53. En este caso se usa para seleccionar diferente presentación, dependiendo del valor del atributo tipo; en caso de que sea "unica" usamos unos menuses, mientras que si es "si_no" usamos una "checkbox", que se pueda pulsar o no dependiendo de la opción.

Ejercicios
1. Cambiar la clasificación, de forma que se usen sólo los equipos que tengan una puntuación mayor que una dada, que se pase como parámetro.
2. Cambiar la clasificación, de forma que aparezcan en una tabla los tres primeros con un color, y los siguientes con un color diferente. Usar expresiones XPath para seleccionarlos o <xsl:number>; usar si es necesario una variable para establecer el color.

Un documento XML puede llevar asociadas diferentes hojas de estilo, y el propio sistema de publicación (tal como el cocoon) se encargará de seleccionarla dependiendo del navegador que use el cliente. Por ejemplo, se puede añadir esta línea a un fichero XML tal como este:

<?xml-stylesheet href="encuesta1-lynx.xsl" type="text/xsl" media="lynx"?>

En este caso, Cocoon usará la hoja de estilo encuesta1-lynx.xsl cuando el navegador sea el Lynx. Esta hoja de estilo está bastante más simplificada que la anterior, dando un código HTML más simple y visible en modo texto. En el Lynx, se vería como aparece en la imagen.

¿Qué ocurre si queremos sacar los resultados por orden alfabético, en vez del mismo orden que en el documento? Habrá que usar una nueva opción de apply-templates, sort. Por ejemplo, si queremos formatear el siguiente fichero XML (ordenar.xml):

<raiz>
  <cosa>Pepe  </cosa>
  <cosa>Juan  </cosa>
  <cosa>Enrique  </cosa>
  <cosa>Xabier  </cosa>
  <cosa>Aarón  </cosa>
</raiz>

Se puede hacer con la siguiente hoja de estilo (ordenar.xsl), de la cual extraemos solo las órdenes pertinentes:

11 <xsl:apply-templates select='cosa'> 12 <xsl:sort select='.' data-type='text'/> 13 </xsl:apply-templates><br />

El resultado se puede ver en el fichero ordenar.htm. En este caso, en vez de aplicar la orden apply-templates en un solo tag "vacío" (con el / al final) se aplica en forma de tag y antitag, con las opciones en medio. La opción xsl:sortsirve para ordenar, y como clave de ordenación se puede usar cualquier atributo, XPath, o en este caso, el contenido en sí de la etiqueta cosa. En la salida, saldrán ordenados, Aarón primero y Xabier el último. El atributo data-type sirve para indicar el criterio de ordenación,< code>text para texto y number para ordenación numérica.

Todavía se puede cambiar un poco más el sistema: a veces resulta que uno quiere procesar de forma diferente un elemento, dependiendo de la entrada. Meter decisiones puede ser un poco coñazo, así que el propio estándar XSL tiene la forma de hacerlo: usando modos, tal como se hace en la siguiente y bonita hoja de estilo (ordenar2.xsl):

En esta hoja de estilo se usa el atributo mode al llamar y al definir un template; los nombres que le hemos asignado son arbitrarios, pero lo que hacen es que, en caso de que se le pase como parámetro "verbose" imprimirá "nombre" delante del nombre de la persona; si no, lo imprimirá como antes. Para que funcione, se toma una decisión (a partir de la línea 14): en caso de que el modo sea "verbose", se llama al template usando como atributo de modo esa palabra; en otro caso, se llama al template "normal". Ese código tiene el efecto de que se llame a un template o a otro, según el modo que se haya elegido.

Pero claro, esto se puede resolver, en este caso, de una forma mucho más simple. ¿No sería ideal que se pudiera llamar a un template con parámetros, como si de una subrutina se tratara? Pues sí, se puede, tal como se hace en la hoja siguiente (ordenar3.xsl):

La principal diferencia con los dos anteriores está en la línea 14: la orden xsl:with-param hace que se llame al template con un parámetro determinado, cuyo nombre y valor queda establecido por los atributos. En este caso, estamos asignándole al parámetro miModo el mismo valor que el del parámetro modo (y por eso es innecesario, peor admitámoslo por mor de la pedagogía). Ese parámetro se recibe dentro del template con una sentencia similar a la que se usa para los parámetros globales: xsl:param; si el parámetro no se declara aquí, al principio del template, XSL no le hará ni puto caso.

Y ya dentro del template, usamos una decisión, como las que se han visto anteriormente, para imprimir el introito a cada nombre en caso de que el modo sea el adecuado. Y aquí paz y después gloria.

Ejercicios
1. Cambiar el programa de procesamiento del XML de los equipos de fútbol, de forma que salgan ordenados por orden de puntuación (se supone que el original puede estar desordenado), o por orden alfabético, dependido de un parámetro.
2. Añadir modos a la hoja de procesamiento de las quinielas, de forma que, en un modo, salga en forma de tabla, y en otro modo, en forma de lista ordenada.
3. Cambiar la hoja de procesamiento de las quinielas, de forma que cada fila aparezca con un color diferente.

Como era de esperar, el jefe no está contento; ya que el tema de las quinielas está agotado, vamos a por las encuestas. Y la encuesta hay que hacerla medianamente bien, poniendo diferentes elementos de formularios, y no dejando que el usuario conteste lo que le dé la gana. Usando el fichero encuesta2.xml, habría que aplicar la siguiente hoja (encuesta3.xsl): 61 <xsl:when test='@tipo="numero"'> 62 <tr> 63 <td colspan ='2' width="100%" bgcolor="white"> 64 <select name='numero'> 65 <xsl:call-template name='option-range'> 66 <xsl:with-param name='range' select='@rango'/> 67 </xsl:call-template> 68 </select> 69 </td> 70 </tr> 71 </xsl:when> 115 <xsl:template name='option-range'> 116 <xsl:param name='range' /> 117 <xsl:param name='i'>0</xsl:param> 118 <xsl:if test='$range != $i'> 119 <option><xsl:value-of select='$i' /></option> 120 <xsl:call-template name='option-range'> 121 <xsl:with-param name='range' select='$range'/> 122 <xsl:with-param name='i' select='$i+1'/> 123 </xsl:call-template> 124 </xsl:if> 125 </xsl:template> 126 </xsl:stylesheet>

Como siempre, aquí está la salida. Se han puesto las líneas que introducen elementos nuevos solamente.

La principal complicación de este tipo de problemas, que se resuelven fácilmente con un bucle for en cualquier lenguaje de programación pachanguero, en lenguajes funcionales pueden ser un poco más complicados. Por eso, muchos procesadores de XSL tienen extensiones que permiten hacer bucles convencionales, como veremos más adelante.

El principal problema es que, dado que no se pueden actualizar variables por la ausencia de efectos secundarios, no se puede crear un bucle que vaya comprobando el valor de una variable y actualizándolo en cada iteración. La única solución es sustituir los bucles clásicos por bucles recursivos, en los cuales se llama recursivamente a una subrutina (en este caso, template) hasta que se cumple una condición.

En este caso, vamos a incluir una etiqueta select y sus correspondientes option, una para cada uno de las opciones que haya. Y no tenemos más remedio que llamar a una rutina recursivamente. Eso se hace en la línea 65. En este caso en vez de dejar que los templates se disparen según los valores de una etiqueta, lo llamamos explícitamente con la orden xsl:call-template. Y dado que se trata de una especie de subrutina o procedimiento, hay que llamarlo también con sus correspondientes parámetros, para lo cual se usa xsl:with-param. Es decir, las siguientes órdenes

corresponderían en cualquier otro lenguaje de programación a option-range( range ).

De la misma forma, la "declaración" de un template es un tanto peculiar (línea 115):

<xsl:template name='option-range'> <xsl:param name='range' /> <xsl:param name='i'>0</xsl:param>

Esto correspondería a algo así como void function option-range(var range, var i=0), es decir, declaración de dos variables, una de las cuales tiene un valor por defecto, el 0, y otra sin valor por defecto, que tiene que ser dado por el usuario.

El resto de ese template, a partir de la línea 118, comprueba si el range es distinto al contador que usamos, i, y si lo es, imprime las etiquetas HTML, y vuelve a llamarse recursivamente, incrementando el contador. Cuando range y i sean iguales, la recursión para.

En este template se usan también variables, las que se pasan como parámetro. Las variables, aunque no lo son en el sentido clásico, se pueden actualizar dentro de un template, asignársele valor y pasar como parámetro a otros templates; para asignarles valor se puede usar esta construcción: