XSLT Mini COMO

01. Licencia

02. Objetivos

La información que hay en internet sobre XML y las aplicaciones que surgen sobre ella se están multiplicando rápidamente, pero para estar al día hay que doblegarse ante el inglés. Así que trataré de que este documento explique de forma clara y sencilla que es lo que a día de hoy XSLT ofrece.

Este mini como parte con un enfoque muy general del XML y profundiza rápidamente hacia los detalles del XSLT. Por ello recomiendo hacer una primera lectura rápida del mismo para comprender la estructura general, para más adelante estudiar las zonas de mayor interés para el lector. También pretendo que sirva como una guia de consulta rápida y para ese fin el índice enlaza con todas las tablas del documento.

03. Orientémonos en este mar de acrónimos

Lo primero que crea confusión al aprender XML es la cantidad de acrónimos que existen, vamos a tratar de sentar unas bases firmes en las que poder apoyar tanta sucesión de siglas.

Bien XML es, dejándonos de tecnicismos, un estándar que ha gustado mucho a la comunidad de desarrolladores y ha generado en tiempo récord innumerables herramientas basadas en este estándar. XML no es más que una forma ordenada de escribir un archivo de texto y tomando esto como base podemos utilizar las nuevas herramientas que se han desarrollado para poder maximizar la productividad del contenido que hemos ordenado.

Y una vez definida la base empecemos a enumerar que acrónimos existen a su alrededor, voy a agruparlos en 5 grupos: evolución, extensiones, herramientas, esquemas y formatos.

La "evolución" agrupa aquellos acrónimos que son los pasos previos del XML y algunos cambios posteriores a su primera definición.

Las "extensiones" son ampliaciones comúnmente utilizadas de las características propias del XML.

Las "herramientas" agruparían aquellas aplicaciones cuyo objetivo es facilitar y potenciar el trabajo con archivos XML. Cada una se especializa en un campo y algunas se apoyan en otras para poder crear cada vez herramientas más especializadas.

Los "esquemas" son un caso especial de "herramientas", todas ellas tienen como objetivo definir que estructura debe de cumplir un archivo XML para ser válido. Existe una gran diversidad de esquemas y por ello he definido un grupo a parte. La variedad de esquemas se debe a que ninguno es "el mejor" y posiblemente no pueda existir un esquema perfecto para todas las necesidades, así que por ahora cada cual tiene su favorito en función de las necesidades.

Si yo (con la carga subjetiva que ello conlleva) tuviese que destacar 3 esquemas elegiría: DTD, XML Schema y Relax NG.

DTD tiene su lugar garantizado porque ha sido utilizado durante mucho tiempo junto con el SGML, esta más orientado a contenido texto y por ello su soporte de tipos de datos es muy limitado, otra pega es que tiene su propia sintaxis que hay que aprender.

XML Schema resuelve los anteriormente citados inconvenientes del DTD, pero debido a su excesiva complejidad no ha terminado de convencer.

Relax NG es la evolución de los XML DTDs: sigue una definición de tipo gramática, es una aplicación XML, no necesita ser definido en el archivo XML origen, permite trabajar con tipos de datos, incluso importar tipos de forma sencilla, etc.

Los "formatos" agruparían aquellas aplicaciones XML cuyo objetivo es guardar un tipo de contenido, es al fin y al cabo un formato de archivo que aprovecha las ventajas del XML. Cada vez más programas utilizan el formato XML para guardar datos de configuración de la aplicación o incluso su formato original es XML.

04. Lo más básico del XML

Lo primero que debemos hacer es declarar que nos encontramos ante un archivo XML, para ello los cinco primeros caracteres del archivo deben ser: " <?xml ". Veamos que atributos puede tener, los opcionales están marcados en verde:

Voy a citar rápidamente las características básicas que un archivo XML debe cumplir para estar "bien formado". Si un archivo no esta "bien formado" al ser procesado dará un error y se detendrá el proceso.

Otra posible causa de errores de "mal formación" de archivos XML se debe a la utilización de símbolos reservados XML para fines diferentes a los que XML define. Para evitarlo deben ser sustituidos:

Por último, citar que existen 2 atributos definidos por XML, los cuales pueden utilizarse en cualquier elemento:

05. Sintaxis XPath

No es objeto de este mini como definir la sintaxis de XPath, pero como su utilización es ineludible voy a resumir sus puntos básicos, después con los ejemplos XSLT explicaré con mayor detalle cada punto. Téngase en cuenta que solo con un gran dominio sobre XPath es posible maximizar el rendimiento de XSLT.

XPath es un lenguaje no-XML que permite identificar partes de documentos XML. Para XPath un documento XML no es más que un árbol de nodos, existen 7 tipos de nodos:

Existen 3 tipos de operadores que podemos utilizar: matemáticos, boléanos y de expresiones.

Hasta ahora hemos visto las expresiones más comunes para moverse por el árbol de nodos, las cuales son iguales a las utilizadas para moverte por el sistema de ficheros Unix. Pero existen más expresiones y para utilizarlas deberemos utilizar la sintaxis no abreviada, denominada también como ejes:

06. Funciones XPath

XPath, además de lo que hemos visto hasta ahora, define 27 funciones que facilitan mucho el trabajo. Vamos a agrupar las funciones en 4 grupos:

07. Centrémonos en el XSLT

XSLT es una aplicación que define un lenguaje para modificar archivos XML. Este lenguaje precisa definir que transformaciones se quieren hacer y a que partes del documento. Para lo primero el propio XSLT define unos elementos, pero para lo segundo XSLT se basa en la sintaxis que define XPath. Por lo tanto XSLT es un lenguaje que va a definir que transformaciones vamos a realizar y cada vez que precisemos seleccionar un elemento a modificar utilizaremos XPath.

XSLT al ser una aplicación XML, se escribe en archivos XML y debe seguir todas las reglas que ello implica. Tendremos a nuestra disposición los elementos y funciones que define XSLT, la sintaxis y funciones propias de XPath e incluso podremos utilizar otras aplicaciones como XLink y XPointer.

Para conseguir realizar la modificación deberemos escribir una hoja de estilo explicando, con la sintaxis apropiada, que queremos que el procesador XSLT haga con el archivo XML. La hoja de estilo tiene la extensión 'xsl' y una vez definida funcionará con cualquier procesador XSLT escrito en cualquier lenguaje y ejecutado en cualquier entorno.

08. Puntos fuertes del XSLT

La gran ventaja del XSLT es la capacidad de transformar una única fuente de información en infinidad de formatos y de adaptar el contenido y la presentación para que se adapte a cualquier medio, ya sea visual, inalámbrico, físico, temporal, braille, etc... el límite lo pone la imaginación, o la necesidad.

Otra de las ventajas es que por fin permite separar el contenido de la presentación, pudiéndose modificar aspectos visuales fácilmente sin que los contenidos se vean mezclados en el proceso.

Permite reutilizar los datos contenidos en formato XML para otros fines diferentes al original.

09. Funciones XSLT

XSLT puede utilizar las funciones de XPath y además define 10 funciones propias. Vamos a utilizar el mismo sistema de agrupación que hemos utilizado antes:

Para la función 'format-number()' vamos a definir la simbología que podemos utilizar para definir el patrón:

A parte de estas funciones se pueden generar otras, llamadas funciones extendidas. Estas funciones pueden ahorrar mucho trabajo, pero debe saberse que se pierde compatibilidad de la hoja de estilo y posiblemente solo funcione en el procesador XSLT en el que fue desarrollada.

10. Elementos XSLT: atributos

Antes de empezar con los elementos XSLT voy a hacer hincapié en los posibles contenidos de un atributo, que como ya sabemos tiene que estar entre comillas:

11. Elementos XSLT: 'root'

La estructura básica de una hoja de estilo es la siguiente:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	...
</xsl:stylesheet>

El ejemplo 11.1 declara que nos encontramos ante un archivo XML y define un elemento root 'xsl:stylesheet' que contendrá toda la información sobre las transformaciones a realizar. El resto de la línea define el prefijo 'xsl' como el indicado para todos los elementos del lenguaje XSLT. En la siguiente tabla aparecen todos los atributos de este elemento, están señalados en verde los opcionales.

12. Elementos XSLT: 'top level'

Los elementos 'top level' son los únicos que pueden ser hijos de 'xsl:stylesheet'. Para facilitar su aprendizaje voy a mostrar los 12 elementos agrupados en 4 grupos:

13. Elementos XSLT: restantes

Ahora vamos a agrupar de igual modo los 21 elementos restantes que define XSLT:

14. Transformaciones: básicas I

Hasta ahora nos hemos limitado a citar de forma ordenada todas las herramientas que podemos utilizar, es hora de empezar a ver ejemplos. Cada vez que utilicemos un elemento nuevo explicaremos en una tabla todos sus posibles atributos, señalando los opcionales en verde. La hoja de estilo más sencilla que podemos definir contiene sólo el elemento 'xsl:stylesheet'.

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
</xsl:stylesheet>

Para poder utilizar esta hoja de estilo necesitamos un archivo XML a transformar. Supongamos que el ejemplo 14.2 contiene el listado de obras de una biblioteca:

<?xml version="1.0"?>
<biblioteca nombre="Biblioteca Municipal">
	<libro>Matemáticas</libro>
	<libro>Historia</libro>
	<revista>Ciencia</revista>
	<revista>OVNI</revista>
</biblioteca>

Si procesamos el documento XML 14.2 con la hoja de estilo 14.1 obtenemos el documento resultante 14.3:

<?xml version="1.0" encoding="UTF-8"?> 
Matemáticas
Historia
Ciencia 
OVNI

Con este ejemplo podemos ver que transformaciones por defecto realiza el procesador XSLT ante una hoja de estilo sin contenido: el documento resultante tiene una declaración XML con codificación UTF-8 y muestra el contenido de todas las etiquetas, pero no los nombres de la etiquetas ni sus atributos. Supongamos que el documento que queremos obtener sea un archivo mostrando como título el nombre de la biblioteca:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:template match="biblioteca">
		<xsl:value-of select="@nombre"/>
	</xsl:template>
</xsl:stylesheet>

En la hoja de estilo 14.4 hemos definido un elemento 'xsl:template' el cual contiene un modelo que se limita a un elemento vacío 'xsl:value-of'. El elemento 'xsl:template' se aplicará a los elementos que se llamen 'biblioteca', es este caso el elemento 'root'. El elemento 'xsl:value-of' con el atributo 'select' esta seleccionando el atributo 'nombre' como el valor a mostrar. Veamos las tablas de ambos elementos:

Si procesamos la nueva hoja de estilo obtendremos:

<?xml version="1.0" encoding="UTF-8"?>Biblioteca Municipal

¿Que ha pasado?. Realmente el proceso ha salido bien, pero no esta el listado que esperábamos obtener. Las transformaciones que el procesador XSLT realiza por defecto afectan a elementos que no estén definidos en la hoja de estilo, al definir que se debe hacer con el elemento 'biblioteca' los elementos hijos ya no sufren las transformaciones por defecto, salvo que se defina explícitamente que el contenido del elemento 'biblioteca' debe aparecer:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:template match="biblioteca">
		<xsl:value-of select="@nombre"/>
		<xsl:value-of select="."/>
	</xsl:template>
</xsl:stylesheet>

El contenido del elemento 'biblioteca' incluye todo el contenido entre las etiquetas, lo que incluye los hijos 'libro' y 'revista', el procesador transforma por defecto los elementos hijo mostrando su contenido:

<?xml version="1.0" encoding="UTF-8"?>Biblioteca Municipal
Matemáticas
Historia
Ciencia
OVNI

Ahora supongamos que queremos obtener un archivo de texto plano, es decir sin la declaración XML:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text"/>
	<xsl:template match="biblioteca">
		<xsl:value-of select="@nombre"/>
		<xsl:value-of select="."/>
	</xsl:template>
</xsl:stylesheet>

Hemos utilizado el elemento 'xsl:output' para definir que tipo de archivo resultante queremos. Este elemento es muy completo e iremos hablando de él a lo largo del mini como.

Con la hoja de estilo 14.8 obtenemos el listado que buscábamos:

Biblioteca Municipal
Matemáticas
Historia
Ciencia
OVNI

15. Transformaciones: básicas II

En el anterior capítulo hemos visto como hacer unas simples transformaciones con unos pocos elementos, pero para obtener resultados más interesantes deberemos utilizar más elementos. Pero antes definamos un documento XML más completo:

<?xml version="1.0"?>
<biblioteca nombre="Biblioteca Municipal">
	<datos>
		<publicos>
			<direccion>Calle Mayor, 54</direccion>
			<telefono>111222333</telefono>
			<fax>111222000</fax>
		</publicos>
		<privados>
			<personal cargo="Oficial Administrativo">Don Pedro</personal>
			<personal cargo="Técnico Superior de Biblioteca">Don Alberto</personal>
		</privados>
	</datos>
	<documentos>
		<libro paginas="1256">Matemáticas</libro>
		<libro paginas="345">Historia</libro>
		<revista paginas="54">Ciencia</revista>
		<revista paginas="90">OVNI</revista>
	</documentos>
</biblioteca>

En la próxima hoja de estilo vamos a definir varios modelos, de tal modo que unos llamen a otros y poder controlar mejor el resultado.

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text"/>
	<xsl:template match="biblioteca">
		<xsl:value-of select="@nombre"/>.
		<xsl:apply-templates select="documentos/*"/>
	</xsl:template>
	<xsl:template match="*">
		<xsl:value-of select="position()"/>. <xsl:value-of select="text()"/>.
	</xsl:template>
</xsl:stylesheet>

En esta hoja de estilo hay dos modelos: el primero afecta al elemento 'biblioteca' y el segundo a todos los elementos. Por prioridad se procesa el modelo que afecta a 'biblioteca' primero y este con el elemento 'apply-templates' llama a cualquier modelo que afecte a los elementos hijo de 'documentos'.

Dentro de 'documentos' existen dos tipos de elementos 'libro' y 'revista', ambos serán procesados con el segundo modelo. Este segundo modelo obtiene la posición del elemento con la función XPath 'position()', escribe un punto y un espacio, muestra el contenido de texto del elemento con la función XPath 'text()' y escribe otro punto. De este modo obtenemos este listado:

Biblioteca Municipal.
1. Matemáticas.
2. Historia.
3. Ciencia.
4. OVNI.

Hay otra forma de utilizar modelos y es llamándolos directamente. Vamos a utilizar esta forma para mostrar los datos de la biblioteca al principio del listado.

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text"/>
	<xsl:template match="biblioteca">
		<xsl:call-template name="titulo"/>
		<xsl:apply-templates select="documentos/*"/>
	</xsl:template>
	<xsl:template match="*">
		<xsl:value-of select="position()"/>. <xsl:value-of select="text()"/>.
	</xsl:template>
	<xsl:template name="titulo">
		<xsl:value-of select="@nombre"/>.
		Dirección: <xsl:value-of select="datos/publicos/direccion"/>.
		Tlf: <xsl:value-of select="datos/publicos/telefono"/>.
		Fax: <xsl:value-of select="datos/publicos/fax"/>.
	</xsl:template>
</xsl:stylesheet>

Vemos que hemos creado un nuevo modelo, pero este tiene un nombre definido con el atributo 'name'. Cuando en la hoja de estilo aparezca un elemento 'xsl:call-template' con un atributo 'name' con el mismo nombre se procesará su contenido.

Este método permite mostrar un contenido concreto en un punto exacto, y simplemente con hacer otra llamada al mismo modelo podemos mostrar el mismo contenido en varias zonas del documento resultante pudiendo ahorrar mucho código.

Biblioteca Municipal.
Dirección: Calle Mayor, 54.
Tlf: 111222333.
Fax: 111222000.
1. Matemáticas.
2. Historia.
3. Ciencia.
4. OVNI.

Añadamos un paréntesis a la lista especificando el número de páginas:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text"/>
	<xsl:template match="biblioteca">
		<xsl:call-template name="titulo"/>
		<xsl:apply-templates select="documentos/*"/>
	</xsl:template>
	<xsl:template match="*">
		<xsl:value-of select="position()"/>. <xsl:value-of select="text()"/>.
		(<xsl:value-of select="format-number(@paginas, '#,##0')"/> pags.)
	</xsl:template>
	<xsl:template name="titulo">
		<xsl:value-of select="@nombre"/>.
		Dirección: <xsl:value-of select="datos/publicos/direccion"/>.
		Tlf: <xsl:value-of select="datos/publicos/telefono"/>.
		Fax: <xsl:value-of select="datos/publicos/fax"/>.
	</xsl:template>
</xsl:stylesheet>

Hemos añadido una función XSLT 'format-number()' para que nos coloque la puntuación necesaria si el número de paginas es superior a mil. Veamos el resultado:

Biblioteca Municipal.
Dirección: Calle Mayor, 54.
Tlf: 111222333.
Fax: 111222000.
1. Matemáticas.
(1,256 pags.)
2. Historia.
(345 pags.)
3. Ciencia.
(54 pags.)
4. OVNI.
(90 pags.)

Lo ha hecho bien, pero siguiendo la puntuación anglosajona. Además sería más cómodo que el número de teléfono tuviese también algún tipo de formato. Para ello deberemos añadir lo siguiente:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="text"/>
	<xsl:decimal-format grouping-separator="."/>
	<xsl:decimal-format name="tel" grouping-separator="-"/>
	<xsl:template match="biblioteca">
		<xsl:call-template name="titulo"/>
		<xsl:apply-templates select="documentos/*"/>
	</xsl:template>
	<xsl:template match="*">
		<xsl:value-of select="position()"/>. <xsl:value-of select="text()"/>.
		(<xsl:value-of select="format-number(@paginas, '#.##0')"/> pags.)
	</xsl:template>
	<xsl:template name="titulo">
		<xsl:value-of select="@nombre"/>.
		Dirección: <xsl:value-of select="datos/publicos/direccion"/>.
		Tlf: <xsl:value-of select="format-number(datos/publicos/telefono, '#-##0', 'tel')"/>.
		Fax: <xsl:value-of select="format-number(datos/publicos/fax, '#-##0', 'tel')"/>.
	</xsl:template>
</xsl:stylesheet>

En esta hoja de estilo aparecen dos elementos 'xsl:decimal-format', el primero no tiene atributo 'name' con lo cual se convierte en el formato por defecto. El segundo si tiene y sólo se aplicará cuando sea llamado expresamente. En la línea en la que se formatea el número de páginas sólo ha cambiado el patrón, sustituyendo la coma anglosajona por el punto. En las líneas en las que aparecen los números de teléfono se ha añadido la función 'format-number()' con un patrón distinto y utilizando el formato definido por el segundo elemento 'xsl:decimal-format'.

Veamos el resultado de la transformación:

Biblioteca Municipal.
Dirección: Calle Mayor, 54.
Tlf: 111-222-333.
Fax: 111-222-000.
1. Matemáticas.
(1.256 pags.)
2. Historia.
(345 pags.)
3. Ciencia.
(54 pags.)
4. OVNI.
(90 pags.)

16. Transformaciones: copiar y crear

Hasta ahora hemos visto como extraer y dar formato a cierta información contenida en un archivo XML y mostrarla en un documento de texto plano. Supongamos que se nos pide un documento XML, pero con ciertas modificaciones respecto al original (el mismo que hemos utilizado en el capítulo anterior).

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:template match="biblioteca">
		<xsl:copy/>
	</xsl:template>
</xsl:stylesheet>

Con esta hoja de estilo vamos a copiar el elemento 'biblioteca' utilizando el elemento 'xsl:copy'.

Veamos el resultado:

<?xml version="1.0" encoding="UTF-8"?><biblioteca/>

Hemos obtenido un documento XML y hemos copiado el elemento 'biblioteca', pero no su contenido. Supongamos que queremos obtener una copia del documento original, pero sin los datos privados.

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:template match="biblioteca">
		<xsl:copy>
			<xsl:copy-of select="datos/publicos"/>
			<xsl:copy-of select="documentos"/>
		</xsl:copy>
	</xsl:template>
</xsl:stylesheet>

Con esta hoja de estilo copiamos el elemento 'biblioteca' y dentro hacemos una copia completa de los elementos que nos interesan con el elemento 'xsl:copy-of'.

Aquí tenemos el resultado:

<?xml version="1.0" encoding="UTF-8"?><biblioteca><publicos>
<direccion>Calle Mayor, 54</direccion>
<telefono>111222333</telefono>
<fax>111222000</fax>
</publicos><documentos>
<libro paginas="1256">Matemáticas</libro>
<libro paginas="345">Historia</libro>
<revista paginas="54">Ciencia</revista>
<revista paginas="90">OVNI</revista>
</documentos></biblioteca>

Hemos obtenido la copia, pero hay dos pegas. La primera es que la copia no es tan clara como el original (una etiqueta por línea), pero como nos encontramos ante un documento XML esto no influye en absoluto. La segunda es que el elemento 'datos' no se ha copiado. Una posible solución a ambas pegas sería:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" indent="yes"/>
	<xsl:template match="biblioteca">
		<xsl:copy>
			<xsl:element name="datos">
				<xsl:copy-of select="datos/publicos"/>
			</xsl:element>
			<xsl:copy-of select="documentos"/>
		</xsl:copy>
	</xsl:template>
</xsl:stylesheet>

Veamos el nuevo resultado:

<?xml version="1.0" encoding="UTF-8"?>
<biblioteca>
<datos>
<publicos>
<direccion>Calle Mayor, 54</direccion>
<telefono>111222333</telefono>
<fax>111222000</fax>
</publicos>
</datos>
<documentos>
<libro paginas="1256">Matemáticas</libro>
<libro paginas="345">Historia</libro>
<revista paginas="54">Ciencia</revista>
<revista paginas="90">OVNI</revista>
</documentos>
</biblioteca>

Ya hemos solucionado las dos pegas anteriores, pero ahora que se ve claro nos damos cuenta de que al elemento 'biblioteca' le falta el atributo 'nombre'. Y además deberíamos avisar de que este documento es una copia y que en poco tiempo estará desactualizado.

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" indent="yes"/>
	<xsl:template match="biblioteca">
		<xsl:copy>
			<xsl:attribute name="nombre">
				<xsl:value-of select="@nombre"/>
				<xsl:text> (Listado de 29-2-2002)</xsl:text>
			</xsl:attribute>
			<xsl:element name="datos">
				<xsl:copy-of select="datos/publicos"/>
			</xsl:element>
			<xsl:comment>Atención!!! Listado de 29-2-2002</xsl:comment>
			<xsl:copy-of select="documentos"/>
		</xsl:copy>
	</xsl:template>
</xsl:stylesheet>

Para añadir el atributo con el nombre de la biblioteca utilizamos el elemento 'xsl:attribute' y en su interior obtenemos con 'xsl:value-of' el nombre y le añadimos información extra con el elemento 'xsl:text'. Hasta ahora hemos añadido texto directamente a la hoja, pero para tener mayor control es preferible incluirlo dentro de un elemento 'xsl:text'. Por ultimo, hemos añadido una comentario con el elemento 'xsl:comment'.

Veamos el resultado final:

<?xml version="1.0" encoding="UTF-8"?>
<biblioteca nombre="Biblioteca Municipal (Listado de 29-2-2002)">
<datos>
<publicos>
<direccion>Calle Mayor, 54</direccion>
<telefono>111222333</telefono>
<fax>111222000</fax>
</publicos>
</datos>
<!--Atención!!! Listado de 29-2-2002-->
<documentos>
<libro paginas="1256">Matemáticas</libro>
<libro paginas="345">Historia</libro>
<revista paginas="54">Ciencia</revista>
<revista paginas="90">OVNI</revista>
</documentos>
</biblioteca>

El último elemento de este capítulo es 'xsl:processing-instruction' el cual simplemente define un nombre y un contenido, y los muestra una vez transformado entre '<? ... ?>'.

17. Transformaciones: programar

En este capítulo vamos a definir elementos que nos permitan definir condiciones y que hacer en cada caso. Vamos a definir un documento XML que contiene los datos de préstamo de los libros:

<?xml version="1.0"?>
<prestamo hoy="10-03-2002">
	<usuario u_id="u00432">
		<prestado fecha="09-03-2002" doc_id="doc00123"/>
		<prestado fecha="10-03-2002" doc_id="doc01007"/>
	</usuario>
	<usuario u_id="u03406">
		<prestado fecha="02-03-2002" doc_id="doc00978"/>
	</usuario>
	<restaurador r_id="r00004">
		<prestado fecha="01-03-2002" doc_id="doc00101"/>
		<prestado fecha="03-03-2002" doc_id="doc00775"/>
		<prestado fecha="03-03-2002" doc_id="doc00067"/>
	</restaurador>
</prestamo>

Supongamos que queremos que el bibliotecario tenga acceso a estos datos vía pagina html (voy a dar por supuesto un conocimiento básico de las etiquetas HTML) y que le señale los prestamos que han superado el periodo máximo (7 días).

<?xml version="1.0" encoding="ISO-8859-15"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="html" encoding="ISO-8859-15"/>
	<xsl:template match="prestamo">
		<html>
		<head><title>Listado de Préstamo</title></head>
		<body>
		<h2>Listado de Préstamo</h2>
		<ul>
			<xsl:apply-templates select="*/prestado"/>
		</ul>
		</body>
		</html>
	</xsl:template>
	<xsl:template match="prestado">
		<li>
		<xsl:value-of select="@doc_id"/>
		<xsl:text> lleva </xsl:text>
		<xsl:value-of select="substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')"/>
		<xsl:text> días prestado.</xsl:text>
		<xsl:if test="substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')&gt;7">
			<xsl:text> [Multa]</xsl:text>
		</xsl:if>
		</li>
	</xsl:template>
</xsl:stylesheet>

Lo primero que hemos hecho ha sido elegir la codificación 'ISO-8859-15' para no tener problemas con las tildes de nuestro idioma. También hemos definido el documento resultantes como HTML y con la misma codificación. El resto del modelo nos debería resultar familiar, quizás nos asuste un poco "substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')", que simplemente calcula los días que el documento lleva prestado. La función 'substring-before()' selecciona la subcadena anterior a '-', es decir el día. Y lo que hacemos es restar el día del atributo 'hoy' con el día del atributo 'fecha'. Señalar que hemos simplificado el problema asumiendo que el mes y el año son iguales.

La novedad de esta hoja de estilo está en el elemento 'xsl:if' que define una condición en su atributo 'test' y solo cuando se cumple se procesa su contenido. La condición es que lleve más de 7 días prestado, téngase en cuenta que para representar el signo '>' hemos tenido que substituirlo por '&gt;'.

Veamos el resultado:

<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-15">
		<title>Listado de Préstamo</title>
	</head>
	<body>
		<h2>Listado de Préstamo</h2>
		<ul>
			<li>doc00123 lleva 1 días prestado.</li>
			<li>doc01007 lleva 0 días prestado.</li>
			<li>doc00978 lleva 8 días prestado. [Multa]</li>
			<li>doc00101 lleva 9 días prestado. [Multa]</li>
			<li>doc00775 lleva 7 días prestado.</li>
			<li>doc00067 lleva 7 días prestado.</li>
		</ul>
	</body>
</html>

El listado es correcto, pero hay que definir casos especiales para cuando los días sean 0 y 1. Además 'doc00101' esta prestado a un restaurador, ellos no tienen límite de tiempo y no tiene sentido ponerle una multa.

<?xml version="1.0" encoding="ISO-8859-15"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="html" encoding="ISO-8859-15"/>
	<xsl:template match="prestamo">
		<html>
		<head><title>Listado de Préstamo</title></head>
		<body>
		<h2>Listado de Préstamo</h2>
		<ul>
			<xsl:apply-templates select="*/prestado"/>
		</ul>
		</body>
		</html>
	</xsl:template>
	<xsl:template match="prestado">
		<li>
		<xsl:value-of select="@doc_id"/>
		<xsl:choose>
			<xsl:when test="name(..)='restaurador'">
				<xsl:text> está en restauración.</xsl:text>
			</xsl:when>
			<xsl:when test="substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')=0">
				<xsl:text> se ha prestado hoy.</xsl:text>
			</xsl:when>
			<xsl:when test="substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')=1">
				<xsl:text> lleva 1 día prestado.</xsl:text>
			</xsl:when>
			<xsl:otherwise>
			<xsl:text> lleva </xsl:text>
			<xsl:value-of select="substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')"/>
			<xsl:text> días prestado.</xsl:text>
			<xsl:if test="substring-before(/prestamo/@hoy,'-')-substring-before(@fecha,'-')&gt;7">
				<xsl:text> [Multa]</xsl:text>
			</xsl:if>
			</xsl:otherwise>
		</xsl:choose>
		</li>
	</xsl:template>
</xsl:stylesheet>

Para definir todos los casos hemos utilizado el elemento 'xsl:choose' que