Descargar

INGENIERÍA SUPERIOR DE TELECOMUNICACIÓN
PROYECTO FIN DE CARRERA
IMPLEMENTACIÓN DE UNA AGENDA PERSONALIZADA
A PARTIR DE UNA ESTRUCTURA DE DATOS XML CON
TRANSFORMACIONES XSLT Y XSL-FO
Tutor del Proyecto: Antonio Jesús Sierra Collado
Alumno: José Antonio Pérez Moral
INDICE GENERAL
3
INDICE GENERAL
Objetivos........................................................................................................................ 10
1.
Introducción ......................................................................................................... 12
1.1.
2.
TEMÁTICA DE LOS CAPÍTULOS ..................................................................................................13
El lenguaje XML.................................................................................................. 16
2.1
INTRODUCCIÓN ........................................................................................................................16
2.2
FAMILIA XML .........................................................................................................................17
2.2.1. SGML..................................................................................................................................17
2.2.2. HTML .................................................................................................................................18
2.3
CARACTERÍSTICAS DE XML....................................................................................................20
2.4
DOCUMENTOS XML BIEN FORMADOS ......................................................................................21
2.5
DOCUMENTOS VÁLIDOS ...........................................................................................................22
2.5.1. Las DTDs............................................................................................................................23
2.5.2. XML Schema.......................................................................................................................24
2.5.3. Esquemas VS. DTDs ...........................................................................................................26
2.6
ESCRIBIR DOCUMENTOS XML .................................................................................................26
2.6.1. Prólogo de un documento XML..........................................................................................27
2.6.1.1.
2.6.1.2.
2.6.2.
Cuerpo del documento XML...............................................................................................29
2.6.2.1.
2.6.2.2.
2.7
2.8
3.
Declaración XML.................................................................................................................... 27
Declaración del documento externo de validación .................................................................. 28
Instrucciones de Proceso ......................................................................................................... 29
Elementos y atributos.............................................................................................................. 29
PROCESADORES XML ..............................................................................................................31
CONCLUSIONES ........................................................................................................................32
Tecnologías para la presentación de un documento XML .............................. 34
3.1
INTRODUCCIÓN ........................................................................................................................34
3.2
CSS..........................................................................................................................................35
3.2.1. Características y reglas de una hoja CSS ..........................................................................36
3.2.2. Enlace a hoja CSS ..............................................................................................................37
3.2.3. Limitaciones y desarrollo de las hojas de estilo CSS .........................................................38
3.3
XSL .........................................................................................................................................38
3.3.1. Por qué XSL........................................................................................................................39
3.3.2. Pasos para dar estilo a un documento XML.......................................................................39
3.3.3. Creación de hojas de estilo XSL.........................................................................................41
3.3.4. Templates............................................................................................................................43
3.3.5. Enlace a hoja XSL ..............................................................................................................44
3.4
CONCLUSIONES ........................................................................................................................44
4.
El Lenguaje de Caminos XPATH ...................................................................... 48
4.1
INTRODUCCIÓN ........................................................................................................................48
4.2
MODELO DE DATOS EN XPATH: ÁRBOL Y NODOS ....................................................................49
4.3
UN PATH DIFERENTE ................................................................................................................51
4.4
CAMINOS DE LOCALIZACIÓN (LOCATION PATH) .......................................................................53
4.4.1. Elementos de un Camino de Localización ..........................................................................54
4.4.1.1.
4.4.1.2.
4.4.1.3.
Ejes.......................................................................................................................................... 55
Nodos de comprobación o búsqueda (node test) ..................................................................... 59
Predicado................................................................................................................................. 60
4.4.2. Sintaxis abreviada ..............................................................................................................61
4.5
CONCLUSIONES ........................................................................................................................64
INDICE GENERAL
5.
4
El lenguaje de transformación XSLT ................................................................ 67
5.1
INTRODUCCIÓN ........................................................................................................................67
5.2
TRANSFORMACIÓN DE DOCUMENTOS XML .............................................................................67
5.3
PRINCIPALES CARACTERÍSTICAS DE XSLT...............................................................................69
5.4
MODELO Y PROCESADO DE XSLT ...........................................................................................70
5.4.1. Procesadores XSLT ............................................................................................................71
5.5
ESTRUCTURA DE UN DOCUMENTO XSLT .................................................................................73
5.5.1. Elementos de alto nivel (top-level-element)........................................................................74
5.5.2. Instrucciones de Plantilla (instruction) ..............................................................................75
5.6
DEFINICIÓN DE LA HOJA DE ESTILO .........................................................................................77
5.6.1. El Elemento Template (Plantilla) .......................................................................................80
5.6.1.1.
5.6.2.
5.6.2.1.
5.6.2.2.
5.6.2.3.
5.6.2.4.
5.6.2.5.
5.6.2.6.
5.6.2.7.
5.6.2.8.
5.6.2.9.
5.7
6.
Plantilla predeterminada.......................................................................................................... 82
Generación de Plantillas ....................................................................................................84
Regla <xsl:apply-templates>.................................................................................................. 84
Regla <xsl:value-of> .............................................................................................................. 86
Regla <xsl:element>............................................................................................................... 87
Regla <xsl:attribute>.............................................................................................................. 88
Regla <xsl:if>......................................................................................................................... 88
Regla <xsl:choose>, <xsl:when> y <xsl:otherwise> .............................................................. 89
Regla <xsl:for-each> .............................................................................................................. 90
Regla <xsl:copy-of>................................................................................................................ 92
Comentarios ............................................................................................................................ 92
CONCLUSIONES ........................................................................................................................93
El Formato, XSL-FO.......................................................................................... 95
6.1
INTRODUCCIÓN ........................................................................................................................95
6.2
XSL-FO COMO RECOMENDACIÓN ...........................................................................................95
6.3
FORMATING OBJECTS ...............................................................................................................96
6.3.1
Áreas...................................................................................................................................97
6.4
ESTRUCTURA DE UN DOCUMENTO XSL-FO .............................................................................99
6.4.1. < fo:root >........................................................................................................................100
6.4.2. < fo:layout-master-set > ..................................................................................................100
6.4.3. < fo:simple-page-master >...............................................................................................101
6.4.4. < fo:page-sequence >.......................................................................................................103
6.4.4.1.
6.4.4.2.
< fo:flow > (Contenido dinámico)........................................................................................ 103
< fo:static-content > (Contenido estático) ............................................................................ 105
6.5
MÉTODOS DE OBTENCIÓN DE UN DOCUMENTO XSL-FO ........................................................105
6.6
PROCESADORES XSL-FO .......................................................................................................106
6.6.1. FOP ..................................................................................................................................107
6.7
HOLA, MUNDO! ......................................................................................................................108
6.7.1
Método directo..................................................................................................................108
6.7.2
Método Indirecto ..............................................................................................................109
6.8
CONCLUSIONES ......................................................................................................................112
7.
Aplicación desarrollada y pruebas................................................................... 114
7.1
INTRODUCCIÓN ......................................................................................................................114
7.2
IMPLEMENTACIÓN DE LA APLICACIÓN DESARROLLADA .........................................................114
7.3
PROGRAMAS INSTALADOS ......................................................................................................115
7.4
DOCUMENTO XML ................................................................................................................119
7.5
APLICACIÓN SOBRE NAVEGADOR WEB ...................................................................................121
7.5.1. Pruebas.............................................................................................................................128
7.6
APLICACIÓN PARA DOCUMENTOS PDF...................................................................................129
7.6.1 Pruebas .................................................................................................................................135
7.7
APLICACIÓN SOBRE DISPOSITIVO MÓVIL ................................................................................137
7.7.1 Pruebas ..................................................................................................................................140
7.8
CONCLUSIONES ......................................................................................................................143
INDICE GENERAL
8.
5
Planos de Código................................................................................................ 145
8.1
8.2
8.3
8.4
9.
DOCUMENTO XML ................................................................................................................145
HOJA DE ESTILO PARA TRANSFORMACIÓN A HTML..............................................................146
HOJA DE ESTILO PARA TRANSFORMACIÓN A PDF...................................................................151
HOJA DE ESTILO PARA TRANSFORMACIÓN A WML ................................................................157
Conclusiones....................................................................................................... 162
9.1
10.
LÍNEAS FUTURAS DE DESARROLLO .........................................................................................164
Referencias ......................................................................................................... 166
GLOSARIO................................................................................................................. 169
INDICE DE FIGURAS
6
INDICE DE FIGURAS
Ilustración 1 .- Implementación de la aplicación desarrollada ....................................... 10
Ilustración 2 .- Familia XML.......................................................................................... 19
Ilustración 3 .- Definición de elemento XML ................................................................ 30
Ilustración 4 .- Elemento vacío....................................................................................... 30
Ilustración 5.- Jerarquía XSL.......................................................................................... 40
Ilustración 6 .- Árbol XPath ........................................................................................... 49
Ilustración 7 .- Sintaxis completa de un Camino de Localización ................................. 55
Ilustración 8 .- Descripción Tipos de Ejes XPath........................................................... 58
Ilustración 9 .- Relación entre los Ejes de XPath ........................................................... 59
Ilustración 10 .- Tabla abreviaturas Pasos XPath ........................................................... 63
Ilustración 11 .- Proceso de Transformación XSLT....................................................... 68
Ilustración 12 .- Árbol resultado de la Transformación.................................................. 70
Ilustración 13 .- Obtención árbol resultado .................................................................... 71
Ilustración 14 .- Principales Procesadores XSLT........................................................... 73
Ilustración 15.- Posición de XSL-FO ............................................................................. 96
Ilustración 16.- Estructura general XSL-FO .................................................................. 99
Ilustración 17.- Áreas de una Página ............................................................................ 102
Ilustración 18 .- Obtención de un documento XSL-FO ............................................... 106
Ilustración 19 .- Procesos de Transformación .............................................................. 107
Ilustración 20 .- Implementación de la aplicación desarrollada ................................... 115
Ilustración 21 .- Stylus Studio ...................................................................................... 116
Ilustración 22 .- Selección procesador Stylus Studio ................................................... 116
Ilustración 23 .- Asignación de documentos Stylus Studio .......................................... 117
Ilustración 24 .- XSL Formatter v4.2 ........................................................................... 118
Ilustración 25 .- Nokia Mobile Browser....................................................................... 118
Ilustración 26 .- Árbol XML en Stylus Studio ............................................................. 121
Ilustración 27 .- Grid en Stylus Studio ......................................................................... 121
Ilustración 28 .- Agenda para exámenes en Internet Explorer ..................................... 128
Ilustración 29 .- Agenda para exámenes en Mozilla Firefox........................................ 129
Ilustración 30 .- Agenda para exámenes en PDF I ....................................................... 135
Ilustración 31 .- Agenda para exámenes en PDF II...................................................... 136
Ilustración 32 .- Agenda para exámenes en NMB I ..................................................... 140
Ilustración 33 .- Agenda para exámenes en NMB II .................................................... 141
Ilustración 34 .- Agenda para exámenes YoSpace I..................................................... 142
Ilustración 35 .- Agenda para exámenes YoSpace II.................................................... 142
INDICE DE CÓDIGO
7
INDICE DE CÓDIGO
Código 1 .- Doc_validacion.xml .................................................................................... 25
Código 2 .- Doc_validacion.xsd ..................................................................................... 25
Código 3 .- Encabezado XML........................................................................................ 28
Código 4 .- Declaración doc. externo validación (DTD) ............................................... 28
Código 5 .- Declaración doc. validación (Schema XML) .............................................. 28
Código 6 .- Instrucción de Proceso................................................................................. 29
Código 7.- Elemento con sus atributos........................................................................... 30
Código 8 .- IP para hoja de estilo CSS ........................................................................... 37
Código 9 .- Línea de prologo XSL ................................................................................. 41
Código 10 .- Línea de declaración XSL ......................................................................... 42
Código 11 .- Declaración del documento de salida ........................................................ 42
Código 12 .- Definición de Plantilla............................................................................... 44
Código 13 .- IP para hojas de estilo XSL ....................................................................... 44
Código 14 .- Sintaxis XPath ........................................................................................... 51
Código 15 .- Ejemplo XPath .......................................................................................... 52
Código 16 .- Sintaxis de un “Paso” de Localización...................................................... 55
Código 17 .- Eje.............................................................................................................. 55
Código 18 .- Test de Nodo ............................................................................................. 59
Código 19 .- Predicado ................................................................................................... 60
Código 20 .- Abreviatura de Child:: ............................................................................... 61
Código 21 .- Abreviatura de Atributo............................................................................. 62
Código 22 .- Abreviatura descendant-or-self::node()..................................................... 62
Código 23 .- Abreviatura self::node()............................................................................. 63
Código 24 .- Abreviatura parent::node() ........................................................................ 63
Código 25 .- Instrucción de Transformación para Xalan ............................................... 73
Código 26 .- Declaración XML en documento XSLT ................................................... 78
Código 27 .- Elemento <xsl:stylesheet >........................................................................ 78
Código 28 .- Formato de salida ...................................................................................... 78
Código 29 .- Definición de Plantilla raíz........................................................................ 79
Código 30 .- Estructura de un template .......................................................................... 80
Código 31 .- Ejemplo template....................................................................................... 81
Código 32 .- Ejemplo documento XSLT con Plantillas ................................................ 81
Código 33 .- Ejemplo documento XSLT con Plantillas ................................................ 82
Código 34 .- Plantilla predeterminada para elementos................................................... 83
Código 35 .- Plantilla predeterminada para atributos ..................................................... 83
Código 36 .- Plantilla básica sin salida........................................................................... 84
Código 37 .- Plantilla con salida..................................................................................... 84
Código 38 .- Sintaxis regla xsl:apply-templates............................................................. 85
Código 39 .- Ejemplo regla xsl:apply-templates I.......................................................... 85
Código 40 .- Ejemplo regla xsl:apply-templates II......................................................... 85
Código 41 .- Sintaxis regla xsl:value-of ......................................................................... 86
Código 42 .- Sintaxis regla xsl:element.......................................................................... 87
Código 43 .- Sintaxis regla xsl:attribute ......................................................................... 88
Código 44 .- Sintaxis regla xsl:if.................................................................................... 88
Código 45 .- Ejemplo regla xsl:if ................................................................................... 89
INDICE DE CÓDIGO
8
Código 46 .- Sintaxis regla xsl:choose ........................................................................... 89
Código 47 .- Ejemplo regla xsl:choose........................................................................... 90
Código 48 .- Sintaxis regla xsl:for-each ......................................................................... 91
Código 49 .- Ejemplo reglas xsl:choose, xsl:for-each .................................................... 91
Código 50 .- Sintaxis regla copy-of ................................................................................ 92
Código 51 .- Comentario sin salida ................................................................................ 92
Código 52 .- Comentario con salida ............................................................................... 92
Código 53 .- Estructura general de archivo XSL-FO ..................................................... 99
Código 54 .- Línea de declaración XSL-FO................................................................. 100
Código 55 .- Elemento raíz XSL-FO............................................................................ 100
Código 56 .- Elemento fo:layout-master-set................................................................. 100
Código 57 .- Elemento simple-page-master ................................................................. 101
Código 58 .- Atributos fo:simple-master-master.......................................................... 102
Código 59 .- Elemento fo:page-sequence..................................................................... 103
Código 60 .- fo:block.................................................................................................... 103
Código 61 .- fo_inline................................................................................................... 104
Código 62 .- Estructura fo:page-sequence con fo:block............................................... 104
Código 63 .- Instrucción de procesado FOP................................................................. 108
Código 64 .- Hola, mundo!, método directo................................................................. 109
Código 65 .- Declaración del namespace ..................................................................... 109
Código 66 .- Hola, mundo!, archivo XSL .................................................................... 110
Código 67 .- Hola, mundo!, archivo XML ................................................................... 110
Código 68 .- Espacio de nombres................................................................................. 111
Código 69 .- Hola, mundo!, archivo .fob ..................................................................... 111
Código 70 .- Documento XML..................................................................................... 120
Código 71 .- Variables de la hoja de estilo................................................................... 122
Código 72 .- Definición de la variable: n_elementos ................................................... 122
Código 73 .- Comienzo de la plantilla principal de agenda_html.xsl........................... 123
Código 74 .- Definición de la tabla de asignaturas para HTML................................... 123
Código 75 .- Cierre de la plantilla principal de agenda_html.xsl ................................. 124
Código 76 .- Plantillas 'mes' y 'semana' para formar el calendario............................... 125
Código 77 .- Plantilla ‘dias’ para el calendario en HTML ........................................... 127
Código 78 .- Plantilla que imprime las asignaturas para HTML.................................. 127
Código 79 .- Declaración del espacio de nombres FO ................................................. 129
Código 80 .- Comienzo de la plantilla principal de agenda_pdf.xsl............................. 130
Código 81 .- Definición de la tabla calendario para documento pdf............................ 131
Código 82 .- Definición de la tabla con las asignaturas para pdf ................................. 131
Código 83 .- Cierre de la plantilla principal para pdf................................................... 132
Código 84 .- Impresión de los días de la semana en pdf .............................................. 132
Código 85 .- Plantilla que imprime las asignaturas para documento pdf ..................... 133
Código 86 .- Template dia para documento pdf........................................................... 134
Código 88 .- Declaración del método de salida WML................................................. 137
Código 89 .- Template principal para hoja de estilo con salida WML......................... 138
Código 90 .- Plantilla que crea una Tarjeta para cada asignatura en WML ................. 138
Código 91 .- Plantilla dia para generación del documento WML................................ 140
Código 92 .- Estructura de datos de la aplicación: agenda.xml.................................... 146
Código 93 .- Código de la hoja de estilo agenda_html.xsl........................................... 150
Código 94 .- Código de la hoja de estilo: agenda_pdf.xsl............................................ 156
Código 95 .- Código de la hoja de estilo: agenda_wml.xsl .......................................... 160
Objetivos
Una hoja de estilo XSL es una secuencia de reglas que determinan una
transformación entre un documento XML de entrada y un documento deseado de salida,
con el fin de dar un formato de presentación a la estructura de datos XML. Cada regla se
compone de un patrón y una acción o plantilla (template). El objetivo del presente
Proyecto es implementar una aplicación que sirva de agenda personalizada utilizando el
lenguaje de hojas de estilo XSL.
Una estructura de datos XML necesita de una transformación y una definición de
formato para su presentación final sobre un medio. Una hoja de estilo CSS, presenta
ciertas carencias, ya que es incapaz de ejecutar operaciones lógicas y de filtrar los datos
de acuerdo a ciertas condiciones.
XSL es una tecnología que puede adaptar un documento XML a un tipo de
presentación en concreto y dar salida a una estructura de datos XML sobre cualquier
medio.
La aplicación desarrollada se muestra sobre tres medios: dispositivo móvil,
navegador web y documento portátil imprimible, y da salida a un único documento
origen XML tras aplicarle las correspondientes hojas de estilo XSL.
Para presentar una estructura de datos XML sobre un nuevo dispositivo externo,
basta aplicar al documento origen XML una nueva hoja de estilo XSL apropiada para
ese dispositivo.
La hoja de estilo XSL es la que define la forma de realizar la transformación, y
serán los procesadores XSLT y XSL-FO, los encargados de transformar la estructura de
datos XML.
Ilustración 1 .- Implementación de la aplicación desarrollada
CAPITULO 1.- INTRODUCCIÓN
12
1. Introducción
En este capítulo se dará una breve descripción de las tecnologías que se tratan en
la presente memoria.
Cabe comenzar con una breve historia del nacimiento de XML (Extended Markup
Language), el cual se puede decir que proviene de un lenguaje que inventó IBM en los
años 70. El lenguaje de IBM se llama GML (General Markup Language) y surgió por la
necesidad que tenían en la empresa de almacenar grandes cantidades de información de
temas diversos.
Este lenguaje gustó mucho a la ISO (International Organization for
Standardization), de modo que en 1986 la entidad de normalización comenzó a trabajar
para normalizar el lenguaje, creando SGML (Structured Generalized Markup
Language), que no era más que el Standar GML.
Será ya en 1998, cuando el W3C (World Wide Web Consortium) con lo que había
gustado el lenguaje SGML, comenzó a desarrollar XML, al igual que había hecho
anteriormente con HTML (HyperText Markup Language). Éste lenguaje XML surgió
como una versión simplificada de SGML, intentaba quitar complejidad a SGML y
además pretendía solucionar las carencias de HTML en lo que se respecta al tratamiento
de la información. Problemas de HTML como:
•
El contenido se mezcla con los estilos que se le quieren aplicar.
•
No permite compartir información con todos los dispositivos, como
pueden ser ordenadores o teléfonos móviles.
•
La presentación en pantalla depende del navegador que se utilice.
Con posterioridad, han ido apareciendo también varias tecnologías que se han
unido con XML y la complementan, haciendola mucho más importante y con unas
posibilidades mucho mayores.
XML junto con todas las tecnologías relacionadas, representa una manera distinta
de hacer las cosas, más avanzada, cuya principal novedad consiste en permitir compartir
los datos con los que se trabaja a todos los niveles, por todas las aplicaciones y soportes.
XML apoyado con las tecnologías con que se relaciona, utiliza maneras más
fáciles e interesantes de trabajar con los datos.
CAPITULO 1.- INTRODUCCIÓN
13
Así pues, XML juega un papel importantísimo en la actualidad, que tiende a la
globalización y la compatibilidad entre los sistemas, ya que es la tecnología que
permitirá compartir la información de una manera segura, fiable, fácil.
Para cada documento XML que se desee presentar formateado se tiene que
escribir una hoja de estilo. También tenemos dos posibles lenguajes con los que
formatear los textos de un documento XML, la primera posibilidad es el CSS
(Cascading Style Sheets), mientras que la segunda opción es el XSL (Extensible
Stylesheet Language), bastante más avanzada.
CSS no es nada nuevo, ya se podía utilizar con HTML y se creó en un intento de
separar la forma del contenido en HTML. En XML también podemos utilizar las CSS, y
se utilizan de una manera muy similar a cómo se utilizan en HTML.
XSL es el segundo lenguaje con el que trabajar en XML. Este lenguaje no se
limita a definir qué estilo aplicar a cada elemento del documento XML. Además se
pueden realizar pequeñas instrucciones típicas de los lenguajes de programación y la
salida no tiene porque ser un documento HTML, sino que además podría ser de otros
tipos como un documento escrito en WML (Wireless Markup Language) para móviles
WAP (Wireless Application Protocol), un documento de texto plano u otro documento
XML.
XSL resulta mucho más potente que CSS y de hecho es mucho más adecuado
utilizarlo. Si tenemos un documento XML que queremos que se visualice en múltiples
dispositivos distintos será imprescindible utilizar XSL.
En este esquema, tendríamos un solo documento XML y un documento XSL para
cada dispositivo que queramos incluir, por ejemplo para un navegador web, otro para un
documento imprimible y otro para un dispositivo móvil.
Es este último caso supuesto, el que ocupa el lugar de la aplicación que se ha
realizado en este Proyecto.
1.1. Temática de los capítulos
La temática de los siguientes capítulos de la memoria es:
•
Capítulo 2.- El lenguaje XML. Definición, características y familia de
XML. Se ve su estructura y los procesadores que se utilizan.
CAPITULO 1.- INTRODUCCIÓN
14
•
Capítulo 3.- Presentación de un documento XML. Tecnologías para
dar formato a un documento XML. Por qué la elección de XSL.
•
Capítulo 4.- El Lenguaje de Caminos XPATH. Necesidad de un
lenguaje de caminos para moverse en un documento XML.
•
Capítulo 5.- El lenguaje de transformación XSLT. Transformaciones
de documentos XML.
•
Capítulo 6.- El Formato, XSL-FO. Dar formato de salida a las
estructuras de datos.
•
Capítulo 7.- Aplicación desarrollada y pruebas. Generación de una
aplicación visualizable en navegador web, dispositivo móvil y
documento con formato, a partir de un mismo documento XML.
•
Capítulo 8.- Plano de Código. Código del documento XML y de las
hojas de estilo XSL implicadas en la transformación.
•
Capítulo 9.- Conclusiones. Objetivos conseguidos y análisis de líneas
futuras.
•
Capítulo 10.- Referencias. Referencias bibliográficas utilizadas para la
redacción de la memoria.
CAPITULO 2.- EL LENGUAJE XML
16
2. El lenguaje XML
2.1 Introducción
EXtensible Markup Language (Lenguaje de marcado extensible) es un estándar
abierto desarrollado por el grupo W3C (World Wide Web Consortium) para textos
estructurados. Es un lenguaje de marcas que se ha elaborado para la definición de
estructuras de documentos y el almacenamiento de datos.
Se dice que XML (Extensible Markup Language) es un “lenguaje de marcado”
porque se pueden describir los documentos XML simplemente con la utilización de
etiquetas. La parte “extensible” de su nombre, también es importante, XML no es un
lenguaje de marcado sino de meta-marcado, es decir, se puede utilizar XML para crear
nuestro propio lenguaje de marcado.
En cada documento XML se crea un lenguaje de marcado personal, no existe
ningún documento XML semejante a otro documento escrito en el mismo lenguaje,
puesto que en cada documento XML se crea un lenguaje de marcado propio.
Un documento XML tiene dos estructuras, una lógica y otra física. Físicamente, el
documento está compuesto por unidades llamadas entidades. Una entidad puede hacer
referencia a otra entidad, causando que esta se incluya en el documento. Cada
documento comienza con una entidad documento, también llamada raíz.
Lógicamente, el documento está compuesto de declaraciones, elementos,
comentarios, referencias a caracteres e instrucciones de procesamiento, todos los cuales
están indicados por una marca explícita.
En los apartados segundo y tercero de este capitulo se va a comenzar viendo la
Familia XML y las características principales del lenguaje XML. El apartado cuarto y
quinto se dedicarán al estudio de documentos XML bien formados y válidos. Para
terminar el capítulo, se verá en los dos últimos apartados cómo escribir documentos
XML y los tipos de procesadores que se utilizan.
CAPITULO 2.- EL LENGUAJE XML
2.2
17
Familia XML
2.2.1. SGML
SGML (Structured Generalized Markup Language), lenguaje de marcación
generalizado, es un metalenguaje que cumple con el estándar ISO 8879, y permite
definir diferentes tipos de documentos. Es un lenguaje derivado de GML (Generalized
Markup Language), una norma anterior adoptada de IBM como parte de su sistema de
procesamiento de textos.
Con SGML se diferencia en un documento entre su estructura física y lógica, con
una organización como un conjunto de entidades por un lado, y como una jerarquía de
elementos por otro; de forma que el marcado describe la estructura de la información, y
el texto el contenido.
SGML es un estándar internacional, no propietario y abierto, y provee una
codificación estándar para la transmisión de documentos entre sistemas diferentes:
distintas plataformas, soportes físicos, lógicos y diferentes sistemas de almacenamiento
y presentación, con independencia de su grado de complejidad.
La utilización de SGML se debe a la necesidad de:
•
Intercambiar documentos entre diferentes sistemas de cómputo o de
publicación.
•
Requerir que los documentos tengan una vida de uso larga
•
Dar gran importancia a la estructura de un documento.
•
Utilizar una base de datos para el almacenamiento y recuperación de
elementos del documento.
Un documento SGML se marca de modo que no dice nada respecto a su
representación en la pantalla o en papel. Un programa de presentación debe unir el
documento con la información de estilo a fin de producir una copia impresa en la
pantalla o en el papel.
De todos modos, la sintaxis de SGML es suficiente para sus necesidades, pero
pocos pueden decir que es particularmente “bella”. El lenguaje muestra que se originó
en sistemas donde el texto era el contenido principal y el marcado era la excepción.
CAPITULO 2.- EL LENGUAJE XML
18
SGML es el predecesor y una versión ampliada, más compleja, de XML. Entre
sus objetivos más directos podemos destacar las siguientes características:
•
Proceso de documentos por ordenador.
•
Separación de estructura, contenido y presentación.
•
Independencia de sistemas y vendedores.
Es decir, tiene las mismas características que el XML, pero con varios
inconvenientes:
•
Mayor complejidad.
•
Muchas opciones para aplicaciones especiales.
•
Alto coste
•
Sintaxis no legible.
•
SGML diseña herramientas demasiado complicadas.
Por tanto, si a SGML se le prepara para la presentación de documentos en Internet
(en un principio no lo estaba), y le eliminamos su complejidad y otras características
que le hacen ilegible, tenemos como resultado a XML.
Es por tanto, a modo de resumen, que podemos decir que XML es, una versión de
SGML, más sencilla y más fácil de aplicar. Diseñada precisamente para hacer frente a
los problemas de compatibilidad y adaptabilidad de las nuevas tecnologías.
2.2.2. HTML
HTML (HyperText Markup Language) es el hermano más cercano a XML, y se
utiliza para la presentación de información en Internet. HTML, no es un lenguaje de
programación, es un lenguaje de especificación de contenidos para un tipo específico de
documentos SGML.
Es decir, mediante HTML podemos especificar, utilizando un conjunto de
etiquetas, cómo va a representarse la información en un navegador o browser. HTML
no es demasiado útil para describir el significado de un dato, sino para definir su
aspecto.
CAPITULO 2.- EL LENGUAJE XML
19
HTML, se utiliza para establecer cómo se han de presentar, o visualizar los datos,
mientras que con XML lo que definimos utilizando el marcado, es la estructura de los
datos.
Éste lenguaje tiene ventajas aprovechadas por el XML:
•
Es el lenguaje de formateo para los navegadores de Internet.
•
Es fácil de entender y utilizar.
•
Su uso es muy extendido.
Pero tiene ciertos inconvenientes que intenta suplir XML, entre ellos podemos
destacar:
•
No tiene semántica.
•
El contenido no puede ser reconocido ni procesado por programas.
•
Tiene un costoso mantenimiento de las páginas.
•
No tiene estándares comunes.
•
Dificultad de ampliación (razones políticas y técnicas).
XML no es ningún tipo de documento SGML, como si lo es HTML, sino que es
una versión abreviada de SGML optimizada para su utilización en Internet. Esto
significa que con él se va a poder definir nuestros propios tipos de documentos.
Se puede ver en la ilustración siguiente, lo comentado en el párrafo anterior, la
relación entre las tres tecnologías que estamos tratando:
Ilustración 2 .- Familia XML
CAPITULO 2.- EL LENGUAJE XML
20
Señalar que la diferencia más importante entre HTML y XML, a destacar entre las
anteriores, es que HTML es un lenguaje, mientras que XML es un metalenguaje. HTML
es un lenguaje de marcas fijas, sólo se deben utilizar las marcas establecidas en la
especificación, y cualquier otra marca es ignorada.
XML sin embargo, permite al diseñador crear sus propias marcas, especificando
su sintaxis y funcionalidad de tal forma que las nuevas marcas puedan ser reconocidas e
interpretadas por los visualizadores.
Esto es muy útil puesto que las propias marcas pueden ser utilizadas para
identificar contenidos, no sólo para determinar la forma de presentación al usuario como
hace HTML.
Se puede concluir que HTML es un lenguaje muy fácil de comprender y muy
utilizado para la presentación de la información en un navegador web, pero ésta no se
puede procesar ni almacenar, ya que no permite ser manipulado por un programa debido
a su anarquía.
2.3
Características de XML
La principal característica de XML, es la posibilidad separar el contenido de la
estructura, es decir se puede saber si un documento está bien formado sin saber qué es
lo que contiene.
Es por tanto XML, el lenguaje encargado de guardar en sus documentos todo el
contenido, datos a estructurar. Se verá más adelante quién es el encargado de estructurar
dichos datos.
XML se basa en el uso de marcas o etiquetas para diferenciar los diversos
elementos que pueden existir en un documento, a la vez con el lenguaje XML se
consigue una perfecta organización de los contenidos existentes en el documento XML.
El nombre de las etiquetas que se utilizan para cada elemento en un documento
XML, es totalmente personal; cómo ya se ha comentado más arriba, es lo que le da
sentido al término “extensible”. El programador tiene por tanto, absoluta libertad para
la elección del nombre de etiquetas.
Esto le da sencillez a la hora de ser interpretado y manipulado, se podría decir que
es casi autodescriptivo.
CAPITULO 2.- EL LENGUAJE XML
21
De esta forma, si se recibe una cadena de texto normal sin ninguna identificación
y la tenemos que interpretar, resulta difícil saber qué es exactamente, pero si ese texto
va acompañado de unas etiquetas, sí que podemos identificarla (transforma los datos en
información descriptiva).
También debe de recordarse, que es un lenguaje estricto, un documento XML
debe de cumplir unas normas de sintaxis y estructuración para que sea reconocido como
tal; para ello el documento ha de estar como mínimo, bien formado. HTML es más
permisivo, elementos con contenido sin etiquetas de cierre, marcas mal anidadas, etc, no
provocan ningún error.
Los documentos XML, teniendo en cuenta el grado de restricción utilizado para
establecer la estructura y contenido de sus datos, pueden ser de dos tipos: bien formados
y válidos o no válidos. Como consecuencia, la condición de ser un documento válido no
siempre debe de cumplirse.
2.4
Documentos XML bien formados
Los documentos XML se organizan en una estructura en forma de árbol, en la que
los elementos se encuentran distribuidos jerárquicamente. Existiendo siempre un
elemento raíz (root) de esta estructura.
Para que la estructura del documento sea correcta y este bien formado, condición
indispensable a la hora de tener un documento XML, se deben de cumplir una serie de
normas que enunciamos a continuación:
•
El elemento raíz debe de ser único.
Es el nodo raíz a partir del cual se irán añadiendo nuevas entidades o
elementos, nodos hijos, para formar el árbol del documento.
•
Todos los elementos con contenido deben de tener etiquetas de cierre y
con el mismo nombre que la etiqueta inicial
Siempre que utilicemos una etiqueta y hemos de tener también su
etiqueta cierre (<etiqueta> … </etiqueta>). Si un elemento estuviese vacío, la
propia etiqueta incluirá el cierre de la misma (<etiqueta />). El nombre de
etiqueta inicial y final debe corresponderse.
CAPITULO 2.- EL LENGUAJE XML
•
22
Las etiquetas de distintos elementos no se pueden solapar o superponer.
No se puede mezclar el contenido de varios elementos.
•
Cerrar en orden correcto las etiquetas de elementos anidados.
No se pueden mezclar las etiquetas de elementos de orden superior.
•
Los atributos de los elementos deben ir entre comillas.
En caso de tener atributos los elementos, dichos atributos deben de ir en
comillas dobles (“ ”) o simples (‘ ’).
•
Un elemento no tiene dos atributos con el mismo nombre
•
No se pueden utilizar los caracteres <, >, & en el contenido de un
elemento.
Se ha de recurrir a las entidades XML: <, >, &
respectivamente.
•
Los comentarios y las IP no aparecen en ninguna etiqueta
•
Todos los caracteres que aparecen en el documente deben de ceñirse a la
codificación especificada en el atributo encoding del encabezado
En el caso de que alguna de éstas normas no se cumpliese, el documento no
estaría bien formado, y el analizador al detectarlo, lo notifica e interrumpe su trabajo.
2.5
Documentos válidos
Estar bien formado es un requisito básico y obligatorio en un documento XML,
pero el tener validez no debe de cumplirse en todo documento XML, es una condición
más fuerte que no se requiere para procesar dichos documentos.
CAPITULO 2.- EL LENGUAJE XML
23
Éste tipo de documentos válidos, utilizan además de las normas básicas arriba
expuestas, un mecanismo de descripción de documentos, ya sea DTD (Document Type
Definition, Definición de Tipo de Documento) o Schema XML (Esquemas XML), en
los que se indica los elementos que deben ser usados, además del modo en que hacerlo
(sintaxis) y de la estructura que deberán de mantener.
2.5.1. Las DTDs
Las DTDs (Document Type Definition), son una aportación procedente de SGML
incorporada a XML, utilizan instrucciones definidas en el lenguaje SGML. Una DTD es
una colección de declaraciones de elementos (ELEMENT), atributos (ATTLIST),
entidades (ENTITY) y anotaciones (NOTATION) a partir de las cuales se describe la
validez de un documento XML.
Una DTD es por tanto, un mecanismo para describir cada objeto (entidades,
notaciones, elementos y atributos) que pueden aparecer en el documento XML que la
utilice. Un documento XML que indique que hace uso de una DTD se dice que es
válido si cumple las normas allí establecidas.
La forma como se puede organizar un documento que describa una DTD es
bastante libre, aunque es conveniente que siga el mismo orden con el que se van a
presentar los objetos en el documento XML, definiendo por tanto en primer lugar los
objetos que aparecen primero y/o que pueden ser incluidos en otros elementos, para
luego definir el resto de elementos.
Dependiendo de que la DTD se incluya dentro del propio documento XML o sea
guardada en un archivo independiente, las DTD se clasifican en dos tipos: internas y
externas:
•
Internas, la DTD se encuentra declarada en el propio documento
XML. Éste método suele utilizarse cuando las DTD son de pequeño
tamaño y solamente se piensa utilizarlas con ese documento XML.
•
Externas, las DTD se guardan en archivos independientes con
extensión “.dtd”. El documento de validación puede ser usado desde
diversos documentos XML. En este caso, el documento XML debe de
realizar un enlace a dicha hoja de validación, para ello se incluirá en el
mismo, una línea que indique al procesador XML que debe de leer de un
archivo externo. El parámetro DTD de la instrucción <!DOCTYPE>
indicará la ruta (URI) donde se encuentra el archivo de la DTD.
CAPITULO 2.- EL LENGUAJE XML
24
En el caso de utilizar una DTD externa, se tiene dos métodos a la hora de acceder
a ellas:
•
SYSTEM, se utilizará este método para acceder a DTDs que se
encuentran en nuestro propio equipo, en la misma máquina que en la que
tenemos el documento XML.
•
PUBLIC, con su uso accedemos a DTDs que se encuentre en cualquier
equipo de la red, como pude ser la utilización de validaciones
proporcionadas por organizaciones o compañías de Internet.
2.5.2. XML Schema
Éste lenguaje de modelado, utilizado igualmente que el anterior, para la creación
de documentos de validación, está basado en el lenguaje XML, y no en instrucciones
SGML como las DTDs.
La primera ventaja que encontramos sobre las DTDs es la posibilidad de utilizar
espacios de nombre (namespaces), por medio de los cuales es posible utilizar en el
documento de definición del esquema diversos lenguajes o tecnologías XML, incluso
aunque se utilicen elementos del mismo nombre, ya que namespaces proporciona un
mecanismo basado en prefijos para evitar confusión entre ellos.
La finalidad de XML Schema es al igual que la DTD, declarar diversos objetos
que pueden ser utilizados en el documento XML y definir los elementos con su
contenido y atributos para establecer cómo se han de usar para crear la estructura del
documento XML que utilice dicho esquema y, de esa forma, poder efectuar la
validación.
A los documentos desarrollados con XML Schema también se les conoce como
documentos XSD (XML Schema Definition, Definición de Esquemas XML), y se
guardan en archivos con extensión “.xsd”.
Existen distintos modelos de lenguajes para la creación de esquemas de
documentos XML, entre los más conocidos:
•
XSD, basado en las especificaciones de World Wide Web Consortium
(W3C) para el lenguaje XML Schema.
CAPITULO 2.- EL LENGUAJE XML
•
25
XDR (XML-Data Reduced Language, Lenguaje reducido de DatosXML), es un lenguaje implementado por Microsoft para la creación de
esquemas. Estos archivos desarrollados con XDR, se guardan como
documentos XML, con la extensión “.xml”.
La referencia al esquema que va a ser utilizado por el documento XML se efectúa
por medio de una marca colocada justamente antes del comienzo del documento, al
igual que se hace con las declaraciones DOCTYPE para establecer el elemento raíz y la
DTD utilizada. En este caso, se indica el nombre de espacio utilizado por el documento,
por medio del atributo xmlns, asignándole el nombre del archivo del esquema utilizado:
<?xml version= “1.0” encoding= “ISO-8859-1”?>
< ejemplo xmlns = “doc_validacion.xsd ” >
<indice>
.
.
.
</indice>
</ejemplo>
Código 1 .- Doc_validacion.xml
Hacer mención que el espacio de nombres por defecto, utilizado en todo esquema,
se declara en el elemento raíz del documento del esquema XML, es decir, en el archivo
de extensión “.xsd”, asignándole a xmlns la URL http://www.w3.org/2001/XMLSchema.
<?xml version= “1.0” encoding= “ISO-8859-1”?>
< xsd:schema xmlns:xsd= “http://www.w3.org/2001/XMLSchema” >
.
.
.
</xsd:schema>
Código 2 .- Doc_validacion.xsd
Como vemos el elemento raíz es schema, el que introduce la dirección del espacio
de nombres.
CAPITULO 2.- EL LENGUAJE XML
26
2.5.3. Esquemas VS. DTDs
Resumimos a continuación en una lista, las capacidades de validación que se
pueden realizar con un esquema XML y que por otro lado no están permitidas en una
DTD, o en su lugar si están implementadas pero de forma menos estricta:
•
Tipos de datos: controla los tipos de datos que puede contener un
elemento o un atributo (integer, float, boolean, date, time, etc)
•
Aspectos de restricción: establece límites para el valor de los datos
(longitud, enumeración, modelo, intervalos con mínimo y máximo, …)
•
Cardinalidad: controla el número de apariciones permitidas.
•
Opción: limita los valores a los de una lista dada.
•
Secuencia: define el orden en que se pueden utilizar los elementos.
•
Valores predeterminados: proporciona valores que se utilizan cuando
no se especifica ningún otro valor.
Además hay que mencionar que los “esquemas” permiten la definición de datos
abstractos, tipos complejos de datos, con lo cual nos acercamos más a las estructuras de
procesamiento de la información que se están utilizando en la actualidad.
En conjunto, podemos decir, que el uso de “esquemas” presenta grandes ventajas
frente a las DTDs.
2.6
Escribir documentos XML
Ya se ha adelantado la definición de un documento XML como una información
jerarquizada, en forma de texto, que constituye un objeto de datos que puede ser
representado mediante una estructura de árbol.
Para escribir documentos XML no se requiere de utilizar ningún software
específico, es suficiente utilizar cualquier procesador de texto normal. De todos modos
existen a la vez infinidad de programas libres y de pago que nos hacen una visión más
clara del documento, al indexar adecuadamente el texto y utilizar distintos colores para
etiquetas, entre otras funcionalidades.
CAPITULO 2.- EL LENGUAJE XML
27
La representación textual de un documento XML, se puede resumir de la forma:
Texto XML = datos + marcado, es decir, el texto de un documento XML consta de
dos conjuntos disjuntos: marcado y datos.
El marcado son las instrucciones que el procesador XML debe procesar (éstas
marcas se incluyen entre paréntesis angulares: <,>). Los datos son el texto entre la
marca o etiqueta delimitada, en inicio y final por paréntesis angulares.
Todo documento XML debe de cumplir una serie de normas para poder ser
nombrado como tal, estas normas son las que hemos expuesto más arriba y que hacen
que sea un documento bien formado.
Los documentos XML tienen una estructura fija, compuesta por un prologo y un
cuerpo. En el prologo se especifican las características del documento en sí, como la
versión a la cual pertenece la especificación del tipo o estructura al cual debe ajustarse
para ser válido. En el cuerpo se incluye la información propiamente dicha, formada por
el contenido en sí del documento.
2.6.1. Prólogo de un documento XML
Aparece al principio del documento e incluye la declaración propia de un
documento XML y en su caso de las declaraciones de las DTDs o Esquemas XML
utilizados.
2.6.1.1.
Declaración XML
Todo documento XML comienza con un encabezado: <?xml … ?>, al que
normalmente se le añade la versión de XML a la que se ajusta el documento: <?xml
version= “1.1” ?>. A este encabezado también se le suele añadir otro atributo,
encoding, que determina el tipo de codificación del documento, para la interpretación de
los caracteres.
En caso de incluirse éste atributo, los conjuntos más utilizados para el texto con
lenguaje español son: ISO-8859-1 y UTF-8, donde el primero define la codificación del
alfabeto latino, incluyendo los diacríticos (como letras acentuadas, ñ, ç) en nuestro
texto.
CAPITULO 2.- EL LENGUAJE XML
28
Otro atributo que se le puede asignar a este encabezado es standalone, que indica
si se necesita un documento externo (DTD o Esquema XML) para definir la estructura
del documento, con lo que puede tomar los valores de “yes” o “no”.
Un ejemplo que incluya todos estos atributos en el encabezado:
<?xml version= “1.1” encoding=“ ISO-8859-1 standalone=“yes” ?>
Código 3 .- Encabezado XML
En ésta línea de declaración se indica que el documento XML utiliza la versión
1.1, codificación del alfabeto latino y además hacemos uso de un documento externo de
validación.
2.6.1.2. Declaración del documento externo de validación
2.6.1.2.1.
DTD
Una DTD se declara en un documento XML a través de DOCTYPE con la
sintaxis:
<!DOCTYPE nombre SYSTEM (o PUBLIC ) uri>
Código 4 .- Declaración doc. externo validación (DTD)
Señalar que, nombre declara el nombre de la DTD, si la DTD es pública o no
viene expresado en SYSTEM / PUBLIC (desarrollado en un apartado anterior), y con
uri expresamos la que corresponda a éste documento.
2.6.1.2.2.
Esquemas XML
Para indicar que el documento XML está validado por un “Esquema”, debemos
añadir la siguiente línea de declaración en el documento XML:
< nombre_doc xmlns = “nombre” >
Código 5 .- Declaración doc. validación (Schema XML)
CAPITULO 2.- EL LENGUAJE XML
29
Se pasa el nombre de espacio utilizado por el documento, por medio del atributo
xmlns, asignándole el nombre del archivo del esquema XML utilizado o la dirección
web en la que esté dicho esquema.
2.6.2. Cuerpo del documento XML
Constituye el contenido de un documento XML, y en él se puede destacar:
2.6.2.1. Instrucciones de Proceso
Las Instrucciones de proceso (IP) es un mecanismo que permite a los documentos
XML contener instrucciones específicas para las aplicaciones que los van a utilizar, sin
que éstas formen parte de los datos del propio documento.
Una IP se delimita mediante <? y ?>, la declaración <?xml … ?> es una
excepción. La IP empieza con un identificador (acompañado de un valor) denominado
destino que, se usa para identificar la aplicación a la que se dirige. El ejemplo más
común, es utilizar una IP para indicar a la aplicación que el documento se debe mostrar
con una determinada hoja de estilo:
<?xml-stylesheet type= “text/xsl (o text/css)” href.= “hoja_estilo.xsl(o .css)”?>
Código 6 .- Instrucción de Proceso
type especifica el tipo MIME de la hoja de estilo, es decir, la hoja de estilo puede
ser del tipo CSS o XSL. Con Ref. se indica la URI donde se encuentra la hoja que se va a
utilizar.
2.6.2.2. Elementos y atributos
Un elemento es un componente de la jerarquía de un documento, que puede
contener otros elementos. Es decir, es una estructura compuesta de una etiqueta inicial,
su etiqueta final y la información entre las etiquetas, llamado contenido del elemento,
que es texto u otros elementos anidados:
CAPITULO 2.- EL LENGUAJE XML
30
<elemento> Hola </elemento> , en este ejemplo vemos que el
elemento tiene como contenido, la información de texto: hola; siendo por tanto, un
elemento con contenido.
En la siguiente ilustración se ve de forma grafica los componentes de un elemento
con contenido:
Ilustración 3 .- Definición de elemento XML
Si un elemento carece de contenido se le llama elemento vacío, se representa:
<elemento></elemento>, o bien <elemento/> de forma abreviada.. De forma algo más
visual:
Ilustración 4 .- Elemento vacío
El atributo es la forma en la que un elemento incorpora información adicional
sobre él mismo, describiendo propiedades y dando significado a los nodos que
componen el árbol del documento.
Cada atributo tiene su nombre y toma un determinado valor (entre comillas
simples o dobles). Se añaden a la etiqueta de inicio del elemento al que están asociados:
<elemento nombre_atrib1= “valor1” nombre_atrib2= “valor2” >
</elemento>
Código 7.- Elemento con sus atributos
CAPITULO 2.- EL LENGUAJE XML
2.7
31
Procesadores XML
Los procesadores XML son módulos de software utilizados para leer documentos
XML y proporcionar acceso a su contenido y estructura, ya que un archivo XML sin
una herramienta que lo abra y procese, no tiene mucho valor.
Un procesador XML consiste en un módulo de software centrado en:
•
Leer documentos.
•
Comprobar su sintaxis.
•
Informar de posibles errores.
•
Proporcionar acceso tanto a su contenido como a su estructura.
Los principales componentes de un procesador XML son:
•
Los gestores, responsables de localizar los datos que van a pasar al
analizador.
•
El analizador (parser), encargado de leer el flujo de símbolos de entrada
y emitir los símbolos de salida basándose en las reglas gramaticales
correspondientes.
•
El analizador léxico, lee símbolos individuales y emite un símbolo por
palabra basándose en reglas léxicas.
•
El validador, que en caso de ser utilizado comprueba las reglas del
esquema.
Se puede ver como un funcionamiento en serie de los diferentes procesadores
simples, proporcionan a su salida los datos necesarios para el modulo siguiente.
La implementación mínima de un procesador XML está representada por el
analizador, encargado de comprobar que el documento cumpla con las reglas mínimas
de documento XML bien formado. El llamado validador, es también un analizador,
pero en este caso de validación y no de buena formación.
CAPITULO 2.- EL LENGUAJE XML
32
El procesador XML, puede formar parte de una aplicación, como un editor XML,
y ser ejecutado desde ella misma al intentar abrir in documento XML. Otras veces son
invocados desde otra aplicación externa o módulo.
2.8 Conclusiones
XML es una versión de SGML, más sencilla y más fácil de aplicar. Diseñada
precisamente para hacer frente a los problemas de compatibilidad y adaptabilidad de las
nuevas tecnologías.
La diferencia más importante entre HTML y XML, es que HTML es un lenguaje,
mientras que XML es un metalenguaje. XML, permite al diseñador crear sus propias
marcas, especificando su sintaxis y funcionalidad.
Esto es muy útil puesto que las propias marcas pueden ser utilizadas para
identificar contenidos. Se podría decir que XML es un lenguaje casi autodescriptivo.
La representación textual de un documento XML, se puede resumir de la forma:
Texto XML = datos + marcado, es decir, el texto de un documento XML consta de dos
conjuntos disjuntos: marcado y datos.
Los documentos XML, teniendo en cuenta el grado de restricción utilizado para
establecer la estructura y contenido de sus datos, pueden ser de dos tipos: bien formados
y válidos o bien formados y no válidos. La condición de ser un documento válido no
siempre debe de cumplirse.
Para leer los documentos XML y proporcionar acceso a su contenido y estructura
se utilizan los procesadores XML. El procesador XML, puede formar parte de una
aplicación, como un editor XML, o ser invocado desde otra aplicación externa.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
34
3. Tecnologías para la presentación de un
documento XML
3.1 Introducción
La utilización de documentos XML (Extensible Markup Language) resulta
difícilmente accesible en la forma en la que se presentan, por lo que es inevitable
someter a estos documentos a transformaciones para que se adapten y sean útiles en
cada contexto.
En los orígenes de XML, no existía ningún navegador capaz de mostrar
documentos XML sino era más que en simple texto, lo cual era un retraso respecto a
HTML (HyperText Markup Language), el cual sí interpretaba el documento de una
página web y podía traducirlo en texto e imágenes.
No debemos olvidar que XML no es un lenguaje diseñado para la publicación de
documentos, y por tanto, se ha de recurrir a alguna otra tecnología para poder mostrar
los contenidos de dichos documentos.
Con esto surgió una necesidad de tener que transformar dichos documentos XML
para obtener unos resultados que si se adaptarán a los medios y necesidades del usuario.
Entre las distintas posibilidades de transformación, podemos mencionar algunas,
como son:
•
Darle estilo para publicación impresa.
•
Convertirlo en WML (Wireless Markup Language) para su presentación
en terminales WAP (Wireless Application Protocol).
•
Pasarlo a HTML en un determinado tipo de Terminal en la web.
•
Convertirlo en texto plano.
•
Convertirlo a distintos dialectos XML para transferencia de datos en B2B
(Business to Business).
•
Pasarlo a documentos imprimibles como es el formato PDF (Portable
Document Format).
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
35
Resolver el problema de la presentación de un documento XML, no es tarea
sencilla, pero es a la vez imprescindible dicha adaptación, teniendo en cuenta que la
transformación será diferente dependiendo del medio al que se quiera acceder.
Se llega a la necesidad de disponer de herramientas adicionales que ejerzan un
control detallado de la salida del documento. Estas herramientas, son lo que viene a
llamarse las hojas de estilo, con las que podemos resolver el problema de presentar
documentos XML a los distintos medios.
En el siguiente apartado, se ve como una primera opción de dar formato a
documentos XML, el uso de las hojas de estilo CSS (Cascading Style Sheets), y se
expondrán sus desventajas y limitaciones. En el tercer apartado se muestra una segunda
opción, y a la vez la elegida para transformación de documentos XML, utilizar las hojas
de estilo XSL (Extensible Stylesheet Language).
3.2
CSS
Ya desde los comienzos de XML se era consciente de la necesidad de tener que
adaptar su presentación sobre web, y se recurrió a CSS como una tecnología que ya se
aplicaba con éxito a documentos HTML, lo cual no supuso demasiadas complicaciones
para ser adaptada a XML.
La técnica de aplicar las hojas de estilo CSS a documentos XML, es la más
sencilla para publicar estos documentos XML en Internet y logramos separar el
contenido (documento XML con los datos), de la presentación (hoja de estilo), lo cual
era la tarea que se busca.
Las CSS o “Hojas de Estilo en Cascada” se usan igual en XML y en HTML,
aunque la forma de acceder a la hoja de estilo CSS sea distinta. Con la utilización de
estas hojas de estilo, lo que se consigue es poder cambiar el formato de la presentación,
sin que el documento XML sufra ningún cambio.
Con XML se controla la estructura y elementos (etiquetas) que van a ser usados
en el documento, y con CSS se define de forma totalmente personal qué estilos serán
utilizados por cada uno de estos elementos.
La definición de estilos CSS para documentos XML suele ser más laboriosa,
compleja y creativa puesto que no existe ningún tipo de formato predefinido que
podemos ‘aprovechar’, como sucede con los elementos HTML, sino que tenemos que
definir todas las propiedades CSS que queramos utilizar.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
36
El diseñador de documentos XML tendrá que crear desde cero los estilos que
desea aplicar a los documentos; por tanto, deberá ser creativo y metódico en la
definición de las reglas de estilo.
3.2.1. Características y reglas de una hoja CSS
La principal característica de las hojas de estilo CSS utilizadas por los
documentos XML es que el nombre del selector del estilo debe coincidir con el nombre
del elemento XML sobre el cual se va a aplicar, es decir, los nombres de los selectores
serán los mismos que los de los elementos utilizados en el documento XML; de esta
forma, cada regla de estilo siempre estará asociada a un elemento en concreto y se
aplicará el estilo para él definido cada vez que utilicemos su etiqueta en el documento.
La lista de propiedades a aplicar a un documento XML con una hoja de estilo
CSS es bastante amplia y se puede organizar en categorías en función del tipo de
representación visual que alteran. Las categorías más básicas las enumeramos a
continuación:
•
Colores y fondos, cambio de color del fondo de los elementos
•
Fuentes, propiedades con capacidad para manipular las fuentes de texto.
•
Texto, propiedades relacionadas con la alineación, subrayado, espacio
entre palabras, etc
•
Tablas, CSS proporciona un gran soporte para poder construirlas.
•
Bordes, proporciona la forma de dibujar los bordes alrededor de los
elementos que los incorporen.
•
Exhibición, determina la posición y relación mutua entre elementos en un
página
•
Márgenes, propiedad que permite determinar las zonas de la página
donde no se puede poner texto.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
37
El diseñador debe ser metódico en la definición de las reglas de estilo a la hora de
aplicar esta lista de propiedades, las reglas de estilo no deben ser implementadas de una
forma aleatoria, por tanto, un buen método consiste en seguir los siguientes pasos:
•
Establecer el nivel de presentación del elemento, se tiene que ver si es un
elemento de nivel bloque o nivel texto.
•
Establecer las características de la caja, márgenes, bordes, tamaño, …
•
Establecer el color y fondo, que se va a utilizar.
•
Establecer las propiedades de la fuente.
•
Establecer las propiedades del texto.
3.2.2. Enlace a hoja CSS
Para obtener la presentación deseada de un archivo XML, debemos de añadir en el
mismo, una línea de instrucción de proceso (IP), que le indicará al documento XML
donde debe de leer para que adquiera el formato deseado para su representación. Tal
línea es:
<?xml-stylesheet href="estilos.css" type="text/css"?>
Código 8 .- IP para hoja de estilo CSS
La llamada hoja de estilo, será: estilos.css, documento en el que están las reglas
de estilo para obtener la salida deseada del documento origen XML; la referencia a la
hoja de estilo se pasa a través del parámetro href.
Con el parámetro type, se indica el tipo de hoja de estilo para el formato, en este
caso se está utilizando CSS, por tanto es “text/css”.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
38
3.2.3. Limitaciones y desarrollo de las hojas de estilo
CSS
Con la utilización de las hojas de estilo CSS se tienen ciertas limitaciones, como
puede ser el querer adaptarse a distintos medios y no solo a la publicación web para dar
salida a documentos XML.
Existe también la limitación de tener que seleccionar el documento XML en su
conjunto y no solo una parte deseada de ese documento origen. Es debido a estas
limitaciones, por lo que surge una nueva iniciativa por parte de W3C (World Wide Web
Consortium) y es impulsar el llamado lenguaje XSL (Extensible Stylesheet Language).
A pesar del desarrollo de XSL, se ha seguido explotando la idea de emular en
XML lo que CSS hacía en HTML. Con lo que estas hojas de estilo CSS, no han perdido
en su totalidad su función, y se han ido detallando de forma muy amplia, existiendo tres
recomendaciones en este sentido: CSS1, CSS2, CSS3. Todas estas nuevas
recomendaciones que han ido surgiendo, siempre han contado con el objetivo inicial de
separar contenidos y presentaciones.
3.3
XSL
XSL (Extensible Stylesheet Language o Lenguaje de Estilos Extensible) es una
especificación desarrollada dentro del W3C para aplicar formato a los documentos
XML de forma estandarizada, el primer boceto de esta especificación aparece el 18 de
agosto de 1998.
Es un lenguaje basado en XML y especialmente pensado para la publicación de
documentos XML. Al estar basado en XML, las normas de estructuración y sintaxis de
este lenguaje son idénticas a las utilizadas por cualquier otro lenguaje XML.
Las hojas de estilo XSL se almacenan en archivos independientes, con la
extensión .xsl y son enlazadas desde el documento XML de forma similar a como se
hace con las hojas de estilo CSS.
XSL no es un lenguaje para definir estilos como en el caso de CSS o XSL-FO
(XSL Formatting Objects), sino un lenguaje que permite aplicar determinados formatos
ya definidos a documentos XML.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
39
3.3.1. Por qué XSL
Dentro de las carencias de CSS, decir que CSS es incapaz de ejecutar operaciones
lógicas, tales como instrucciones < if – then >, que a veces son necesarias para poder
adaptar un documento a un tipo de presentación en concreto.
Es entonces cuando se tomo conciencia de que las hojas de estilo CSS podían
llegar a ser insuficientes para adaptar archivos XML a los distintos periféricos, y
siguieron nuevos desarrollos. Esto hizo que W3C impulsara un metalenguaje para
expresar hojas de estilo, lo que dio lugar a XSL.
Otra gran razón por la que tomó tanto auge XSL, es que CSS es eficaz para
describir formatos y presentaciones, pero no sirve para decidir qué tipos de datos deben
ser mostrados y cuáles no deben salir en la pantalla. Esto es, CSS se utiliza con
documentos XML en los casos en los que todo su contenido debe mostrarse sin mayor
miramiento.
XSL no solo permite especificar cómo queremos presentar los datos de un
documento XML, sino que también sirve para filtrar los datos de acuerdo a ciertas
condiciones. El XSL añade al XML, además del aspecto que ya incluía CSS referente a
la presentación y estilo de los elementos del documento, una pequeña sintaxis de
lenguaje script para poder procesar los documentos XML de forma más cómoda.
Por otro lado, también mencionar que CSS sigue siendo el método más utilizado a
la hora de presentar documentos XML sobre navegadores web, y aunque no pueda
ejecutar cualquier lógica basada en los datos, sigue también siendo muy útil en
aplicaciones que no precisan de transformaciones importantes.
Además, XSL no es incompatible con las hojas CSS, es decir, podemos utilizar
ambos formatos al unísono para la presentación de los documentos.
3.3.2. Pasos para dar estilo a un documento XML
La idea consiste en utilizar una clase de documentos XML que definen una hoja
de estilo (XSL) y aportan la forma en que un archivo XML debe ser presentado en un
determinado medio. Es decir, llegar a conseguir lo que CSS consigue en la ventana de
un navegador.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
40
Para comenzar, describiremos las etapas en las que se divide el hecho de “dar
estilo” a un documento XML:
1. Transformarlo, existencia de un lenguaje para transformar el documento
XML en cuestión.
2. Darle formato, utilizar un vocabulario XML para la especificación de
una semántica para los formatos de presentación. Algo bastante
complejo, debido a que existen presentaciones muy diversas, al existir
igualmente gran variedad de periféricos.
Debido a esta división de tareas a la hora de dar estilo a un documento XML, la
tecnología XSL está organizada en dos partes:
XSLT (XSL Transform o Transformaciones XSL), lenguaje para
transformar documentos XML.
XSL-FO (XSL Formatting Objects u objetos para Formato de XSL),
vocabulario XML para especificar objetos de formateo (FO) para la
presentación de los documentos. Permite formatear los documentos para
su impresión, es una tecnología para definir estilos de forma similar a las
hojas de estilo CSS.
A ellas, tenemos que añadir XPATH (XML Path Language), que es el lenguaje
que se utiliza para la navegación sobre la estructura de un documento XML, y es por
tanto utilizado para el proceso de transformación de XSLT haciendo referencia a la
forma de acceder y moverse por los nodos de un documento XML. XPath no ha sido
diseñado para utilizarlo de forma independiente sino desde XSLT.
En el siguiente árbol se muestra la jerarquía y la división de estas tecnologías:
Ilustración 5.- Jerarquía XSL
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
41
Mencionar, que en un comienzo, XSL era un único lenguaje para escribir hojas de
estilo y constaba de dos partes: un lenguaje de transformación y un lenguaje de
formateo. Sin embargo, durante su desarrollo, se decidió “sacar” fuera de la
especificación XSL el lenguaje de transformación y desarrollarlo como una
especificación “independiente” a la que se denominó XSLT.
Por tanto, desde entonces la especificación XSL se centraba en la definición del
lenguaje de formateo. Ponemos las palabras “sacar” e “independiente” entre comillas
porque no son del todo ciertas, ya que una especificación es inseparable de la otra
debido a que XSL hace uso de XSLT, aunque la XSLT esté diseñada para ser utilizada
independientemente de XSL.
Además, durante el desarrollo de la especificación XSLT también se decidió
“sacar” fuera de ella la parte del lenguaje de transformación que hacía referencia a la
forma de acceder y moverse por los nodos de un documento XML, debido
esencialmente a que esta sintaxis era muy parecida a la que se estaba desarrollando en la
especificación XPointer (XML Pointer Language), enlaces al interior de un documento
XML. A esta nueva especificación se le denominó XPath, y ha sido desarrollada no para
utilizarse de forma independiente, sino desde XSLT y XPointer.
3.3.3. Creación de hojas de estilo XSL
Los documentos XSL comienzan por una línea de prólogo similar a la que se
utiliza por los documentos XML. En dicha línea se debe de indicar al menos la versión
de XML, en caso de utilización lenguas en las que se utilicen caracteres propios,
también debemos mencionar el tipo de codificación correspondiente.
Ejemplo:
<?xml version= “1.1” encoding= “ISO-8859-1”?>
Código 9 .- Línea de prologo XSL
En este ejemplo, se utiliza la versión 1.1 y una codificación del alfabeto latino, la
cual incluye los diacríticos (como letras acentuadas, ñ, ç) y letras especiales.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
42
La siguiente línea en un documento de hoja de estilo XSL, es la línea de
declaración de la hoja de estilo, que nos sirve para identificar el documento como una
hoja de estilos.
Con el parámetro xmlns:xsl (XML Namespace), se establece el nombre de
espacio, en el cual se encuentra definida la versión de XSL que utilizaremos en nuestra
hoja de estilos.
El Namespace para XSL tiene la URI (Uniform Resource Identifier)
http://www.w3.org/1999/XSL/Transform
La sintaxis de esta instrucción es:
<?xsl:stylesheet xmlns:xsl= “URI” version="1.0">
Código 10 .- Línea de declaración XSL
El “1999” en la URI indica el año en que ésta URI fue destinada por W3C, y no la
versión de XSL que se está usando. Dicha versión viene definida en esta misma línea de
declaración pero como atributo, en el ejemplo se puede ver como se hace uso de la
versión 1.0.
La tercera línea que puede aparecer en un documento XSL, es la declaración
<xsl:output>, que aunque opcional, representa un elemento XSL que define el tipo de
contenido y características del documento que será generado al ser realizada la
transformación, en este caso se está indicando que la transformación será un documento
tipo HTML:
<xsl:output method="html" version="4.0" encoding="ISO-8859-1"/>
Código 11 .- Declaración del documento de salida
La declaración, además de indicarnos el tipo de documento a generar, viene
acompañada de los atributos que definirán más aun dicha transformación.
Las siguientes líneas del documento XSL son las definiciones de las distintas
plantillas (templates) que utilizaremos para la transformación del documento XML.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
43
Todos los documentos XSL se han de cerrar con la etiqueta: </xsl:stylesheet>, la
cual cierra la línea de declaración de la hoja de estilo, que nos habíamos dejado abierta
al comienzo del mismo archivo.
3.3.4. Templates
Las hojas de estilo XSL se basan en la definición de plantillas (templates), cada
una de las plantillas definidas debe de estar relacionada con algún elemento existente en
el documento XML; sobre dicho elemento se aplican las transformaciones y formatos
definidos en la hoja de estilo y más concretamente en las plantillas o templates.
La relación entre la plantilla (template) y el elemento XML, se establece por
medio del parámetro match existente en toda plantilla y en el cual se asigna la ruta (por
medio de XPath) que el elemento XML tiene en la estructura de su documento XML.
Tipos de plantillas:
•
Plantilla raíz, existe en todas las hojas de estilo y está relacionada con el
elemento raíz del documento XML; establece la forma en que ha de
efectuarse la transformación genérica de dicho documento XML. El
parámetro match tomará la ruta: match = “/”.
•
Plantillas definidas por el programador, para determinados elementos
del documento XML se implementa la transformación propia que
deseamos realizar. Es la que el programador define personalmente por
medio de templates en la hoja de estilo XSL.
•
Plantillas predefinidas, pueden existir en algunas aplicaciones y se
aplicarán de forma automática a todos aquellos elementos del documento
XML que no tengan plantillas definidas en la hoja de estilo XSL.
La declaración de una plantilla se realiza por medio de la instrucción XSL:
<xsl:template>, en la cual establecemos la ruta de acceso al elemento relacionado con la
plantilla por medio del parámetro match como ya hemos mencionado.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
44
La sintaxis genérica de la definición de una plantilla sería:
<xsl:template match = “ruta de acceso XPath” >
.
.
</xsl:template>
Código 12 .- Definición de Plantilla
3.3.5. Enlace a hoja XSL
La manera enlazar el documento XML con la hoja de estilo XSL, hoja de estilo de
la que se ayuda para poder presentar sus datos sobre cualquier medio, es mediante la
instrucción de proceso (IP):
<?xml-stylesheet href="estilo.xsl" type="text/xsl"?>
Código 13 .- IP para hojas de estilo XSL
La única diferencia que lo separa de la manera de indicarle que lea de un archivo
“.css”, es que se le pasa la hoja de estilo con la extensión adecuada, en este caso href
tiene extensión “.xsl”.
Igualmente, con el atributo type, le indicamos el tipo de contenido del archivo con
el que enlaza, en este caso está escrito en XSL, type= “text/xsl”.
3.4
Conclusiones
La utilización de documentos XML resulta difícilmente accesible en la forma en
la que se presentan, por lo que es inevitable tener que someter a estos documentos a
transformaciones.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
45
Resolver el problema de la presentación de un documento XML, no es tarea
sencilla, teniendo en cuenta que la transformación será diferente dependiendo del medio
al que se quiera acceder. La herramienta para dicha transformación es las hojas de
estilo.
Las hojas de estilo CSS son eficaces para describir formatos y presentaciones,
pero tienen ciertas limitaciones respecto a XSL como:
•
No sirve para decidir qué tipos de datos deben ser mostrados y cuáles no
deben salir en la pantalla.
•
CSS es incapaz de ejecutar operaciones lógicas, tales como instrucciones
<if - then>, necesarias para adaptar un documento a un tipo de
presentación en concreto.
•
Las hojas de estilo CSS son insuficientes para adaptar archivos XML a
los distintos periféricos.
Debido a estas deficiencias de las hojas de estilo CSS, se escoge la tecnología
XSL para la presentación de documentos XML en distintos medios.
El hecho de “dar estilo” a un documento XML procesado con hojas de estilo
XSL, lleva consigo dos etapas: transformar el documento XML y darle formato a ese
documento de salida. Por eso la especificación XSL se divide en dos:
•
XSLT, es la especificación que desarrolla el lenguaje de transformación
de un documento de entrada XML en algún tipo de documento de salida,
ya sea XML, HTML, texto plano, etc.
XSLT hace uso de la especificación XPath y ha sido diseñado para ser
utilizado de forma independiente aunque sea utilizado desde la
especificación XSL.
•
XSL-FO, se encarga de dar formato, es decir, de definir la visualización
final del resultado de la transformación realizada por XSLT.
XPath, es la especificación que desarrolla el lenguaje para acceder a los
elementos de un documento XML. Ha sido desarrollada para ser utilizada desde XSLT.
CAPITULO 3.- PRESENTACIÓN DE UN DOCUMENTO XML
46
Es de aclarar que XSL, es la especificación que desarrolla el lenguaje de formateo,
y hace uso de la especificación XSLT para la transformación. Por tanto, XSL y XSLFO obedecen a la misma especificación.
De una forma global podemos decir que la utilización de XSL lleva entonces a un
marco en el que:
•
Los datos se transforman, filtran y ordenan.
•
Las partes de un documento se definen.
•
Se da formato a los datos basándose en sus valores.
•
Podemos dar una salida por XML a diferentes medios tales como
pantalla, papel, voz, terminal móvil,…
Mediante XSLT y XSL-FO se puede generar la salida del contenido de un
documento XML en cualquier formato de publicación, como puede ser texto plano,
XHTML, HTML, WML, PDF, RTF (Rich Text Format), SVG (Scalable Vector
Graphics).
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
48
4. El Lenguaje de Caminos XPATH
4.1 Introducción
XPath (XML Path Language o Lenguaje XML de rutas), es el lenguaje utilizado
para establecer el camino a seguir hacia un determinado elemento en la jerarquía de
elementos de un documento XML (Extensible Markup Language). XPath obtiene su
denominación por el uso que hace de una notación de caminos para navegar a través de
la estructura jerárquica de un documento XML.
XPath se convirtió en estándar con una Recomendación del W3C (World Wide
Web Consortium) el 16 de Noviembre de 1999. XPath no fue diseñado para su uso
individual, sino para su utilización conjunta con otras tecnologías como es el caso de
XSLT (XSL Transform) y XPointer (XML Pointer Language).
XPath es el resultado para proporcionar una sintaxis y semántica comunes para
funcionalidades compartidas entre XSLT y XPointer. El objetivo principal de XPath es
direccionar partes de un documento XML.
Además de su uso fundamental, XPath está diseñado también de modo que puede
usarse para comprobar si un nodo de la estructura del documento XML encaja con un
patrón de estilo o no; tal uso es del hecho de su unión con XSLT.
XPath sirve para decir cómo debe procesar una hoja de estilo el contenido de una
página XML, pero también para poder poner enlaces o cargar zonas determinadas de
una página XML, en vez de toda la página, característica diferenciadora de XSL
(Extensible Stylesheet Language) respecto a las hojas de estilo CSS (Cascading Style
Sheets).
Con XPath podremos seleccionar y hacer referencia a texto, elementos, atributos y
cualquier otra información contenida dentro de un fichero XML.
En el apartado segundo de este capítulo, se introduce el modelo de datos en
XPath. En los dos siguientes apartados se verá por qué XPath no modela un Path
común, y se estudiará la sintaxis y funcionamiento de los trayectos de búsqueda.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
49
4.2 Modelo de Datos en XPath: Árbol y nodos
XPath opera sobre un documento XML considerándolo como un árbol, pero este
modelo es solamente conceptual y no impone ninguna implementación en particular.
Al ser el objetivo principal de XPath dirigirse a una parte del documento XML,
hay que facilitar la posibilidad de moverse a través de él, acción que se lleva a cabo
utilizando la ya comentada estructura jerárquica en árbol.
Además se debe de contar con un mecanismo que permita al lenguaje XPath
seleccionar información del documento objeto del procesamiento.
XPath al tratar a todo documento XML como un árbol, siempre cuenta con la
capacidad de saber si un nodo de este árbol se ajusta a la expresión XPath que se utilice
en cada momento. Vemos un ejemplo de documento XML, construido en forma de
árbol por XPath:
Ilustración 6 .- Árbol XPath
Para seleccionar partes de un documento XML, XPath construye internamente, el
árbol de nodos, donde a partir del nodo raíz, el propio documento se diversifica a lo
largo de los elementos hasta los nodos hojas, que contienen solo texto, comentarios,
instrucciones de proceso o incluso pueden estar vacíos y solo tener atributos.
Un caso especial de nodo son los nodos atributo. Un nodo puede tener tantos
atributos como desee, y para cada uno se le creará un nodo atributo. No obstante, dichos
nodos atributo no se consideran como hijos suyos, sino más bien como etiquetas
añadidas al nodo elemento.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
50
Los nodos de un árbol XPath pueden ser de siete tipos diferentes:
•
Raíz
•
Elemento
•
Atributo
•
Texto
•
Comentario
•
Instrucción de proceso
•
Espacio de nombres
En este árbol cada nodo intermedio contiene listas ordenadas de nodos hijos,
siendo la relación entre un nodo padre y un nodo hijo que el primero contiene al
segundo. Por ello, además del nodo raíz, solo pueden tener hijos los nodos: elemento,
comentario, texto e instrucción de proceso. Los nodos atributo y espacio de nombres se
consideran que sólo describen a su nodo padre, por lo que se asume que no contienen
ningún nodo.
Veamos con más detalle los diferentes tipos de nodos:
•
Nodo raíz, se identifica por “/”, y no se debe confundir el nodo raíz
con el elemento raíz del documento XML, de hecho el nodo raíz del
árbol contiene al elemento raíz del documento.
•
Nodo elemento, cada uno de los nodos elementos tienen un nodo
padre. Cualquier elemento de un documento XML se convierte en un
nodo elemento dentro del árbol.
El nodo padre de cualquier elemento es, a su vez, un elemento, excepto
el elemento raíz, cuyo padre es el nodo raíz. Los nodos elemento tienen
nodos hijos, que son: nodos elemento, nodos texto, nodos comentario y
nodos de instrucciones de proceso.
Los nodos elemento también tienen propiedades tales como su nombre,
sus atributos e información sobre los "espacios de nombre" que tiene
activos.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
51
•
Nodos atributo, no son hijos del nodo elemento que los contiene,
sino que son etiquetas añadidas a dicho nodo elemento. Cada nodo
atributo consta de un nombre, un valor y un posible "espacio de
nombres".
•
Nodos texto, son los caracteres del documento que no está
marcados con alguna etiqueta; un nodo texto no tiene hijos.
•
Nodos de comentario y de instrucciones de proceso, en el árbol
también se generan nodos para cada nodo con comentarios y con
instrucciones de proceso.
4.3 Un Path diferente
XPath utiliza como expresión patrón para identificar los nodos del documento,
una expresión que puede comenzar o no por el carácter barra “/ ”, seguido de una lista
con los nombres de los nodos hijos que describen un recorrido a través del documento,
de forma que tiene la capacidad para seleccionar los sucesivos elementos que se ajustan
al mismo.
En el sentido semántico, la sintaxis XPath tiene una estructura tal como la del
siguiente ejemplo:
/biblioteca/libro/autor
Código 14 .- Sintaxis XPath
Donde la expresión XPath tiene unas ciertas características a destacar:
•
Con la expresión de ejemplo anterior, hacemos referencia a todos los
elementos autor que cuelguen directamente de cualquier elemento libro
que cuelgue directamente de cualquier elemento biblioteca, que a su vez
cuelguen del elemento raíz.
•
XPath no devuelve los elementos que cumplen con el patrón que
representa cada expresión, sino que devuelve una referencia, es decir,
una lista de punteros a los elementos que encajan con el patrón de
localización. Esta lista de resultados de la ejecución de la expresión,
puede estar vacía o contener uno o varios nodos del árbol XPath
correspondiente.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
52
Son estas características comentadas, las que hacen que el término Path que
obedece a la estructura que crea XPath, esté inspirado en el tradicional “File Path”,
pero por el contrario se destaque que la semántica de XPath es distinta a la de una ruta
de acceso a carpetas o archivos tradicional.
Veamos un ejemplo más claro para ver esta característica propia de XPath y que
tanta ventaja puede llevar a darnos. Tenemos una serie de libros que pertenecen a una
biblioteca y cada uno tiene sus propias características:
<?xml version="1.0" encoding="UTF-8"?>
<biblioteca>
<libro numero="1">
<nombre>Java y XSLT</nombre>
<autor>Eric M. Burke</autor>
</libro>
<libro numero="2">
<nombre>Beginning XSLT 1.0</nombre>
<autor>Jeni Tennison</autor>
</libro>
<libro numero="3">
<nombre>XSLT Qickly</nombre>
<autor>Bob Ducharme</autor>
</libro>
<libro numero="4">
....
</libro>
.....
</biblioteca>
Código 15 .- Ejemplo XPath
En el caso de escribir la secuencia: /biblioteca/libro/autor en el marco adecuado
que haga referencia a este documento, XPath acabará seleccionando todos los autores de
todos los libros que pertenecen a la biblioteca.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
4.4
53
Caminos de Localización (Location Path)
La construcción sintáctica básica en XPath es la expresión. Las expresiones son
evaluadas para producir un objeto, que será uno de los siguientes cuatro tipos básicos:
•
Conjunto de nodos (colección desordenada de nodos)
•
Número (número en punto flotante)
•
Booleano (verdadero o falso)
•
Cadena (secuencia de caracteres)
La evaluación de expresiones tiene lugar respecto a un contexto. XSLT y
XPointer especifican como se determina el contexto para las expresiones XPath.
Un tipo importante de expresión es el camino de localización o también llamado
trayecto de búsqueda. Un camino de localización selecciona un conjunto de nodos de
la estructura relativo al nodo de contexto. El resultado de evaluar una expresión que sea
un camino de localización es el conjunto de nodos seleccionados por el camino de
localización.
Hay dos tipos de caminos de localización: caminos de localización relativos y
caminos de localización absolutos, es decir, la identificación del camino puede ser
absoluta o relativa; en base al raíz o en base al nodo actual (es una dirección absoluta si
empieza por “/”, y relativa cuando no sea así).
Un location path siempre tiene un punto de partida llamado nodo contexto, es
decir, es el nodo del árbol XPath del documento XML desde el que se inicia el trayecto
de búsqueda de elementos o nodos del árbol.
Los caminos de localización pueden ser:
•
Un camino de localización relativo consiste en una secuencia de
uno o más pasos de localización separados por “/”. Los pasos en un
camino de localización relativo se componen de izquierda a derecha.
Cada paso selecciona un conjunto de nodos relativos a un nodo
contextual.
Una secuencia inicial de pasos se une al paso siguiente de la forma que
ahora se explica. La secuencia inicial de pasos selecciona un conjunto de
nodos relativos a un nodo de contexto.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
54
Cada nodo de ese conjunto se usa como nodo de contexto para el
siguiente paso. Los distintos conjuntos de nodos identificados por ese
paso se unen. El conjunto de nodos identificado por la composición de
pasos es dicha unión.
•
Un camino de localización absoluto consiste en “/” seguido
opcionalmente por un camino de localización relativo. Una “/” por si
misma selecciona el nodo raíz del documento que contiene al nodo
contextual. Si es seguida por un camino de localización relativo,
entonces el camino de localización selecciona el conjunto de nodos que
seleccionaría el camino de localización relativo al nodo raíz del
documento que contiene al nodo contextual.
Sea absoluto o relativo, un trayecto o camino de localización, consiste en una
serie de escalones, que podemos llamar pasos, separados por el carácter barra (“/”), de
forma que:
•
Un trayecto de búsqueda absoluto es de la forma:
/paso/paso/…
•
Mientras, que un camino de localización es relativo cuando es de la
forma:
paso/paso/…
4.4.1. Elementos de un Camino de Localización
Si recordamos, el camino o trayecto de búsqueda, se compone de uno o más
pasos, que se escriben separados por barras. Un camino absoluto empieza por barra, y
uno relativo no.
Ahora bien, un paso se describe con hasta tres elementos: eje, test de nodo, y
predicado. Cada paso y elemento de selección selecciona un nuevo conjunto de nodos a
partir del anterior, empezando por el conjunto formado por el nodo de contexto (camino
relativo) o el nodo raíz (camino absoluto).
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
55
La sintaxis es:
camino absoluto
camino_relativo
paso
:: = /camino_relativo
:: = paso/paso/ …
::= eje::test_de_nodo[predicado]
Ilustración 7 .- Sintaxis completa de un Camino de Localización
Por tanto, resaltar que la sintaxis de localización en XPath, en cuanto a un único
paso se refiere, podemos expresarla:
nombre_eje :: test_de_nodo [ predicado]
Código 16 .- Sintaxis de un “Paso” de Localización
Vamos a desarrollar de aquí en adelante cada uno de estos tres elementos que
componen cada uno de los pasos de un Camino de Localización en XPath.
4.4.1.1. Ejes
nombre_eje :: test_de_nodo [ predicado]
Código 17 .- Eje
Un eje representa una relación con el nodo de contexto, y se utiliza para localizar
nodos relativos a ese nodo en el árbol, es decir, especifica la relación entre los distintos
nodos que quieren seleccionarse en el trayecto de búsqueda, y el nodo contexto desde el
que se parte.
En XPath existen 13 tipos de ejes, se van a clasificar de acuerdo al sentido de su
dirección, ya sea hacia delante o hacia detrás.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
56
Hacia delante se tienen los siguientes ejes:
•
Child
Indica el hijo del nodo de contexto, y se expresa de la forma: /child::, con
forma abreviada: “/” (se corresponde con la barra). Si una expresión XPath no
especifica un eje, se entiende éste por defecto. Ya que sólo los nodos raíz o los
nodos elementos tienen hijos, cualquier otro uso no seleccionará nada.
•
Attribute
Indica los atributos del nodo de contexto; este eje se puede abreviar con el
signo “@” como prefijo del elemento buscado, mientras que su forma larga es:
attribute::. Sólo los elementos tienen atributos.
•
Descendant
Indica todos los hijos del nodo contexto, y todos sus hijos y así
sucesivamente, se expresa de la forma: //descendant::, palabra que puede
evitarse pues siempre se asume por defecto tras “//”. No se incluyen los
atributos y namespaces.
•
Descendant-or-self
Indica el nodo de contexto y todos sus descendientes. No se incluyen los
nodos atributos y namespaces. El “parent” de un nodo attribute es un nodo
elemento, pero los nodos attribute no son los hijos de sus padres.
•
Following
Indica todos los nodos que aparecen después del nodo de contexto, excepto
cualquier nodo descendant, attribute y namespace.
•
Following-sibling
Indica todos los nodos que tienen el mismo padre que el nodo de contexto
y aparecen después del nodo de contexto en el documento de origen.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
•
57
Namespace
Indica todos los nodos que están en el ámbito del nodo de contexto. En
este caso, el nodo de contexto debe tener un nodo elemento.
•
Self
Es muy útil e indica el nodo de contexto en sí mismo. Se puede abreviar
con un solo punto “.”.
Por otra parte, los ejes hacia atrás son:
•
Parent
Indica el único nodo que es el padre del nodo de contexto. Se puede
abreviar con dos puntos “..”.
•
Ancestor
Indica todos los antecesores del nodo de contexto comenzando con el nodo
padre y viajando hacia el nodo raíz, de todos los ejes que podemos usar, este es
el único que no tiene ninguna forma de abreviación, sino que hay que ponerlo
como ancestor::.
•
Ancestor-or-self
Indica el nodo de contexto y todos sus antecesores, incluyendo el nodo
raíz.
•
Preceding
Indica todos los nodos que preceden al nodo de contexto en el documento
excepto cualquier nodo ancestor, attribute y namespace.
•
Preceding-sibling
Indica todos los nodos que tienen el mismo padre que el nodo de contexto
y aparecen antes que el nodo de contexto en el documento de origen.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
A modo de resumen se expone a continuación una tabla con cada uno de estos
ejes y una breve explicación:
ancestor: nodo padre, abuelo, etc.
ancestor-or-self: nodos ascendientes o el mismo nodo
parent: nodo padre
self: el mismo nodo
child: nodos hijos
descendant: nodos hijos, nietos, etc.
descendant-or-self: nodos descendientes o el mismo nodo
preceding-sibling: hermanos anteriores (hijos anteriores del mismo padre)
preceding: nodos anteriores en el orden lexicográfico
following-sibling: hermanos siguientes (hijos siguientes del mismo padre)
following: nodos posteriores en el orden lexicográfico
attribute: atributos
namespace: espacio de nombres
Ilustración 8 .- Descripción Tipos de Ejes XPath
58
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
59
En el siguiente árbol, podemos ver de una forma gráfica la relación entre estos
ejes:
Ilustración 9 .- Relación entre los Ejes de XPath
4.4.1.2. Nodos de comprobación o búsqueda (node test)
nombre_eje :: test_de_nodo [ predicado]
Código 18 .- Test de Nodo
Los nodos de comprobación o búsqueda, también llamados nodos test, son los
encargados de identificar un nodo o nodos concretos dentro de un eje. Su función dentro
del trayecto de búsqueda es que cada eje pueda determinar un tipo de nodo a la hora de
efectuar la selección.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
60
El test de nodo filtra la selección hecha por el eje en función del nombre y/o tipo
de nodo. En las siguientes definiciones el término elemento se refiere a nodos elemento
(si el eje lo permite), o bien a nodos del tipo particular establecido por el eje:
•
nombre: elemento con ese nombre
•
*: elemento con cualquier nombre
•
comment(): nodo de comentario
•
text(): nodo de texto
•
processing-instruction(target): instrucción de procesamiento con ese
nombre
•
namespace:nombre: espacio de nombres con ese nombre
•
node(): cualquier nodo
4.4.1.3. Predicado
nombre_eje :: test_de_nodo [ predicado]
Código 19 .- Predicado
Finalmente, el predicado es una expresión que debe cumplirse para que un nodo
sea seleccionado. La expresión puede usar operadores y funciones. Las expresiones
utilizables en XPath se componen de operandos, operadores e invocaciones de
funciones. Los elementos básicos son:
•
Operandos: nodos, conjuntos de nodos, valores numéricos, booleanos y
de texto
•
Operadores aritméticos: suma, resta, división, multiplicación, módulo
(+, -, div, *, mod).
•
Operadores lógicos: and, or, | .
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
•
Operadores de relación: =, !=, <, <=, >, >=
•
Caminos de selección, para extraer conjuntos de nodos
•
Paréntesis, para agrupar términos: ()
•
Funciones predefinidas
61
o
Funciones booleanas: not() true() false() boolean() ...
o
Funciones numéricas: number() sum() ...
o
Funciones de nodos: position() last() count() name() ...
o
Funciones de texto: string() concat() substring() string-length()
normalize-space() ...
4.4.2. Sintaxis abreviada
Todo camino de localización se puede expresar utilizando una sintaxis directa,
aunque no es lo más común, debido a que la notación de selección tal y como se ha
descrito en el apartado anterior resulta muy farragosa.
Es por ello, que se ha previsto de ciertas abreviaturas sintácticas que permiten
expresar los casos más frecuentes y que son más útiles y de una forma más ligera.
Aunque ya se han visto algunos de estos casos, se exponen a continuación algunos
ejemplos de caminos de localización usando la sintaxis abreviada:
La abreviatura más importante es que child:: puede ser omitida en un paso de
localización. A efectos prácticos, child es el eje por defecto.
autor , es abreviatura de:
child:: autor
Código 20 .- Abreviatura de Child::
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
62
Hay también una abreviatura para atributos, attribute:: puede abreviarse como
“@”. Estaremos seleccionando con: “@numero” el atributo numero del elemento
que se exponga.
Por ejemplo, un camino de localización:
libro[@numero="3"] , es abreviatura de
child::libro[attribute::numero="3"]
Código 21 .- Abreviatura de Atributo
Se está seleccionando los hijos libro con un atributo numero con valor igual
a 3.
Otra abreviatura importante es “//”, la cual proviene de “ /descendant-orself::node()/”. Con este operador se seleccionarán todos los elementos del
documento que cumplan los criterios con independencia del nivel que ocupen en
el árbol.
Por ejemplo,
//libro , es abreviatura de
/descendant-or-self::node()/child::libro
Código 22 .- Abreviatura descendant-or-self::node()
Selecciona cualquier elemento libro en el documento (incluso un elemento
libro que sea el elemento de documento será seleccionado por //libro , ya que el
nodo elemento de documento es hijo del nodo raíz).
Un paso de localización “.” , es abreviatura de self::node(). Esto es
particularmente útil en conjunción con “//”.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
63
Por ejemplo, el camino de localización:
.//libro , es abreviatura de
self::node()/descendant-or-self::node()/child::libro
Código 23 .- Abreviatura self::node()
Se seleccionan todos los descendientes elementos libro del nodo contextual.
Análogamente, un paso de localización “..” , es abreviatura de parent::node() y
selecciona el padre del nodo contextual.
Por ejemplo,
../libro , es abreviatura de
parent::node()/child::libro
Código 24 .- Abreviatura parent::node()
Selecciona los hijos libro del padre del nodo contextual.
La siguiente tabla muestra las abreviaturas más utilizadas:
Notación extendida
child::
parent::
self::
/descendant-or-sef::
[position() = n]
attribute::
Notación abreviada
Se puede omitir
..
.
//
[n]
@
Ilustración 10 .- Tabla abreviaturas Pasos XPath
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
64
4.5 Conclusiones
Ante la necesidad de XSLT de tener que acceder a la estructura de datos XML
para realizar la transformación, se hizo necesario un nuevo lenguaje que toma el nombre
de XPath.
XPath está orientado a direccionar partes de un documento XML, además de
también usarse para comprobar si un nodo de la estructura del documento XML encaja
con un patrón de estilo o no; tal uso es del hecho de su unión con XSLT.
XPath cuando opera sobre un documento XML construye internamente un árbol
de nodos a partir del documento XML origen. Los nodos de un árbol XPath pueden ser
de siete tipos diferentes:
•
Raíz
•
Elemento
•
Atributo
•
Texto
•
Comentario
•
Instrucción de proceso
•
Espacio de nombres
La estructura de acceso que crea XPath, está inspirada en el tradicional “File
Path”, pero la semántica de XPath es distinta a la de una ruta de acceso a carpetas o
archivos tradicional.
Cuando en XPath se hace referencia a un nombre de elemento XML, se hace a
todos los elementos que cumpliendo esa ruta XPath tengan ese nombre. Además, XPath
no devuelve los elementos que cumplen con el patrón que representa cada expresión,
sino que devuelve una referencia, es decir, una lista de punteros a los elementos que
encajan con el patrón de localización.
La construcción sintáctica básica en XPath es la expresión y un tipo importante
de expresión es el camino de localización o también llamado trayecto de búsqueda,
que selecciona un conjunto de nodos de la estructura relativo al nodo de contexto.
CAPITULO 4.- EL LENGUAJE DE CAMINOS XPATH
65
El camino o trayecto de búsqueda, se compone de uno o más pasos, que se
escriben separados por barras. Un camino absoluto empieza por barra, y uno relativo no.
Cada paso se describe con hasta tres elementos: eje, test de nodo, y predicado.
Todo camino de localización se puede expresar utilizando una sintaxis directa,
aunque no es lo más común, por eso, se ha previsto de ciertas abreviaturas sintácticas
que permiten expresar los casos más frecuentes de una forma más ligera.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
67
5. El lenguaje de transformación XSLT
5.1 Introducción
XSLT (Extended Styleshet Language Transformation), es un estándar de la
organización W3C (World Wide Web Consortium). Es un lenguaje diseñado para
transformar un documento XML (Extensible Markup Language), en un nuevo
documento XML o en cualquier otro tipo de documento estructurado. XSLT se apoya
en XPath (XML Path Language) para realizar consultas sobre el documento origen
XML, a fin de especificar una parte concreta de dicho documento.
XSLT está basado en el lenguaje XML, y debe seguir a su vez todas las reglas que
ello implica.
Tendremos a nuestra disposición por un lado, todos los elementos y funciones que
define XSLT, y por otro la sintaxis y funciones propias de XPath.
La hoja de estilo que realiza la transformación tiene la extensión “.xsl” y una vez
definida funcionará con cualquier procesador XSLT escrito en cualquier lenguaje y
ejecutado en cualquier entorno.
La potencialidad e importancia del lenguaje XSLT, es poder publicar en muy
diferentes medios un mismo documento fuente con datos XML, simplemente utilizando
una hoja de estilo adecuada para cada dispositivo de salida.
En los dos siguientes apartados introduce el significado de “Proceso de
transformación XSLT”, y se exponen las principales características de éste lenguaje. En
posteriores apartados, se estudiará el modelo XSLT y la estructura de sus documentos,
concluyendo en un sexto apartado con la definición de la hoja de estilo XSLT.
5.2 Transformación de documentos XML
La motivación del lenguaje de transformación XSLT, es tener la posibilidad de
someter a documentos de datos XML a una transformación, especificada en la llamada
hoja de estilo, con el propósito de conseguir una salida deseada y en un medio
adecuado.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
68
El lenguaje de transformación XSLT precisa definir qué transformaciones se
quieren hacer y a qué partes del documento. Para lo primero el propio XSLT define
unos elementos o reglas de plantilla que alimentan a un procesador o motor de XSLT, el
cual realiza las transformaciones deseadas. A su vez dichas reglas, especifican cómo
debe aparecer cada nodo del documento XML origen en el documento destino.
Para seleccionar a qué partes del documento origen XML vamos a hacer las
transformaciones, XSLT se basa en la sintaxis que define XPath.
En el siguiente diagrama se ilustra de manera gráfica el proceso de
transformación:
Ilustración 11 .- Proceso de Transformación XSLT
En el proceso de transformación se selecciona el documento XML, se le aplica la
hoja XSL de transformación a los nodos del documento XML seleccionado por medio
del procesador XSLT, y como resultado se genera un documento de salida con el
formato que se haya especificado.
Éste documento resultado puede ser de muy distinta naturaleza al original XML,
puede obtenerse un documento: WML (Wireless Markup Language), HTML
(HyperText Markup Language), texto plano, incluso otro documento XML. Pero
siempre será un documento estructurado basado en texto.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
69
5.3 Principales características de XSLT
La sintaxis de XSLT es la misma que la de XML, y su vocabulario consta de
etiquetas reservadas que realizan funciones especiales sobre el documento fuente a la
hora de invocarla. Es por tanto, al existir tal variedad de etiquetas, que no sea una labor
inmediata usarlo con facilidad.
Las principales características del lenguaje XSLT se pueden resumir en los
siguientes puntos:
1. Como lenguaje XML, está constituido por una larga lista de elementos y
a la hora de definir las hojas de estilo se incorporan todas las
posibilidades que ofertan los esquemas XML.
2. Cuenta con recursos para comprobar su ajuste a las plantillas (template
rules) definidas en las hojas de estilo, y por tanto, facilitando que se
dispare la regla que proceda a la transformación correspondiente.
3. Para facilitar la búsqueda en los nodos del documento fuente XML, la
larga lista de funciones que se encuentran definidas, usan expresiones
XPath. Ésta relación entre XSLT y XPath es muy importante.
4. El funcionamiento de XSLT se basa en la combinación de dos
documentos, el fuente XML y la hoja de estilo XSL, es por tanto
obligado, incluir en el primero la Instrucción de Proceso que
desencadenará el proceso de forma que a partir de su ejecución, el
procesador XSLT junto con la hoja de estilo, recorre el árbol fuente
siguiendo el método de primero en profundidad, para luego agrupar a los
elementos, reordenarlos y finalmente proceder a la copia del texto de los
nodos apropiados en el documento resultado.
5. En todo momento del proceso, se tienen controlados los siguientes ítem:
•
El nodo contexto.
•
La posición y tamaño del contexto.
•
Los espacios de nombres que estén en la panorámica de la
expresión utilizada.
•
La biblioteca de funciones disponible.
•
El conjunto de variables asociadas al espacio de nombres.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
70
5.4 Modelo y Procesado de XSLT
El documento original XML queda representado por un árbol en el que:
•
La raíz del árbol, es el elemento raíz
•
Los hijos de un nodo, son los elementos contenidos en él
Se designa con el nombre constructor, al programa que una vez evaluados los
nodos o elementos del documento XML, obtiene a partir de ellos, según las reglas de
construcción de la hoja de estilo, una parte del árbol resultado.
Las reglas en XSLT, se dividen en dos partes:
1. Se buscan los elementos del árbol fuente que se ajustan al patrón dado,
para ello se recurren a expresiones XPath.
2. La plantilla junto con el constructor, construyen una parte del árbol
resultado.
Podemos deducir de lo anteriormente expuesto, que la estructura del árbol
resultado puede ser sensiblemente diferente a la del árbol fuente, debido a que para la
construcción de éste nuevo árbol, se ha podido filtrar nodos del árbol fuente y han
podido sufrir alguna reordenación, incluso se han podido añadir nuevas estructuras al
árbol.
Ilustración 12 .- Árbol resultado de la Transformación
Como se ve en la figura anterior, la entrada XML se transforma en algo llamado
árbol resultante. Este árbol podría ser otro fichero XML, una página HTML, o incluso
un fichero de texto normal. Nada une la entrada XML con la hoja de estilo XSLT, por
eso hay una clara separación entre los datos y el formato.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
71
Esta separación supone un gran beneficio porque podemos fácilmente dirigirnos a
varios tipos de documentos destino con más que hacer cambios en la hoja de estilo, sin
tocar los datos. Esto es mucho más atractivo que la aproximación tradicional que
requiere cambios en la lógica de programación para soportar múltiples objetivos.
Se puede concluir diciendo que se trabaja con dos árboles, el árbol fuente del
documento XML, al que se le aplica la transformación, y el árbol resultado que se
quiere obtener al hacer la transformación.
Ilustración 13 .- Obtención árbol resultado
Una misma hoja de estilo puede ser aplicada a documentos origen distintos,
siempre que tengan parte de estructuras semejantes entre sí. De aquí, puede deducirse
que una hoja de estilo puede construirse con autonomía del documento que vaya a
transformar.
5.4.1. Procesadores XSLT
Para poder obtener los resultados de las transformaciones definidas en una hoja de
estilo, es necesario utilizar un procesador XSLT que implemente las especificaciones
XSL Transform. Es decir, un procesador XSLT nos permite convertir un documento
XML en cualquier tipo de documento estructurado mediante una hoja de estilo XSLT.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
72
Procesar una hoja equivale a procesar una lista de nodos del documento origen
para ir creando fragmentos del árbol de salida. La lista de nodos empieza siempre con el
nodo raíz. Como procesar un nodo es aplicar la plantilla que lo seleccione, habrá que
aplicar una plantilla para el nodo raíz.
La aplicación de plantillas generará más nodos para la lista de nodos a procesar y
así se irán procesando en orden hasta que la lista esté vacía. Si no existiese ninguna
plantilla para el nodo seleccionado, se aplicaría una plantilla predeterminada.
El procesado XSLT puede darse en tres contextos distintos:
1. En un proceso en “batch”, se tiene un documento fuente XML y la hoja
de estilo, y se genera un archivo que presenta la transformación sufrida
por el documento original.
2. Sobre un servidor web, partimos de los mismos dos archivos, pero la
salida se obtiene sobre el navegador web.
3. En un navegador, es el caso en el que el propio navegador soporta el
procesado XSLT, y por tanto es a él a quien se le mandan los dos
documentos de entrada y él mismo muestra el documento de salida al
usuario.
Existen muchas implementaciones de procesadores XSLT, de hecho cada lenguaje
tiene la suya. La herramienta MSXSL es usada en entorno Windows, mientras que si se
quiere trabajar en un entorno Java, pueden utilizar herramientas destinadas también para
ello, entre las que se puede destacar:
•
XT, de James Clark.
•
Xalan, del Proyecto XML Apache.
•
Saxon, de Michael Kay.
El Explorer 5 y sucesivos son en sí un procesador XSLT, al igual que muchos
otros navegadores y, por tanto, son capaces de mostrar un documento XML utilizando
este lenguaje de hojas de estilo.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
73
Entre algunos de los procesadores de licencia libre más conocidos están:
PROCESADOR
Xalan
DESARROLLADOR { LENGUAJE}
Apache XML Project. (LotusXSL de Alphaworks, IBM)
{ C++, Java, Python[Pyana] }
SAXON
XT
Koala XSL Engine
Gnome libxslt library
XSLTC
Unicorn XSLT
Processor
Michael H. Kay. { Java }
James Clark. { Java }
INRIA. { Java }
Daniel Veillard. { C, perl[XML::Lib XSLT] }
Olivier Gerardin. { C++ }
Unicorn Enterprises. { C++ }
Ilustración 14 .- Principales Procesadores XSLT
Como ejemplo, para crear el archivo nuestra_web.xhtml con Xalan, simplemente
basta con la siguiente instrucción en línea de comando:
$java org.apache.xalan.xslt.Process -IN libros.xml –XSL libros.xsl
-OUT nuestra_web.xhtml
Código 25 .- Instrucción de Transformación para Xalan
Se ha utilizado el documento de datos origen libros.xml y la hoja estilo libros.xsl
para la transformación.
5.5 Estructura de un documento XSLT
La estructura de una hoja de estilos XSL se basa en XSLTransform y sus
elementos. Existen dos grandes categorías de elementos XSLT:
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
74
5.5.1. Elementos de alto nivel (top-level-element)
Encargados de ejecutar una tarea específica, son los únicos que pueden ser hijos
de “xsl:stylesheet”. Entre ellos también mantienen una agrupación en distintos
conjuntos de elementos destinados cada uno a distintas funciones:
Definen el modelo
•
xsl:include: permite referenciar plantillas procedentes de una fuente
externa, es decir, permite incluir modelos de otras hojas de estilo con
igual prioridad que los modelos de la hoja actual.
•
xsl:import: importa modelos de otras hojas de estilo dándoles una
prioridad inferior a los modelos de la hoja actual.
•
xsl:template: contiene un modelo que será aplicado a los nodos que
haya que transformar.
•
xsl:attribute-set: define grupos de atributos que posteriormente serán
aplicados a elementos.
Definen el formato del resultado
•
xsl:output: proporciona métodos para la salida (xml, html, text),
definiendo las características básicas del formato del documento
resultado
•
xsl:strip-space: elimina antes del procesamiento todos los nodos
consistentes en espacios en blanco.
•
xsl:preserve-space: definen los elementos a los que no se les va a quitar
los espacios sobrantes.
•
xsl:decimal-format: permite definir el formato en el que los valores
numéricos serán mostrados. Permite definir varios estilos por medio de
nombres, sin nombre es el estilo por defecto.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
75
Definen un pseudo-lenguaje de programación
•
•
xsl:variable: define una función que devuelve un valor en función del
contenido de la variable.
xsl:param: define el nombre y valor de un parámetro. Está diseñado
para guardar un valor, pasarlo entre modelos, e incluso entre el
procesador XSLT y la hoja de estilo..
Definen características especiales
•
•
xsl:key: define una clave que facilita la posterior búsqueda de nodos
mediante la función key().
xsl:namespace-alias: permite definir un alias para un 'namespace'.
5.5.2. Instrucciones de Plantilla (instruction)
Definen las condiciones para que se efectúe cada transformación. En una primera
clasificación, se pueden distinguir cinco categorías:
•
Obtención de patrones: instrucciones encargadas de definir los
patrones a los que deben de ajustarse lo nodos del documento fuente para
que se activen las reglas expresadas en la hoja de estilo.
•
Manipulación de datos: indican los cambios a efectuar en los datos,
como consecuencia de ajustarse a una regla.
•
Flujo de control: permite utilizar la iteración y la condicionalidad a la
hora de procesar la hoja de estilo.
•
Diseño de documentos: proporciona mecanismos para la construcción
del documento resultado.
•
Definición de tipos de contenidos: permite definir variables, texto o
números.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
76
Pero a la hora de enumerar cada uno de estos elementos, se va a volver a
agruparlos en los cuatro grandes grupos al igual que se hizo con los elementos de alto
nivel.
Definen el modelo
•
xsl:value-of: Calcula el valor de una expresión XPath.
•
xsl:copy: Permite copiar un elemento, pero no copia ni sus atributos ni
sus hijos.
•
xsl:copy-of: Permite copiar un elemento incluyendo sus atributos, sus
hijos, nietos, etc.
•
xsl:apply-templates: Define los nodos a los que hay que aplicar los
modelos apropiados. Puede definir también que parámetros se le deben
pasar al modelo.
•
xsl:call-template: Permite llamar a un modelo en concreto por su
nombre. Puede definir también que parámetros se le deben pasar al
modelo.
•
xsl:element: Permite crear un elemento.
•
xsl:attribute: Permite añadir un atributo a un elemento.
•
xsl:text: Permite escribir texto de forma literal en el documento de
destino.
•
xsl:comment: Permite crear comentarios en el documento de salida.
También permite generar definiciones CSS.
•
xsl:processing-instruction: Permite crear instrucciones en otros
lenguajes de programación en el documento de salida.
•
xsl:apply-imports: Permite aplicar modelos importados aumentando su
prioridad.
Definen el formato del resultado
•
•
xsl:number: Permite contar elementos y mostrar la numeración en el
formato deseado. También puede utilizarse para dar formato a valores
numéricos.
xsl:sort: Ordena un conjunto de nodos.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
77
Definen un pseudo-lenguaje de programación
•
xsl:if: Define una condición y solo si se cumple se procesará su
contenido.
•
xsl:choose: Permite elegir entre varias situaciones definidas con
'xsl:when', en el caso de que no se cumpla ninguna elige el elemento
'xsl:otherwise'.
•
xsl:when: Define una condición dentro del elemento 'xsl:choose' y si es
la primera en cumplirse se procesa su contenido.
•
xsl:otherwise: Define que procesar dentro del elemento 'xsl:choose' en
el caso de que las condiciones de los elementos 'xsl:when' precedentes no
se cumplan.
•
xsl:for-each: Recorre, de uno en uno, el conjunto de nodos a los que
hace referencia.
•
xsl:with-param: Selecciona un parámetro que será pasado al modelo.
Definen características especiales
•
xsl:fallback: Define un modelo que será utilizado en el caso de que un
elemento extendido no se encuentre disponible.
•
xsl:message: Permite mandar un mensaje a la salida de texto. Ayuda a
localizar errores en las hojas de estilo.
5.6 Definición de la Hoja de Estilo
Se ven los elementos que se pueden incluir en una hoja de estilo, no todos ellos
son de obligada declaración.
La primera línea en un documento hoja de estilo es la declaración XML, un
documento XSL en sí mismo es un documento XML.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
78
<?xml version="1.0" encoding="ISO-8859-1"?>
Código 26 .- Declaración XML en documento XSLT
Aparece la versión y el tipo de codificación, de los caracteres que se van a utilizar,
en este caso Latin-1.
El siguiente elemento que se puede encontrar, es <xsl:stylesheet>, que define este
documento como un documento de hoja de estilo XSLT (con el número de versión y el
atributo namespace de XSLT).
Por tanto, la hoja de estilo está definida entre las etiquetas <xsl:stylesheet> y
</xsl:stylesheet>, y debemos indicarle el namespace que se utiliza a través del atributo
xmlns:xsl. Como puede verse, lo primero que necesita un fichero XSL es identificar el
namespace XML que permite validar todos los elementos y métodos disponibles en la
versión XSL que se utiliza. De esta forma, el namespace reconoce los atributos y
elementos XSL del documento que le da el formato de salida al documento XML.
<xsl:stylesheet xmlns:xsl=”http://www.w3c.org/1999/XSL/Transform” version=”1.0”>
<!- -resto de definiciones de la hoja de estilo - ->
</ xsl:stylesheet >
Código 27 .- Elemento <xsl:stylesheet >
En el esquema anterior se ha utilizado el namespace que utiliza la recomendación
del W3C del 16 de noviembre de 1999. El namespace de la recomendación del W3C de
diciembre de 1998 es “http://www.w3.org/XSL/Transform/1.0”. La recomendación
más reciente es del 23 de Enero de este mismo año 2007, en su versión 2.0.
La siguiente línea define el formato de salida de este "XSL Stylesheet", es por
tanto que tendrá un aspecto similar a:
<xsl:output method="..." encoding="..." indent="...">
Código 28 .- Formato de salida
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
79
Donde cada atributo puede tomar diferentes valores; a modo de ejemplo algunos
de los valores posibles para estos atributos:
• method: xml, html, text, ...
• encoding: utf-8, utf-16, iso-8859-1, ...
• indent: yes, no
A continuación, la definición de la platilla raíz. En esta platilla puede ya quedar
definido el formato en el cual se quieren mostrar los resultados.
Los formatos básicos pueden ser aplicados ya a todos los elementos del
documento, por lo cual crearemos una plantilla en la que el elemento raíz utilizará ya
esos formatos.
La manera de hacer referencia al elemento raíz del documento es mediante el
parámetro match=”/”:
<xsl:template match=”/”>
<!- - código del lenguaje a obtener - ->
</ xsl:template>
Código 29 .- Definición de Plantilla raíz
Además de esta plantilla raíz, para cada nodo del árbol XML existe la posibilidad
de definir un patrón de estilos que marcará como se va a presentar dicho nodo en el
documento final. Esto es posible con la definición del elemento template.
Cada uno de los elementos template deben de ser cerrados adecuadamente antes
del final de cada hoja de estilo, la cual termina con el cierre del elemento:
</xsl:stylesheet>, abierto al inicio del documento XSL.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
5.6.1.
80
El Elemento Template (Plantilla)
La hoja de estilo XSLT incorpora la descripción de un conjunto de reglas que
indican la manera en que deben procesarse los nodos del documento fuente u origen,
utilizando una estructura de objetos como modelo de datos. Éstas reglas (template rules)
conforman lo que se conoce como plantillas o templates.
A través de los templates o plantillas se transforma el documento XML de partida
al nuevo documento deseado, bastando para ello seleccionar la información con
patrones de búsqueda (filtro) y aplicando a la información seleccionada las reglas de
proceso.
Durante la aplicación de la hoja de estilo, se realizan una serie de comprobaciones
entre partes del documento fuente y estas plantillas, de tal forma que cuando se produce
un ajuste en alguna de ellas, se aplican las reglas asociadas a esa plantilla y se va
construyendo así el árbol o documento resultado.
El elemento <xsl:template> es el encargado de definir una plantilla y el atributo
match es usado para asociar la plantilla con un elemento XML al que se le aplicará la
misma. El valor de la atributo match es una expresión XPath. El atributo match puede
ser utilizado también para definir una plantilla para un archivo XML entero, tal es el
caso de match=“/” que asocia a la plantilla con la raíz del documento XML.
Aunque solo se ha nombrado al atributo match, por ser el más utilizado, no es el
único que puede recibir <xsl:template>, también puede estar acompañado por:
•
name: define un nombre por el cual un elemento “xsl:call-template”
puede invocarlo.
•
mode: define un nombre con el cual se pueden diferenciar varios
modelos a aplicar sobre el mismo nodo.
•
priority: define la prioridad con un número. Este atributo solo se tendrá
en cuenta cuando varios modelos tengan la misma prioridad por defecto.
Las plantillas o templates tienen la siguiente estructura general:
<xsl:template match=”patrón de búsqueda, expresión XPath”>
<!- -acción o regla - ->
</xsl:template>
Código 30 .- Estructura de un template
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
81
Como primer ejemplo de un template:
<xsl:template match=”patron”>
El precio es:
<xsl:value-of select=”precio”/>
<xsl:apply-templates/>
</xsl:template>
Código 31 .- Ejemplo template
Donde patron es el identificador de los elementos a los que se quiere aplicar el
template. Es decir, en el recorrido por el árbol del documento XML, cuando encuentre
un nodo que coincida con el patrón del template, se aplica la plantilla.
<?xml version=”1.0”?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match=”/”
<!- -accion1 - ->
</xsl:template>
<xsl:template match=”patron1”>
<!- -accion2 - ->
</xsl:template>
<xsl:template match=”patron2”>
<!- -accion3 - ->
</xsl:template>
..........
</xsl:stylesheet>
Código 32 .- Ejemplo documento XSLT con Plantillas
En el ejemplo anterior se muestra un documento XSL completo, con la
declaración XML, el elemento xsl:stylesheet y su namespace, la definición de la
plantilla raíz y la de todas las demás plantillas o templates.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
82
Si se tienen estos patrones:
<?xml version= “1.0”?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match= “/”>
<!- -accion1 - ->
</xsl:template>
<xsl:template match= “catalogo”>
<!- -accion2 - ->
</xsl:template>
<xsl:template match= “libro”>
<!- -accion3 ->
</xsl:template>
<xsl:template match= “aventuras”>
<!- -accion4 - ->
</xsl:template>
</xsl:stylesheet>
Código 33 .- Ejemplo documento XSLT con Plantillas
Cuando el procesador identifique al elemento raíz, lleva a cabo accion1, cuando
identifique el elemento catalogo, hace accion2, y así hasta que termina de recorrer el
árbol...
Esta serie de acciones que forman la plantilla, es lo que se ha definido como
reglas de proceso o reglas de plantilla (template rules), y entre las que existe una gran
variedad.
5.6.1.1. Plantilla predeterminada
En el caso en el que no exista ninguna plantilla para un cierto nodo seleccionado,
se aplicará de forma automática una plantilla predeterminada.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
83
Para los elementos se aplica la plantilla siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
<xsl:template match="*|/">
<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet>
Código 34 .- Plantilla predeterminada para elementos
Esta plantilla acepta cualquier nodo y pone todos sus hijos, ya sean elementos o
texto, en la lista de nodos a procesar. Esto quiere decir que si en algún momento hay
algún nodo en la lista de nodos a procesar para el que no hemos definido plantilla, se
aplicará de nuevo esta plantilla y su hijos pasarán a la lista, si tampoco hemos definido
reglas para sus hijos, se seguirá el proceso hasta que sean insertados, procesados por
defecto y eliminados todos los descendientes de este nodo de la lista.
Para los atributos o nodo de texto, la plantilla predeterminada es la siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
<xsl:template match="text() |@*/">
<xsl:value-of select="."/>
</xsl:template>
</xsl:stylesheet>
Código 35 .- Plantilla predeterminada para atributos
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
84
5.6.2. Generación de Plantillas
La plantilla más básica, no hace nada con su nodo. Sería una plantilla como:
<xsl:template match="nodo”>
</xsl:template>
Código 36 .- Plantilla básica sin salida
Una plantilla algo más interesante producirá algún tipo de salida para su nodo
asociado. Esta salida es algún tipo de texto, transformado directamente o calculado en
función de valores de otros nodos o funciones especiales.
Por ejemplo:
<xsl:template match="nodo">
Texto asociado al nodo procesado
</xsl:template>
Código 37 .- Plantilla con salida
Sólo con estas posibilidades, se pueden realizar muchas tareas importantes, pero
para aprovechar toda su potencia, se necesita algo más, acceso a los nodos procesados y
sus atributos de forma automática, repetición y selección condicional de nodos. En
definitiva se necesita poder generar valores calculados para el contenido de salida.
Para ello, existe una serie de reglas o instrucciones modeladas como elementos de
la especificación de XSLT. Se verán algunas de las más importantes con algo de detalle.
5.6.2.1. Regla <xsl:apply-templates>
Se consigue añadir nodos a la lista de procesado. Se añaden los nodos
seleccionados mediante el atributo “select”.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
85
Con esta regla se seleccionan los elementos a los que se les va a aplicar alguna
plantilla. Se debe tener en cuenta el poder seleccionar tanto los hijos del nodo en el que
nos encontremos como a otros que no son hijos del nodo actual.
La sintaxis es la siguiente:
<xsl:apply-templates select="Expresion XPath" mode="identificador">
</xsl:apply-templates>
Código 38 .- Sintaxis regla xsl:apply-templates
A base de ejemplo:
<xsl:template match=”libro”>
<xsl:apply-templates select="precio”/>
</xsl:template>
Código 39 .- Ejemplo regla xsl:apply-templates I
Aplica la regla a todos los hijos de libro con nombre precio.
En este otro ejemplo otro ejemplo:
<xsl:template match= "libro”>
<xsl:apply-templates select="precio”/>
<xsl:apply-templates select= "//catalogo/revista/ciencia”/>
</xsl:template>
Código 40 .- Ejemplo regla xsl:apply-templates II
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
86
La regla se aplica a todos los hijos de libro con nombre precio y a todos los nodos
ciencia que son hijos de revista y nietos de catalogo que estén en cualquier posición del
árbol.
Los dos atributos que pueden acompañar a esta regla son:
•
select: define una expresión XPath que selecciona los nodos a los que
se debe aplicar los modelos. Si no se define se seleccionan todos los
elementos hijos del nodo actual.
•
mode: Identificativo de plantilla. Define un nombre con el cual sólo
permite aplicar elementos 'xsl:template' cuyo atributo 'mode' sea igual. Es
decir, sirve para diferenciar cuando se compara una misma parte del
documento XML, pero en cambio cada plantilla realiza una actuación
diferente.
La ejecución de esta instrucción “congela” la generación de salida para el nodo
actual hasta que se haya procesado los nodos que se añaden a la lista.
5.6.2.2. Regla <xsl:value-of>
El elemento <xsl:value-of> permite extraer contenido del documento XML y
volcarlo en la salida transformada generada. Para ello emplea una expresión XPath
asignada al atributo ‘select’.
Con esta instrucción, se selecciona el valor de una etiqueta XML para agregarlo al
archivo de salida de la transformación, se inserta el valor del atributo o elemento
encontrado en el árbol de salida.
La sintaxis es la siguiente:
<xsl:template match="/">
<xsl:value-of select="expresion_XPath" disable-output-escaping="yes">
</xsl:value-of>
</xsl:template>
Código 41 .- Sintaxis regla xsl:value-of
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
87
Los atributos que pueden acompañarle pueden ser:
•
select: muestra con que debe compararse el árbol del documento XML
origen. El valor de este atributo es una expresión XPath.
•
disable-output escaping: hace que en el documento de salida muestre
o no los caracteres “&” y ”<”, en lugar de “&” o “<”. Cuando el
valor de este atributo es “yes” pone en el documento de salida los
caracteres “&” y “<”. En cambio si e valor de este atributo es “no”
pondrá como salida “&” o “<” respectivamente
5.6.2.3. Regla <xsl:element>
Se utiliza para insertar elementos de marcado en el árbol del documento destino
cuyo nombre y atributos calculamos en base a los nodos del documento origen.
La sintaxis es la siguiente:
<xsl:element name="expresion_XPath" namespace="espacio de nombres a usar"
use-attribute-sets="atributos">
</xsl:element>
Código 42 .- Sintaxis regla xsl:element
En la declaración de este elemento se pueden utilizar los atributos siguientes:
•
name: mediante una expresión XPath se hace que el nombre del
elemento del documento destino sea dinámico y dependa del documento
origen.
•
use-attribute-sets: permite añadir atributos al elemento mediante la
referencia a conjuntos de atributos definidos como elementos globales.
•
namespace: para especificar el espacio de nombres al que pertenecerá
el elemento.
•
xml:space: indica si debe preservar o no los espacios en blanco.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
88
5.6.2.4. Regla <xsl:attribute>
Igual que el elemento “<xsl:element>”, pero éste sirve para añadir atributos de
forma dinámica a un árbol de un documento XML.
<xsl:attribute name="Ejemplo" namespace="Espacio_de_Nombres"
xml:space="default | preserve ">
</xsl:attribute>
Código 43 .- Sintaxis regla xsl:attribute
Los atributos que le pueden acompañar son:
•
name: corresponde con el nombre del atributo que puede ser escrito o
calculado con una expresión XPath..
•
namespace: para especificar el espacio de nombres al que pertenecerá
el atributo.
•
xml:space: indica si va a preservar o no los espacios en blanco.
5.6.2.5. Regla <xsl:if>
Es una instrucción de procesamiento condicional, respecto al contenido del
atributo “test”. Si la comparación es cierta se evalúa el contenido del elemento
“<xsl:if>”, en caso contrario no se evalúa. La sintaxis es la siguiente:
<xsl:if test="condicion">
</xsl:if>
Código 44 .- Sintaxis regla xsl:if
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
89
El atributo que se permite utilizar en este elemento es:
•
test: este atributo indica la expresión lógica con la que se tiene que
comparar.
El valor del atributo “test” debe contener los caracteres “>”, “<” en lugar de
“>” y “<” respectivamente.
Ejemplo:
<xsl:if test="Raiz/elem2">
<xsl:text>hay elementos tipo 2</xsl:text>
</xsl:if>
Código 45 .- Ejemplo regla xsl:if
5.6.2.6. Regla <xsl:choose>, <xsl:when> y <xsl:otherwise>
Permite realizar comparaciones más estrictas que el elemento “<xsl:if>” y con
más variedad de casos. La sintaxis que utiliza es la siguiente:
<xsl:choose>
<xsl:when test = "boolean-expression">
<!-- Contenido: template -->
</xsl:when>
<xsl:when test = "boolean-expression">
<!-- Contenido: template -->
</xsl:when>
...
<xsl:otherwise>
<!-- Contenido: template -->
</xsl:otherwise>
</xsl:choose>
Código 46 .- Sintaxis regla xsl:choose
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
90
Al igual que los elementos “<xsl:if>”, el único atributo que soporta es “test”.
Aunque con el elemento “<xsl:choose>” está asociado un elemento denominado
“<xsl:otherwise>”, el cual se evalúa siempre que ninguna de los anteriores haya sido
verdadera. Este elemento no es obligatorio.
Existe un caso especial con este elemento. Cuando sean correctas más de una
sentencia “<xsl:when>”. Cuando esto ocurra únicamente se evaluará la primera que
haya sido correcta, saliendo del elemento “<xsl:choose>” a continuación.
El contenido de los atributos “test” deben ser caracteres de escape al igual que el
elemento “<xsl:if>”, esto es debido a que XML no soporta caracteres como “<”.“>”.
Como ejemplo se puede tener:
<xsl:choose>
<xsl:when test="Raiz/elem2[@at1=10]">
<xsl:text> -->at1 de elem2 vale 10 </xsl:text>
</xsl:when>
<xsl:when test="Raiz/elem2[@at1=20]">
<xsl:text> -->at1 de elem2 vale 20 </xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text> -->Esto sólo si no se cumple nada. </xsl:text>
</xsl:otherwise>
</xsl:choose>
Código 47 .- Ejemplo regla xsl:choose
5.6.2.7. Regla <xsl:for-each>
Se utiliza para procesar de forma iterativa diversos nodos del documento XML
origen, estos nodos vienen representados por la expresión XPath. La sintaxis se muestra
en el siguiente ejemplo:
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
91
<xsl:for-each select="expresion_XPath">
</xsl:for-each>
Código 48 .- Sintaxis regla xsl:for-each
El atributo “select” permite introducir una expresión XPath que seleccione varios
nodos. Para cada nodo seleccionado por la expresión se realizará lo que se incluya en el
interior.
El siguiente ejemplo combina esta instrucción con la anterior:
<xsl:for-each select="Raiz/elem2">
<xsl:choose>
<xsl:when test="@at1=10">
<xsl:text>at1 de elem2 vale 10 </xsl:text>
</xsl:when>
<xsl:when test="@at1=20">
<xsl:text>at1 de elem2 vale 20 </xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>Esto sólo si no se cumple nada. </xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
Código 49 .- Ejemplo reglas xsl:choose, xsl:for-each
Mediante esta instrucción se permite añadir en cualquier plantilla el
procesamiento de todo un conjunto de nodos distintos de los que la propia plantilla
selecciona.
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
92
5.6.2.8. Regla <xsl:copy-of>
Se utiliza cuando el documento destino tiene una parte de código igual a la del
documento XML origen. Este elemento permite copiar secciones del documento origen
al documento destino.
La sintaxis de este elemento es:
<xsl:copy-of select="expresion_XPath">
</xsl:copy-of>
Código 50 .- Sintaxis regla copy-of
El atributo “select” especifica aquel nodo o nodos que se insertarán directamente
en el documento de salida.
Hacer mención también de la instrucción: <xsl:copy>, que es similar a ésta, pero
más potente ya que copia el nodo de contexto, así como los atributos y los hijos de
dicho nodo. La diferencia respecto al elemento “copy-of”, es que únicamente copia el
nodo actual sobre el que la plantilla se aplica.
5.6.2.9. Comentarios
Si queremos comentar algo en un documento XSL utilizamos <!-- y -->. Estas
etiquetas no se procesan y por tanto no aparecen en el documento de salida. Si se desea
que aparezcan los comentarios se utiliza el elemento <xsl:comment>.
<!-- esto es un comentario y no se procesa -->
Código 51 .- Comentario sin salida
En el caso de que si queramos que salga en la salida:
<xsl:comment>
Esto es un comentario que aparece en el documento de salida.
</xsl:comment>
Código 52 .- Comentario con salida
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
5.7
93
Conclusiones
La gran ventaja de XSLT es que permite poder publicar en muy diferentes medios
un mismo documento fuente con datos XML, simplemente utilizando una hoja de estilo
adecuada para cada dispositivo de salida.
El lenguaje de transformación XSLT precisa definir qué transformaciones se
quieren hacer y a qué partes del documento. Para lo primero el propio XSLT define
unos elementos o reglas de plantilla que alimentan a un procesador o motor de XSLT, el
cual realiza las transformaciones deseadas. Dichas reglas, especifican cómo debe
aparecer cada nodo del documento XML origen en el documento destino.
Para seleccionar a qué partes del documento origen XML vamos a hacer las
transformaciones, XSLT se basa en la sintaxis que define XPath.
Se trabaja con dos árboles, el árbol fuente del documento XML, al que se le aplica
la transformación, y el árbol resultado que se quiere obtener al hacer la transformación,
cuya estructura puede ser sensiblemente diferente a la del árbol origen, debido a que
para la construcción de éste nuevo árbol, se ha podido filtrar nodos del árbol fuente y
han podido sufrir alguna reordenación, incluso se han podido añadir nuevas estructuras
al árbol.
Existen muchas implementaciones de procesadores XSLT, de hecho cada lenguaje
tiene la suya. Entre los más utilizados cabe destacar: XT (James Clark), Xalan (Proyecto
XML Apache), Saxon (Michael Kay), MSXSL (Microsoft).
CAPITULO 6.- EL FORMATO, XSL-FO
95
6. El Formato, XSL-FO
6.1 Introducción
Un documento XSL-FO (XSL Formatting Objects) es un documento XML
(Extensible Markup Language) en el que se especifica cómo se van a formatear los
datos para presentarlos en pantalla, papel u otros medios. Hay que destacar que en el
documento XSL-FO figuran tanto los datos como el formato que se les va a aplicar.
Como su propio nombre indica, XSL-FO se utiliza para formatear el contenido de
un documento XML. Es decir, se le aplica un formato a los datos seleccionados por el
XSL (Extensible Stylesheet Language) a partir de los datos originales en XML. Por
tanto, en el proceso de formateo además de intervenir patrones de búsqueda y
transformación (hoja de estilo), debe existir un convertidor o FOP (Formatting Objects
Processor), que es un procesador de hojas de estilo capaz de interpretar XSL-FO y
generar documentos formateados, como puede ser documentos con formato imprimibles
PDF (Portable Document Format).
En el siguiente apartado, se aclara, cuál es la recomendación oficial para XSL-FO.
En el tercer y cuarto apartado se introducen los FO (Formating Object) y se estudia la
estructura de un documento XSL-FO.
En el quinto apartado, se enumeran los métodos por los que se puede obtener un
documento XSL-FO, puede encontrarse un ejemplo aplicado a cada uno de esos
métodos. Por último, se verá la gama de procesadores XSL-FO que existen.
6.2 XSL-FO como Recomendación
XSL-FO es una recomendación del World Wide Web Consortium, el significado
de las siglas XSL-FO es eXtensible Stylesheet Language Formatting Objects. Es de
aclarar que el nombre oficial de la recomendación es Extensible Stylesheet Language
(XSL) y no XSL-FO.
XSL-FO y XSL son por tanto la misma recomendación, y nos da a conocer el
leguaje de formateo de los documentos XML, es decir, un vocabulario XML que se
utiliza para especificar los objetos de formateo (FO).
CAPITULO 6.- EL FORMATO, XSL-FO
96
XSL 1.0 (XSL-FO) fue nombrada como recomendación el 15 de Octubre de 2001,
pasando a tener una revisión y actualizarse a fecha de 5 de Diciembre de 2006 como la
recomendación XSL 1.1.
Por otra parte, está la recomendación XSLT (XSL Transform), la cual comenzó
estando unida también a XSL pero con el tiempo fue propuesta y aceptada como nueva
recomendación y separada de XSL. XSLT, da las directrices de transformación de
documentos XML, es un lenguaje de transformación por el que se puede transformar un
documento de entrada XML en algún otro tipo de documento estructurado.
XPath (XML Path Language) es también recomendación del W3C (World Wide
Web Consortium), y en ella queda constancia del método de búsqueda y movimiento a
través de documentos XML por parte de XSLT.
Aquí se ve en forma de árbol la jerarquía de estas recomendaciones:
Ilustración 15.- Posición de XSL-FO
En el lenguaje XSLT, ya se ha profundizado en un apartado anterior, viendo su
importancia, su fundamento y dando unas nociones de cómo crear estas hojas de estilo
para la transformación de documentos XML. Es por tanto, que es momento para ver con
algo más de detalle la técnica con la que dar forma y estilo a lo que se generó al realizar
dicha transformación.
6.3 Formating Objects
La unidad básica de trabajo en un documento XSL-FO es el "Formating Object",
unidad básica para presentar (formatear) la información.
CAPITULO 6.- EL FORMATO, XSL-FO
97
Mediante los objetos de formateo (Formatting Objects, FO) y sus propiedades se
describen cómo se van a visualizar los elementos de un documento. Con estos objetos se
puede definir entre otros, los siguientes elementos:
•
Las características de la página.
•
Los párrafos.
•
Las listas.
•
Las tablas.
•
Los enlaces.
•
etc.
El uso más común que se hace en la actualidad de Formatting Objects, está
enfocado a la generación de documentos de calidad destinados a la impresión. Este es el
caso de los documentos PDF (Portable Document Format).
Existen actualmente 56 FO (Formatting Objects), la mayoría de los cuales hacen
referencia a distintos tipos de áreas rectangulares. El modelo utilizado por FO está
basado, por tanto, en cajas rectangulares llamadas áreas, las cuales pueden contener
texto, espacio vacío u otros FO.
6.3.1 Áreas
Éste lenguaje de formateo XSL-FO, define un conjunto de cajas (Boxes) en las
que se muestra la salida. Cualquier tipo de salida, como puede ser texto o imágenes,
debe de ser encajada en dichas áreas para ser mostrada o imprimida.
Los Formatting Objects están divididos formalmente en los siguientes tipos de
áreas rectangulares:
•
Pages, toda salida de un documento XSL-FO cuando es formateado se
imprime en páginas. Incluso si la salida es en navegador, se puede ver
como una gran página. Las páginas tienen distintas regiones.
•
Regions, una página está dividida en regiones, entre ellas tenemos: la
cabecera, el cuerpo, el pie y los márgenes derecho e izquierdo. Es por
ello, que los distintos tipos de regiones que tenemos son:
CAPITULO 6.- EL FORMATO, XSL-FO
98
o Region-body, es el cuerpo de la página, dimensión del área
principal en el centro de la página.
o Region-before, parte superior de la página, utilizada normalmente
para la cabecera del documento.
o Region-after, parte inferior de la página, utilizada normalmente
para el pie del documento.
o Region-start, parte izquierda del documento.
o Region-end, parte derecha del documento.
Por tanto, los FO que producen regiones son: fo:region-body,
fo:region-before, fo:region-after, fo:region-start y fo:region-end.
•
Block areas, definen un bloque pequeño, normalmente se considera
nuevo bloque cuando se empieza un nuevo párrafo. Los bloques, pueden
contener otros bloques, imágenes, espacios a visualizar, aunque lo
normal es que estén constituidos por líneas.
Los FO que producen bloques son: fo:block, fo:display-graphic,
fo:display-link, fo:display-rule y fo:list-block.
•
Line areas, definen líneas de texto dentro de los bloques. Pueden
contener inclusiones (inline areas) así como inclusiones de espacios.
No existen FO que se correspondan con las líneas, sino que el motor de
evaluación del formateo va generándolas conforme divide líneas debido,
por ejemplo, al tipo de justificación elegida.
•
Inline areas, definen caracteres o palabras dentro de las líneas de
texto.
Los FO que generan inclusiones son: fo:character, fo:inline-graphic,
fo:inline-link, fo:inline-rule, fo:inline y fo:page-number.
CAPITULO 6.- EL FORMATO, XSL-FO
6.4 Estructura de un documento XSL-FO
La estructura más general de un archivo de formato, XSL, se puede ver en el
siguiente trozo de código.
<?xml version="1.0" encoding="ISO-8859-1"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="nombre">
<!—Formato de la página -->
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="nombre">
<fo:flow>
<!-- Aquí va el contenido del documento -->
</fo:flow>
</fo:page-sequence>
</fo:root>
Código 53 .- Estructura general de archivo XSL-FO
La ilustración siguiente representa nuevamente una estructura XSL-FO:
Ilustración 16.- Estructura general XSL-FO
99
CAPITULO 6.- EL FORMATO, XSL-FO
100
En primer lugar, como todo en documento XML, el documento XSL-FO debe de
comenzar con la línea de declaración:
<?xml version="1.0" encoding="ISO-8859-1"?>
Código 54 .- Línea de declaración XSL-FO
6.4.1. < fo:root >
El elemento raíz de un documento XSL-FO es <fo:root>, es el elemento que
marca el inicio y el fin del documento XSL-FO. Nos apoyamos en este elemento para
definir el espacio de nombres para FO. Al ser éste el elemento raíz, de él colgarán todos
los demás elementos del documento:
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<!— documento XSL-FO completo -->
</fo:root>
Código 55 .- Elemento raíz XSL-FO
6.4.2. < fo:layout-master-set >
El elemento <fo:layout-master-set>, contiene el template (o plantilla) de una o
más páginas. Engloba un conjunto de definiciones sobre la estructura o layout de las
páginas, es decir, contiene uno o más <fo-simple-page-master>. Con esto se consigue,
por ejemplo, que en el documento final existan unas páginas con orientación vertical y
otras apaisadas. También se puede definir distintos márgenes para las páginas del
documento según si la página es par o impar.
En la mayoría de los casos, con una sola definición de página sería suficiente:
<fo:layout-master-set>
<!—Plantillas de todas las páginas-->
</fo:layout-master-set>
Código 56 .- Elemento fo:layout-master-set
CAPITULO 6.- EL FORMATO, XSL-FO
101
6.4.3. < fo:simple-page-master >
Dentro del elemento <fo:layout-master-set>, están los elementos <fo:simplepage-master>, en cada uno de los cuales se define la plantilla de cada página.
Se encarga de especificar los márgenes, altura y anchura de una página en
concreto (para conseguir una orientación vertical o apaisada). Cada plantilla debe tener
un nombre diferente a las demás:
<fo:simple-page-master master-name="nombre ">
<!—Plantilla de una página-->
</fo:simple-page-master>
Código 57 .- Elemento simple-page-master
Descripción de cada uno de los atributos que constituyen este elemento:
•
master-name, como podemos crear multitud de definiciones de
páginas, posteriormente debemos ser capaces de asociar cada página real
con su definición de estructura. Se hace siempre a través del "mastername".
•
margin-top, margin-bottom, margin-left y margin-right, define el
tamaño de los márgenes superior, inferior, izquierdo y derecho.
•
page-width y page-height, tamaño físico de la página. Por ejemplo, en
caso de DIN- A4 se utiliza 21x29.7.
Dentro de este elemento se encuentran a la vez otros elementos que definen
características de la página: <fo:region-before>, <fo:region-body> y <fo:regionafter>, <fo:region-start>, <fo:region-end>:
•
region-body: dimensión del área principal en el centro de la página.
•
region-before: parte superior de la página, utilizada normalmente para la
cabecera del documento.
•
region-after: parte inferior de la página, utilizada normalmente para el
pie del documento.
CAPITULO 6.- EL FORMATO, XSL-FO
•
region-start: parte izquierda del documento.
•
region-end: parte derecha del documento.
102
En el siguiente dibujo se muestra el área al que hace referencia cada elemento
dentro de una página, es decir, cada uno de los elementos que forman el elemento
página <fo:simple-page-master> y sus atributos de márgenes:
Ilustración 17.- Áreas de una Página
A base de ejemplo del elemento <fo:simple-page-master>, con todos sus
atributos y subelementos:
<fo:simple-page-master master-name="nombre_pagina"
page-width="297mm" page-height="210mm"
margin-top="1cm" margin-bottom="1cm"
margin-left="1cm" margin-right="1cm">
<fo:region-body margin="3cm"/>
<fo:region-before extent="2cm"/>
<fo:region-after extent="2cm"/>
<fo:region-start extent="2cm"/>
<fo:region-end extent="2cm"/>
</fo:simple-page-master>
Código 58 .- Atributos fo:simple-master-master
CAPITULO 6.- EL FORMATO, XSL-FO
103
6.4.4. < fo:page-sequence >
Describe el conjunto de páginas con un formato o estructura determinado. Esta
estructura de páginas viene referenciadas a través del atributo "master-reference". Este
atributo es una referencia a un tag de tipo fo:simple-page-master cuyo "master-name"
corresponde con el indicado.
El contenido de cada página estará descrito por este tipo de elementos y los
elementos que lo forman.
<fo:page-sequence master-reference="nombre">
<!—Contenido de la página-->
</fo:page-sequence>
Código 59 .- Elemento fo:page-sequence
Dentro del elemento <fo:page-sequence> se pueden encontrar los elementos
<fo:flow>, <fo:static-content> que definen la región de la pagina en la que se insertará
el contenido, tanto dinámico como estático. También puede aparecer <fo:title>
(opcional), que contiene el texto del "título" de la página.
6.4.4.1. < fo:flow > (Contenido dinámico)
El elemento <fo:flow>, el cual pertenece a <fo:page-sequence>, es un elemento
de definición de contenido dinámico. Dos de los elementos más utilizados a la hora de
definir contenido dentro de un documento FO:
•
Definición de bloques con <fo:block>, define una sección o párrafo de
contenido. Este elemento siempre causa un salto de línea después de su
renderizado. En la propia etiqueta "block" pueden definirse ciertos estilos
del texto, como son por ejemplo el tamaño o tipo de fuente.
<fo:block font-size="12pt" font-weight="bold">
...
</fo:block>
Código 60 .- fo:block
CAPITULO 6.- EL FORMATO, XSL-FO
•
104
Definición de estilos para el texto contenido en un bloque <fo:inline>,
Permite modificar el estilo del texto ya contenido dentro de un bloque,
sobrescribiendo así las definiciones que se habían hecho.
<fo:block font-size="12pt">
Texto <fo:inline font-size="14pt" font-weight="bold">de</fo:inline>
ejemplo.
</fo:block>
Código 61 .- fo_inline
Uniendo los distintos elementos se tiene una estructura:
<fo:page-sequence>
<fo:flow flow-name="xsl-region-body">
<fo:block>
<!—Texto a mostrar-->
</fo:block>
</fo:flow>
</fo:page-sequence>
Código 62 .- Estructura fo:page-sequence con fo:block
El elemento <fo:flow>, puede tomar distintos valores permitidos para su atributo
“flow-name”, que indica en qué parte de la página se coloca el contenido:
•
xsl-region-body, el contenido caerá dentro de region-body.
•
xsl-region-before, para entrar en region-before.
•
xsl-region-after, se entra dentro de la region-after.
•
xsl-region-start, escritura sobre region-start,
•
xsl-region-end, acceso a region-end.
CAPITULO 6.- EL FORMATO, XSL-FO
105
6.4.4.2. < fo:static-content > (Contenido estático)
Los fo:static-content sirven para especificar contenido que aparecerá en todas las
páginas, pudiendo contener internamente los mismos contenidos que un fo:flow (aunque
normalmente en número más reducido dado que no se pueden extender a más de una
página). También puede contener elementos que se repiten aunque se calculen en cada
una (como el número de página)
Hay que tener en cuenta que, cuando se usan los contenidos estáticos, deben
aparecer antes de los elementos fo:flow al definir la secuencia de elementos de la
página.
6.5 Métodos de obtención de un documento XSL-FO
Para llegar a obtener un documento XSL-FO pueden seguirse dos vías,
dependiendo de si se obtiene de una forma directa o indirecta:
•
Generarlo directamente a partir de los datos. El documento XSL-FO contiene las
especificaciones de formato y los propios datos. Es decir, el programador crea
directamente un documento XSL-FO (tal es el caso del ejemplo siguiente que
mostramos: Hola, mundo!, en su método directo) en el cual se incluye el texto a
presentar y el formato de dicho texto, página e impresión.
•
Un segundo caso de obtención de un documento XSL-FO, es transformar un
documento XML (que contenga los datos a presentar), con una hoja de estilos
XSLT. Es decir, conversión XML original a XSL-FO mediante XSLT y un
procesador XSLT. De esta forma los datos (XML) se independizan del formato
que proporcionará la hoja de transformación XSLT.
A continuación se muestran los dos caminos que conducen a la obtención de un
documento XSL-FO. Una vez conseguido dicho documento, se procesa por un
programa llamado “procesador de XSL-FO” para obtener el documento final en el
formato deseado.
CAPITULO 6.- EL FORMATO, XSL-FO
106
Ilustración 18 .- Obtención de un documento XSL-FO
6.6
Procesadores XSL-FO
Un procesador XSL es la aplicación que procesa un documento XML compuesto
de XSL-FOs y lo presenta de manera más legible, de manera que cualquier persona
pueda leerlo con facilidad.
En cuanto a los procesadores XSL-FO, existe una gran variedad, pero cabe
mencionar algunos de los más representativos:
•
XEP, desarrollado por RenderX en Java. Es sin duda alguna el más
avanzado, aunque su gran inconveniente es que se trata de una aplicación
comercial.
•
FOP, es un procesador de XSL-FO desarrollado en Java, empezó a
ser desarrollado en solitario por James Tauber pero posteriormente se
incorporó al “Apache XML Project”.
CAPITULO 6.- EL FORMATO, XSL-FO
107
Es el primero que apareció, es totalmente gratuito y aunque no es tan
potente como el XEP es el más utilizado en la actualidad. Entre sus
ventajas cabe destacar que permite trabajar con documentos SVG.
•
PassiveTex, es una librería de macros en Tex que pueden ser usadas
para procesar documentos XML formados por XSL-FO. Ejecutando
PassiveTex con pdfTex se pueden generar fácilmente documentos PDF.
La gran ventaja de estas librerías es el buen soporte para MathML que
poseen.
•
Unicorn Formatting Objects, UFO que es un procesador de XSLFO implementado en C++. La salida de esta herramienta es TeX y a
partir de este formato podemos generar PostScript, PDF, etc. Como
inconvenientes tenemos que además de ser un producto comercial, solo
se puede utilizar en Windows.
6.6.1. FOP
El FOP (Formatting Object to PDF) es el primer procesador de objetos de
formateo XSL que apareció. Su incorporación al “Apache XML Project” ha contribuido
a un desarrollo acelerado del proyecto comenzado en solitario por James Tauber.
El procesador FOP, además de convertirnos el documento XSL-FO a un
documento en formato fácilmente de visualizar (por ejemplo, .pdf), nos permite
también realizar la transformación previa del documento origen de datos XML al
documento XSL-FO, en un único paso.
Ilustración 19 .- Procesos de Transformación
CAPITULO 6.- EL FORMATO, XSL-FO
108
Esto es debido a que el FOP lleva incorporado el procesador XSLT Xalan, que
nos permite hacer la conversión XML a XSL-FO. Suponiendo que nuestro documento
XML es hola.xml, se obtiene hola.pdf mediante la siguiente orden:
Fop -xsl hola.xsl -xml hola.xml -pdf hola.pdf
Código 63 .- Instrucción de procesado FOP
Con esta instrucción se convierte el fichero XML original y poco legible, a un
documento .pdf que muestra de forma visual e imprimible los datos de origen. El
documento hola.xsl es la hoja de estilo para la transformación.
6.7 Hola, mundo!
Se muestra un sencillo ejemplo del ya conocido: Hola, mundo!. En primer lugar,
se parte del documento de formato .fob, y en segundo caso iniciamos el proceso desde
el inicio, con un documento XML.
6.7.1 Método directo
En un primer intento de impresión de: Hola, Mundo!, se programa directamente el
documento XSL-FO, con lo cual el documento origen del que partiríamos sería:
<?xml version="1.0" encoding="utf-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="hola"
page-height="29.7cm" page-width="21cm"
margin-top="5mm" margin-bottom="10mm"
margin-left="20mm margin-right="20mm">
<fo:region-body margin-top="10mm" margin-bottom="10mm" />
</fo:simple-page-master>
</fo:layout-master-set>
CAPITULO 6.- EL FORMATO, XSL-FO
109
<fo:page-sequence master-reference="hola">
<fo:flow>
<fo:block font-size="12pt" font-family="sans-serif" line-height="15pt">
Hola, mundo!
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
Código 64 .- Hola, mundo!, método directo
Como se puede observar, se trata de un vocabulario XML, en el que todos los
elementos van precedidos del namespace “fo”, y que por tanto debe declararse con el
elemento raíz del documento:
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
Código 65 .- Declaración del namespace
El documento está formado por un conjunto de elementos: fo:simple-page-master,
fo:flow, fo:block, etc., que unidos con sus propiedades (definidas en los atributos): fontsize, font-family, etc., deciden el formato el documento final.
6.7.2
Método Indirecto
En este caso, se llegará al archivo XSL-FO tras aplicarle una trasformación XSL
al documento de datos origen XML.
CAPITULO 6.- EL FORMATO, XSL-FO
110
El documento de transformación XSL:
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/XSL/Format/1.0"
result-ns="fo" indent-result="yes">
<xsl:template match="etiqueta ">
<fo:root xmlns:fo="http://www.w3.org/XSL/Format/1.0">
<fo:layout-master-set>
<fo:simple-page-master page-master-name="primera">
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence>
<fo:sequence-specification>
<fo:sequence-specifier-single page-master-name="primera"/>
</fo:sequence-specification>
<fo:flow>
<fo:block font-size="14pt" font-family="serif">
<xsl:apply-templates select="etiqueta "/>
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
</xsl:template>
</xsl:stylesheet>
Código 66 .- Hola, mundo!, archivo XSL
Este documento de transformación y formateo será aplicado a un documento origen
XML con los datos:
<?xml version="1.0"?>
<etiqueta>
Hola, mundo!
</etiqueta >
Código 67 .- Hola, mundo!, archivo XML
CAPITULO 6.- EL FORMATO, XSL-FO
111
En la hoja de transformación, se ha utilizado dos veces la instrucción:
xmlns:fo="http://www.w3.org/XSL/Format/1.0"
Código 68 .- Espacio de nombres
Esto se debe a que la primera instancia, servirá para el procesamiento de la hoja
de estilos (documento XLS) y la segunda quedará reflejada en el documento .fob, para
que pueda ser utilizada por el segundo procesador, el de formato.
El documento “.fob” resultado de procesar el documento XML con los datos, y la
hoja de estilo XSL, quedará:
<fo:root xmlns:fo="http://www.w3.org/XSL/Format/1.0">
<fo:layout-master-set>
<fo:simple-page-master page-master-name="primera ">
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence>
<fo:sequence-specification>
<fo:sequence-specifier-single page-master-name="primera "/>
</fo:sequence-specification>
<fo:flow>
<fo:block font-size="14pt" font-family="serif">
Hola, mundo!
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
Código 69 .- Hola, mundo!, archivo .fob
Se ha de notar, que los dos ejemplos mostrados no son iguales, difieren en cuanto
a tipo y tamaño de letra a la hora de la impresión.
CAPITULO 6.- EL FORMATO, XSL-FO
112
6.8 Conclusiones
El nombre oficial de la recomendación por la que se rige XSL-FO es: Extensible
Stylesheet Language (XSL) y no XSL-FO. XSL-FO y XSL son por tanto la misma
recomendación, y nos da a conocer el leguaje de formateo de los documentos XML.
La unidad básica para presentar (formatear) la información en un documento
XSL-FO es el “Formating Object”. Mediante los objetos de formateo y sus propiedades
se describen cómo se van a visualizar los elementos de un documento.
Un documento de formato XSL-FO puede ser escrito directamente o ser generado
como salida de un proceso de transformación del documento origen XML y su hoja de
estilo XSL asociada. Una vez conseguido dicho documento, es procesado por un
“Procesador XSL-FO” para obtener el documento final formateado.
Entre la lista de procesadores XSL-FO, se puede destacar: XEP, FOP, PassiveTex,
Unicorn Formatting Objects. De entre todos es FOP es más utilizado en la actualidad.
Fue el primer proyecto de transformación XSL-FO que se empezó a desarrollar,
comenzó a ser desarrollado por James Tauber pero posteriormente se incorporó al
“Apache XML Project”.
CAPITULO 7.- APLICACIÓN DESARROLLADA
114
7. Aplicación desarrollada y pruebas
7.1 Introducción
En el segundo apartado de éste capitulo se representa la implementación de la
aplicación desarrollada. Se expondrá la aplicación que se ha desarrollado y el proceso
que se ha seguido para su consecución.
En un tercer apartado se muestran los programas que se han utilizado tanto para el
desarrollo y la implementación de la aplicación, como para la visualización del
documento final generado.
Finalmente, se reserva un apartado con la explicación, comentarios y pruebas para
cada uno de los documentos implementados necesarios para la visualización de la
aplicación final sobre los tres medios elegidos como salida.
7.2 Implementación de la aplicación desarrollada
Como aplicación, se ha desarrollado una agenda para exámenes, en la que sobre
un calendario aparecerán los días de examen marcados como tal. Además se tendrá
información de las asignaturas a examinar y de algunas de sus características, que
añadirán información adicional.
La aplicación se apoya sobre un documento XML (Extensible Markup Language),
en el que se encontrará información sobre cuál será el mes de exámenes en cuestión,
para así crear el calendario del mes correspondiente. También se tiene información
sobre todas las asignaturas en las que se va a participar en examen.
En el documento origen XML, del que se sirven las tres hojas de estilo XSL
(Extensible Stylesheet Language), para una vez atacado el procesador, dar salida a la
estructura de datos sobre tres medios con formato diferentes:
•
Una primera aplicación dará salida sobre un entorno web, y puede ser
visualizable desde cualquier navegador.
CAPITULO 7.- APLICACIÓN DESARROLLADA
115
•
Un segunda aplicación, tomará como salida un documento final de
impresión, como es PDF (Portable Document Format).
•
Por último, tendremos una aplicación que se podrá visualizar y manejar
en un terminal móvil WAP (Wireless Application Protocol).
Ilustración 20 .- Implementación de la aplicación desarrollada
7.3 Programas instalados
Para poder hacer uso de los programas que se van a utilizar para el desarrollo de la
aplicación, se tiene que tener instalado previamente la máquina virtual de Java, que
puede descargarse desde su página oficial (www.java.com/es/download/ ).
Para llegar a la presentación final de la aplicación, se ha tenido que elegir entre
una serie de editores, procesadores y visualizadores o browsers como herramientas de
desarrollo.
Se ha escogido como herramienta que permite editar XML y hojas de estilo XSLT
(XSL Transform), Excelon Stylus, software que además incorpora un procesador XSLT.
Es una aplicación con una excelente interfaz gráfica, que nos facilita la labor de
programación de los documentos.
A continuación se muestra una imagen con la apariencia de este software:
CAPITULO 7.- APLICACIÓN DESARROLLADA
116
Ilustración 21 .- Stylus Studio
Stylus Studio además de ser un editor, tiene incluido procesadores XSLT, que
permiten aplicar con facilidad las hojas de estilo a los documentos XML. Entre la serie
de procesadores que se pueden elegir para la transformación, podemos encontrar: Xalan,
Saxon y Microsoft MSXML, cada uno en sus distintas versiones.
Ilustración 22 .- Selección procesador Stylus Studio
CAPITULO 7.- APLICACIÓN DESARROLLADA
117
Para aplicar la hoja de estilo XSL al documento XML, basta seleccionar un
procesador XSLT de entre la lista y sobre la pestaña: “General”, indicar la ruta del
documento XML y el documento final generado:
Ilustración 23 .- Asignación de documentos Stylus Studio
Stylus Studio, incorpora procesadores XSLT, pero no lleva a cabo la
transformación XSL-FO (XSL Formatting Objects). Para ello, se ha utilizado el
programa XSL Formatter v4.2, que sí permite esa transformación al incluir un
procesador XSL-FO.
XSL Formatter v4.2 ha sido el primer programa en utilizar la nueva especificación
XSL v1.1 y ha sido lanzado el 27 de Agosto de este presente año 2007. De ahí que haya
sido el software elegido para formatear los documentos.
Éste software incorpora a su vez el proceso de transformación XSLT, por tanto,
para la obtención como documento final de un documento imprimible PDF, solo haría
falta el uso de este software apoyado en un editor.
XSL Formatter v4.2, al igual que Stylus Studio, da la posibilidad de utilizar como
procesador XSLT cualquiera de los más representativos, por defecto utiliza Microsoft
MSXML.
CAPITULO 7.- APLICACIÓN DESARROLLADA
118
Su interfaz gráfica, es muy sencilla, simplemente se le debe de indicar cuál es el
documento XML a transformar y la hoja de estilo que se le quiere aplicar. Genera como
consecuencia de la transformación, el documento intermedio .fo, y seguidamente de
forma automática el documento final PDF.
Ilustración 24 .- XSL Formatter v4.2
Por último, y para poder visualizar la aplicación que se ejecutará sobre un
terminal móvil, se vuelve a hacer uso del programa Stylus Studio para editar y aplicar la
hoja de estilo a la estructura de datos XML y obtener así el documento de final .wml.
Para visualizar la aplicación WML (Wireless Markup Language) generada, se
hace uso de un browser móvil, En este caso se ha utilizado Nokia Mobile Browser
Simulator, que tiene una apariencia:
Ilustración 25 .- Nokia Mobile Browser
CAPITULO 7.- APLICACIÓN DESARROLLADA
7.4 Documento XML
El documento XML con la estructura de la información a transformar es:
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet href="agenda.xsl" type="text/xsl"?>
<calendario>
<mes dia_comienzo="6" n_dias="30">
<nombre> Septiembre 2007</nombre>
</mes>
<url>http://www.esi.us.es</url>
<asignatura id="a1" curso="3">
<nombre>Transmision de Datos</nombre>
<dia>3</dia>
</asignatura>
<asignatura id="a2" curso="4">
<nombre>SOFTWARE de Comunicaciones</nombre>
<dia>6</dia>
</asignatura>
<asignatura id="a3" curso="4">
<nombre>Radiacion y Radiocomunicacion</nombre>
<dia>11</dia>
</asignatura>
<asignatura id="a4" curso="2">
<nombre>Fundamentos de Computadores</nombre>
<dia>8</dia>
</asignatura>
<asignatura id="a5" curso="3">
<nombre>Sistemas de Transmision</nombre>
<dia>4</dia>
</asignatura>
119
CAPITULO 7.- APLICACIÓN DESARROLLADA
120
<asignatura id="a6" curso="4">
<nombre>Tratamiento Digital de Senales</nombre>
<dia>13</dia>
</asignatura>
<asignatura id="a7" curso="5">
<nombre>Lab de Simulacion de Redes y Teletrafico</nombre>
<dia>14</dia>
</asignatura>
<asignatura id="a8" curso="5">
<nombre>Comunicaciones Opticas</nombre>
<dia>18</dia>
</asignatura>
<asignatura id="a9" curso="1">
<nombre>Teoria de Circuitos</nombre>
<dia>15</dia>
</asignatura>
<asignatura id="a10" curso="5">
<nombre>Ampliacion de Conmutacion</nombre>
<dia>17</dia>
</asignatura>
</calendario>
Código 70 .- Documento XML
Se puede destacar del documento XML, que bajo la etiqueta <mes>, están los
atributos dia_comienzo y n_dias que permiten especificar el día de la semana en el que
empieza el mes y el número de días de dicho mes, con el fin de crear a partir de esos
datos el calendario deseado. A la vez, se describe el mes que se está tratando.
Además de lo relativo al mes del calendario de exámenes, se tiene una estructura
con todas las asignaturas de las que se va a examinar. Cada una de ellas está identificada
por un id, y se tiene información del curso, nombre de la asignatura y día de exámen.
Una vez editado el documento XML en Stylus Studio, éste genera
automáticamente un árbol del documento XML, puede verse en la siguiente ilustración.
CAPITULO 7.- APLICACIÓN DESARROLLADA
121
Ilustración 26 .- Árbol XML en Stylus Studio
Además, también se puede encontrar pinchando en la pestaña “Grid”:
Ilustración 27 .- Grid en Stylus Studio
7.5 Aplicación sobre navegador web
En esta versión de la aplicación, se da salida al documento XML sobre un
navegador web al aplicarle convenientemente la hoja de estilo asociada. Se va a estudiar
el código de la hoja de estilo XSL que se utiliza para realizar la transformación.
CAPITULO 7.- APLICACIÓN DESARROLLADA
122
En el siguiente fragmento de código se ilustra la declaración XML, el espacio de
nombres para la transformación, el método de salida elegido y las variables que se van a
utilizar a lo largo de la hoja de estilo, tomando un cierto valor a cada una de ellas.
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:output method="html" encoding="ISO-8859-1" indent="yes"/>
<xsl:variable name="numero_asig" select="count(//asignatura)"/>
<xsl:variable name="comienzo" select="/calendario/mes/@dia_comienzo"/>
<xsl:variable name="dias_mes" select="/calendario/mes/@n_dias"/>
<xsl:variable name="total" select="$comienzo + $dias_mes - 1"/>
<xsl:variable name="overflow" select="$total mod 7"/>
Código 71 .- Variables de la hoja de estilo
Se define la variable n_elementos, que será el número total de elementos que
aparecerán sobre el calendario, contando tanto los días sin examen como los que sí
tengan exámen.
<xsl:variable name="n_elementos">
<xsl:choose>
<xsl:when test="$overflow > 0">
<xsl:value-of select="$total + 7 - $overflow"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$total"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
Código 72 .- Definición de la variable: n_elementos
Definición de la plantilla principal:
<xsl:template match="calendario">
<html>
<head>
<title>Exámenes <xsl:value-of select="/calendario/mes/nombre"/></title>
</head>
<body bgcolor="lightblue">
<br/>
<h1 align="center">
Agenda de Exámenes <xsl:value-of select="/calendario/mes/nombre"/>
</h1>
<br/>
CAPITULO 7.- APLICACIÓN DESARROLLADA
123
<table title="Calendario" border="2" bgcolor="lightgoldenrodyellow"
align="left">
<tr bgcolor="white">
<th>Lunes</th>
<th>Martes</th>
<th>Miercoles</th>
<th>Jueves</th>
<th>Viernes</th>
<th>Sabado</th>
<th>Domingo</th>
</tr>
<xsl:call-template name="mes"/>
</table>
Código 73 .- Comienzo de la plantilla principal de agenda_html.xsl
En el trozo de código anterior se ve cómo se le pone título a la página y un
enunciado principal.
Además se hace una primera tabla que será la que sirve de calendario. La primera
fila de la tabla se rellenará con los días de la semana y posteriormente se llamará a la
plantilla mes, para que comience a rellenar los demás elementos de la tabla (calendario),
poniendo tanto los días sin examen como marcando como tal los que sí haya exámen.
Continuando con la definición de la plantilla principal:
<div class="tablaCentral">
<table title="Fechas" align="right" border="1"
bgcolor="lightgoldenrodyellow" borderwidth="4">
<tr bgcolor="white">
<th class="curso">Curso</th>
<th class="nombre">Asignatura</th>
<th class="dia">Fecha</th>
</tr>
<xsl:apply-templates select="asignatura">
<xsl:sort select="dia" data-type="number"/>
</xsl:apply-templates>
<tr>
<td class="final" colspan="3" align="center"
bgcolor="white">Número de exámenes:
<xsl:value-of select="$numero_asig"/>
</td>
</tr>
</table>
</div>
Código 74 .- Definición de la tabla de asignaturas para HTML
CAPITULO 7.- APLICACIÓN DESARROLLADA
124
Este código anterior, que también pertenece a la plantilla principal, hace
referencia a una segunda tabla que es la que se va a ir rellenando con el nombre de las
asignaturas pendientes, poniendo además el curso y el día de exámen de cada
asignatura.
Para llevar a cabo la tarea de relleno de la tabla, aplicamos la plantilla asignatura,
a la que se le indica que la tabla éste ordenada por el día de exámen.
La última fila de la tabla es la que se utiliza para poner el número total de
asignaturas a las que se va a presentar.
La definición de la plantilla principal termina con el código que se expone a
continuación, el cual permite poner un enlace la página de la Escuela de Ingenieros y el
botón “Volver” para regresar a la página anterior.
<br/>
<br/>
<h3 align="center">Para consulta sobre las asignaturas:
<a href="{url}">
<xsl:value-of select="url"/>
</a>
</h3>
<br/>
<br/>
<br/>
<tr>
<td width="100%">
<table border="0" width="100%" cellpadding="2">
<tr>
<td width="100%" bgcolor="#add8e6" align="center">
<input type="submit" name="Volver" value="Volver"/>
</td>
</tr>
</table>
</td>
</tr>
</body>
</html>
</xsl:template>
Código 75 .- Cierre de la plantilla principal de agenda_html.xsl
CAPITULO 7.- APLICACIÓN DESARROLLADA
125
La siguiente plantilla que se encuentra en la hoja de estilo XSL es la plantilla mes,
que se utiliza para comenzar a formar el calendario. Su función es llamar a la plantilla
semana, una primera vez y cada vez que esta le devuelva la llamada, para así completar
todas las semanas del mes del calendario. A la plantilla semana, se le pasa el parámetro
indice, que se corresponde con el día que toca analizar si es día de exámen o no.
La plantilla semana llama a la plantilla dias, pasandole a esta plantilla también el
parámetro indice que hace referencia a un determinado día y el parámetro contador, que
es: indice + 6, y por tanto indicará que se va a rellenar toda una semana.
<!-- Solo es llamado una vez por 'root' -->
<!-- Utiliza recursividad con indice+7 para cada semana-->
<xsl:template name="mes">
<xsl:param name="indice" select="1"/>
<xsl:if test="$indice < $n_elementos">
<xsl:call-template name="semana">
<xsl:with-param name="indice" select="$indice"/>
</xsl:call-template>
<xsl:call-template name="mes">
<xsl:with-param name="indice" select="$indice + 7"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
<!-- Se llama el template 'mes' cada semana -->
<xsl:template name="semana">
<xsl:param name="indice" select="1"/>
<tr>
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice"/>
<xsl:with-param name="contador" select="$indice + 6"/>
</xsl:call-template>
</tr>
</xsl:template>
Código 76 .- Plantillas 'mes' y 'semana' para formar el calendario
CAPITULO 7.- APLICACIÓN DESARROLLADA
126
La plantilla dias, que se expone a continuación, elige entre las diferentes
posibilidades de impresión que presenta el día que se va a analizar. En caso de que el
mes no haya empezado o ya haya terminado, se utilizará “-” sobre ese día de la semana.
Una vez empezado el mes, se imprime “Examen” si el día estudiado es reconocido
como tal, en otro caso aparece el número del día del mes.
<!-- Es llamado por semana -->
<!-- Rutina que va imprimiendo cada dia de la semana, usando recursividad con:
indice+1-->
<xsl:template name="dias">
<xsl:param name="indice" select="1"/>
<xsl:param name="contador" select="1"/>
<xsl:choose>
<xsl:when test="$indice < $comienzo">
<td align="center">-</td>
</xsl:when>
<xsl:when test="$indice - $comienzo + 1 > $dias_mes">
<td align="center">-</td>
</xsl:when>
<xsl:when test="$indice > $comienzo - 1">
<td align="center">
<xsl:choose>
<xsl:when test="($indice - $comienzo + 1) = ./asignatura/dia">
<text>Exámen</text>
</xsl:when>
<xsl:when test="($indice - $comienzo + 1) != ./asignatura/dia">
<xsl:value-of select="$indice - $comienzo + 1"/>
</xsl:when>
</xsl:choose>
</td>
</xsl:when>
</xsl:choose>
CAPITULO 7.- APLICACIÓN DESARROLLADA
127
<xsl:if test="$contador > $indice">
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice + 1"/>
<xsl:with-param name="contador" select="$contador"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
Código 77 .- Plantilla ‘dias’ para el calendario en HTML
Por último, solo queda la plantilla asignatura que es llamada desde la plantilla
principal en la definición de la tabla de asignaturas, y la función de ésta plantilla es
imprimir el nombre, curso y día de cada asignatura.
<xsl:template match="asignatura">
<tr>
<td class="curso" align="center">
<xsl:value-of select="@curso"/>º</td>
<td class="nombre" align="center">
<xsl:value-of select="nombre"/>
</td>
<td class="dia" align="center">
<xsl:value-of select="dia"/>
<xsl:value-of select="../mes/nombre"/>
</td>
</tr>
</xsl:template>
</xsl:stylesheet>
Código 78 .- Plantilla que imprime las asignaturas para HTML
CAPITULO 7.- APLICACIÓN DESARROLLADA
7.5.1.
128
Pruebas
La salida que se obtiene al procesar el documento XML con la hoja de estilo
anterior, es un documento HTML, se va a presentar sobre dos navegadores diferentes.
En Internet Explorer toma la salida que se muestra en la siguiente imagen.
Ilustración 28 .- Agenda para exámenes en Internet Explorer
Puede verse, que en esta versión de la aplicación, las asignaturas aparecen
ordenadas por la fecha de examen y aparece el número total de exámenes a los que se va
a presentar la persona.
Además existe un enlace a la página de la Escuela de Ingenieros para más
información. El botón “Volver” regresaría a la página que pidió la petición de mostrar la
agenda de exámenes.
CAPITULO 7.- APLICACIÓN DESARROLLADA
129
Mientras que en Mozilla Firefox:
Ilustración 29 .- Agenda para exámenes en Mozilla Firefox
En ambos navegadores en los que se ha mostrado la salida, la diferencia de
presentación es mínima.
7.6 Aplicación para documentos PDF
En este caso la hoja de estilo que da formato al documento XML contiene
elementos FO (Formatting Objects), para que se pueda dar salida al documento origen
sobre un documento imprimible PDF.
En la declaración de documento XML, declaración del namespace y definición de
las variables que se van a utilizar, no se encuentra diferencia con la hoja de estilo
anterior. Únicamente se debe de añadir una nueva línea de declaración del espacio de
nombres fo en el elemento stylesheet:
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format">
Código 79 .- Declaración del espacio de nombres FO
CAPITULO 7.- APLICACIÓN DESARROLLADA
130
A continuación se comenta la plantilla principal de la hoja de estilo. En el
siguiente trozo de código, aparece la definición del formato de página, además de los
dos primeros bloques de la misma, que no son más que dos encabezados. En el primero
se enuncia la página como: “Agenda de asignaturas pendientes + mes de examenes”, y
en el segundo aparece un texto cómo: “Calendario de exámenes”.
Por último también se define un bloque que contendrá una tabla, dicha tabla va a
tener una sola fila y para rellenarla se hace uso del template diassemana.
<xsl:template match="calendario">
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="simple" page-height="29.7cm"
page-width="21cm" margin-top="3cm" margin-bottom="2cm"
margin-left="2.5cm" margin-right="2.5cm">
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="simple">
<fo:flow flow-name="xsl-region-body">
<fo:block font-size="20pt" font-weight="bold" font-family="serif"
color="maroon" space-after="15mm" text-align="center">
Agenda de asignaturas pendientes
<xsl:value-of select="/calendario/mes/nombre"/></fo:block>
<fo:block font-size="14pt" font-weight="bold" font-family="serif"
color="maroon" space-after="5mm" text-align="left">
Calendario de exámenes</fo:block>
<fo:block font-size="14pt" text-align="center">
<fo:table table-layout="fixed" border="1px ridge"
background-color="peru">
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-body>
<xsl:call-template name="diassemana"/>
</fo:table-body>
</fo:table>
</fo:block>
Código 80 .- Comienzo de la plantilla principal de agenda_pdf.xsl
CAPITULO 7.- APLICACIÓN DESARROLLADA
131
El siguiente fragmento de código define una tabla, y es la que hace función de
calendario sobre el que se ponen los días de exámen. Para rellenar el calendario con los
días de exámen, se llama a la plantilla mes.
<fo:block font-size="14pt" text-align="center" space-after="13mm">
<fo:table table-layout="fixed" border="1px ridge"
background-color="moccasin">
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-body>
<xsl:call-template name="mes"/>
</fo:table-body>
</fo:table>
</fo:block>
Código 81 .- Definición de la tabla calendario para documento pdf
Se definen dos nuevos bloques, el primero será una presentación del segundo, que
será de nuevo otra tabla. En esta tabla se enumeran las asignaturas a examinar junto con
el curso al que pertenecen y el día del exámen. Las asignaturas quedarán ordenadas por
curso:
<fo:block font-size="14pt" font-weight="bold" font-family="serif"
color="maroon" space-after="5mm" text-align="left">
Listado de asignaturas pendientes ordenadas por curso</fo:block>
<fo:block font-size="12pt">
<fo:table table-layout="fixed">
<fo:table-column column-width="1.7cm"/>
<fo:table-column column-width="1.25cm"
border-top-width="1cm"/>
<fo:table-column column-width="8cm"/>
<fo:table-body>
<xsl:apply-templates select="asignatura">
<xsl:sort select="@curso" data-type="text"/>
</xsl:apply-templates>
</fo:table-body>
</fo:table>
</fo:block>
Código 82 .- Definición de la tabla con las asignaturas para pdf
CAPITULO 7.- APLICACIÓN DESARROLLADA
132
Un último bloque en la plantilla general añade una nueva línea con un link en el
que obtener mayor información de las asignaturas.
<fo:block space-before="5mm" font-style="italic" font-family="serif"
color="maroon" text-indent="4cm">
<xsl:element name="fo:basic-link">
<xsl:attribute name="external-destination">
<xsl:value-of select="url"/>
</xsl:attribute>Para información de asignaturas, visitar la web de
la E.S.I.</xsl:element>
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
</xsl:template>
Código 83 .- Cierre de la plantilla principal para pdf
La plantilla diassemana, es llamada en la definición de su correspondiente tabla
en la plantilla principal y con ella se imprimen en una tabla de una única fila los días de
la semana
<xsl:template name="diassemana">
<fo:table-row>
<fo:table-cell>
<fo:block line-height="1cm">Lunes</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Martes</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Miercoles</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Jueves</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Viernes</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Sabado</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Domingo</fo:block>
</fo:table-cell>
</fo:table-row>
</xsl:template>
Código 84 .- Impresión de los días de la semana en pdf
CAPITULO 7.- APLICACIÓN DESARROLLADA
133
Esta plantilla es utilizada para la impresión de la lista de asignaturas a examinar
junto con el curso y el día de exámen. Todas las asignaturas de un mismo curso
aparecerán con un mismo color de fuente, pero diferente al de otro curso, para poder
diferenciarse a la hora de la impresión.
<xsl:template match="asignatura">
<fo:table-row>
<xsl:choose>
<xsl:when test="@curso='1'">
<xsl:attribute name="color">rgb(128,64,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso='2'">
<xsl:attribute name="color">rgb(255,128,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso= '3'">
<xsl:attribute name="color">rgb(128,64,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso= '4'">
<xsl:attribute name="color">rgb(255,128,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso= '5'">
<xsl:attribute name="color">rgb(128,64,0)</xsl:attribute>
</xsl:when>
</xsl:choose>
<fo:table-cell>
<fo:block line-height="0.6cm">
<xsl:value-of select="@curso"/>º Curso,</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="0.6cm">día
<xsl:value-of select="dia"/>,</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="0.6cm">
<xsl:value-of select="nombre"/>.</fo:block>
</fo:table-cell>
</fo:table-row>
</xsl:template>
Código 85 .- Plantilla que imprime las asignaturas para documento pdf
Las plantillas mes y semana, no se exponen de nuevo al tener la misma función y
código que en la anterior hoja de estilo.
CAPITULO 7.- APLICACIÓN DESARROLLADA
134
Si que se revisa el código del template dia. No varía el significado de esta plantilla
respecto a la hoja de estilo anterior, pero si su estructura al tener en este caso que
utilizar objetos de formateo para su impresión en PDF.
<!-- Es llamado por semana -->
<xsl:template name="dias">
<xsl:param name="indice" select="1"/>
<xsl:param name="contador" select="1"/>
<xsl:choose>
<xsl:when test="$indice < $comienzo">
<fo:table-cell>
<fo:block line-height="0.8cm">-</fo:block>
</fo:table-cell>
</xsl:when>
<xsl:when test="$indice - $comienzo + 1 > $dias_mes">
<fo:table-cell>
<fo:block line-height="0.8cm">-</fo:block>
</fo:table-cell>
</xsl:when>
<xsl:when test="$indice > $comienzo - 1">
<fo:table-cell>
<fo:block line-height="0.8cm">
<xsl:choose>
<xsl:when test="($indice - $comienzo + 1) = ./asignatura/dia">
<fo:block color="rgb(128,64,0)">Exámen</fo:block>
</xsl:when>
<xsl:when test="($indice - $comienzo + 1) != ./asignatura/dia">
<xsl:value-of select="$indice - $comienzo + 1"/>
</xsl:when>
</xsl:choose>
</fo:block>
</fo:table-cell>
</xsl:when>
</xsl:choose>
<xsl:if test="$contador > $indice">
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice + 1"/>
<xsl:with-param name="contador" select="$contador"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
Código 86 .- Template dia para documento pdf
CAPITULO 7.- APLICACIÓN DESARROLLADA
135
7.6.1 Pruebas
En esta versión de la aplicación de agenda para exámenes, se necesita además de
un procesador XSLT, un procesador XSL-FO, puesto que se está trabajando con objetos
de formateo. El programa que incluye ambos procesadores y del que se hace uso es XSL
Formatter v4.2.
La salida con formato, tras aplicar ambos procesos de transformación y formateo,
tiene una apariencia:
Ilustración 30 .- Agenda para exámenes en PDF I
En este caso, vemos como los objetos de formateo permiten dar mayor formato a
la salida que la simple transformación que puede hacer un procesador XSLT aislado.
La lista de exámenes aparece ordenada por curso, distinguiéndose cada uno de los
mismos por el color de la fuente utilizada. Los días de examen también aparecen con
otro tono de color distinto sobre el calendario.
CAPITULO 7.- APLICACIÓN DESARROLLADA
136
Por último, se vuelve a tener un enlace a la web de la Escuela de Ingenieros, en
caso de querer realizar alguna consulta.
XSL Formatter v4.2 permite generar directamente, el documento PDF, una vista
del documento generado:
Ilustración 31 .- Agenda para exámenes en PDF II
CAPITULO 7.- APLICACIÓN DESARROLLADA
137
7.7 Aplicación sobre dispositivo móvil
En este caso, se elige como medio de salida del documento XML original, un
dispositivo móvil WAP.
El documento WML de salida, será generado por un procesador XSLT a raíz del
documento XML y la hoja de estilo XSL adecuada. Se va a ver la parte de código en
que se diferencia la hoja de estilo diseñada para este caso con las anteriores.
La línea de declaración del método de la salida, toma en este caso una
descripción:
<xsl:output encoding="iso-8859-1" doctype-public="-//WAPFORUM//DTD WML
1.1//EN" doctype-system="http://www.wapforum.org/DTD/wml_1.1.xml"
indent="yes"/>
Código 88 .- Declaración del método de salida WML
Mientras que las demás líneas de declaración y definición de variables
permanecen inalteradas.
La plantilla principal en este caso, presenta la forma:
<xsl:template match="/">
<wml>
<template>
<do type="prev">
<prev/>
</do>
<do type="Indice">
<go href="#indice"/>
</do>
</template>
<card id="indice" title="Agenda de Examenes">
<p align="center">
<br/>
<big>
<b>
<xsl:value-of select="calendario/mes/nombre"/>
</b>
</big>
<br/>
<br/>
</p>
CAPITULO 7.- APLICACIÓN DESARROLLADA
138
<p>
<table columns="7">
<tr>
<td>L</td>
<td>M</td>
<td>X</td>
<td>J</td>
<td>V</td>
<td>S</td>
<td>D</td>
</tr>
<xsl:call-template name="mes"/>
</table>
</p>
</card>
<xsl:apply-templates select="calendario/asignatura"/>
</wml>
</xsl:template>
Código 89 .- Template principal para hoja de estilo con salida WML
Destacar la creación de una carta principal para la página de presentación de la
aplicación, en la que aparecerá un calendario de exámenes con el título de: “Agenda de
examenes + mes”. El calendario de exámenes se creará en forma de tabla, la cual hace
referencia a la llamada de la plantilla mes para rellenar cada día del calendario.
Por medio de la regla apply-templates en la que se seleccionan las asignaturas, se
hace una llamada a la plantilla que se muestra a continuación para cada una de las
asignaturas:
<xsl:template match="calendario/asignatura">
<card id="{@id}" title="Dia {dia}{../mes/nombre}">
<p align="left">
<big>Examen:
<b>
<xsl:value-of select="nombre"/>, </b>
<xsl:value-of select="@curso"/>Curso.</big>
</p>
</card>
</xsl:template>
Código 90 .- Plantilla que crea una Tarjeta para cada asignatura en WML
En el código anterior, se crea una tarjeta para cada una de las asignaturas. El título
en cada tarjeta será la fecha del exámen de esa asignatura y como texto principal
aparecerá el nombre y curso de la asignatura.
CAPITULO 7.- APLICACIÓN DESARROLLADA
139
Las plantillas mes y semana que formarán el calendario, son las mismas que para
las anteriores hojas de estilo.
El template dias sí se muestra a continuación, y en él se hace una elección de
cómo rellenar cada casilla de la tabla calendario dependiendo del día de que se trate.
Cada casilla de la tabla se rellenará con el número de día y un enlace a la tarjeta
del exámen fijado para ese día, si ese día esta previsto para exámen. En caso de no ser
día de exámen simplemente se imprimirá el número del día a que se corresponde.
<!-- Es llamado por semana -->
<!-- Rutina que va imprimiendo cada dia de la semana, usando recursividad con:
indice+1-->
<xsl:template name="dias">
<xsl:param name="indice" select="1"/>
<xsl:param name="contador" select="1"/>
<xsl:choose>
<xsl:when test="$indice < $comienzo">
<td>-</td>
</xsl:when>
<xsl:when test="$indice - $comienzo + 1 > $dias_mes">
<td>-</td>
</xsl:when>
<xsl:when test="$indice > $comienzo - 1">
<td>
<xsl:choose>
<xsl:when test="($indice-$comienzo+1)=calendario/asignatura/dia">
<xsl:for-each select="calendario/asignatura">
<xsl:if test="($indice - $comienzo + 1) = dia">
<a href="#{@id}">
<xsl:value-of select="$indice - $comienzo + 1"/>
</a>
</xsl:if>
</xsl:for-each>
</xsl:when>
<xsl:whentest="($indice-$comienzo+1)!=calendario/asignatura/dia">
<xsl:value-of select="$indice - $comienzo + 1"/>
</xsl:when>
</xsl:choose>
</td>
</xsl:when>
</xsl:choose>
CAPITULO 7.- APLICACIÓN DESARROLLADA
140
<xsl:if test="$contador > $indice">
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice + 1"/>
<xsl:with-param name="contador" select="$contador"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
Código 91 .- Plantilla dia para generación del documento WML
7.7.1 Pruebas
La aplicación se visualizará en un principio en el programa Nokia Mobile
Browser Simulator.
Ilustración 32 .- Agenda para exámenes en NMB I
CAPITULO 7.- APLICACIÓN DESARROLLADA
141
Como se puede observar, el calendario de exámenes muestra enlaces en las fechas
en las que existen exámenes.
Moviéndose en el calendario con los cursores que facilita el browser, te puedes
colocar sobre uno de los días señalado como día de examen y hacer clic sobre el botón
central.
Con ello, se accede a una nueva página en la que aparece el examen previsto para
tal fecha y el curso en el que se imparte esa asignatura. Por ejemplo, si se hace click
sobre el día 4 de Septiembre, se muestra:
Ilustración 33 .- Agenda para exámenes en NMB II
Pulsando sobre el botón “Back” se vuelve a la página principal del calendario de
exámenes.
También se ha utilizado otro tipo de visualizador para aplicaciones móviles un
poco más moderno. La aplicación se carga sobre un Motorota V3i y un Sony Ericsson
K750i.
CAPITULO 7.- APLICACIÓN DESARROLLADA
142
La vista de la aplicación en su página principal del calendario es:
Ilustración 34 .- Agenda para exámenes YoSpace I
En la siguiente imagen se muestra una fecha concreta de examen en cada uno de
losterminales:
Ilustración 35 .- Agenda para exámenes YoSpace II
CAPITULO 7.- APLICACIÓN DESARROLLADA
143
Se puede apreciar cómo existen diferencias dependiendo del browser móvil sobre
el que se cargue la aplicación. La salida de la aplicación es distinta tanto para el modelo
de Nokia como para el Motorota V3i y el Sony Ericsson k750i.
7.8 Conclusiones
Se ha visto la salida de la aplicación implementada en los tres diferentes medios
elegidos, y se ha introducido el software necesario utilizado tanto para el desarrollo de
la herramienta como para su visualización final.
Para la edición de los documentos XSM y XSL se ha utilizado el software
Excelon Stylus Studio, que además tiene incluido un procesador XSLT y será el que se
utilizará para hacer las transformaciones.
El programa XSL Formatter v4.2 es el que se utiliza para hacer uso del procesador
XSL-FO que dará formato a los documentos. Se ha utilizado éste software por ser el
primero que ha incluido un procesador XSL-FO con la especificación XSL v1.1. La
fecha de lanzamiento de esta versión del programa es del 27 de Agosto de 2007.
Ha sido incluido el código necesitado para crear la estructura de datos y código
que define las hojas de estilo que permiten especificar la transformación y formato
deseado.
CAPITULO 8.- PLANOS DE CÓDIGO
8. Planos de Código
8.1 Documento XML
El documento XML (Extensible Markup Language) que se utiliza como
estructura de datos es:
<?xml version="1.0" encoding="iso-8859-1"?>
<?xml-stylesheet href="agenda.xsl" type="text/xsl"?>
<calendario>
<mes dia_comienzo="6" n_dias="30">
<nombre> Septiembre 2007</nombre>
</mes>
<url>http://www.esi.us.es</url>
<asignatura id="a1" curso="3">
<nombre>Transmision de Datos</nombre>
<dia>3</dia>
</asignatura>
<asignatura id="a2" curso="4">
<nombre>SOFTWARE de Comunicaciones</nombre>
<dia>6</dia>
</asignatura>
<asignatura id="a3" curso="4">
<nombre>Radiacion y Radiocomunicacion</nombre>
<dia>11</dia>
</asignatura>
<asignatura id="a4" curso="2">
<nombre>Fundamentos de Computadores</nombre>
<dia>8</dia>
</asignatura>
<asignatura id="a5" curso="3">
<nombre>Sistemas de Transmision</nombre>
<dia>4</dia>
</asignatura>
145
CAPITULO 8.- PLANOS DE CÓDIGO
146
<asignatura id="a6" curso="4">
<nombre>Tratamiento Digital de Senales</nombre>
<dia>13</dia>
</asignatura>
<asignatura id="a7" curso="5">
<nombre>Lab de Simulacion de Redes y Teletrafico</nombre>
<dia>14</dia>
</asignatura>
<asignatura id="a8" curso="5">
<nombre>Comunicaciones Opticas</nombre>
<dia>18</dia>
</asignatura>
<asignatura id="a9" curso="1">
<nombre>Teoria de Circuitos</nombre>
<dia>15</dia>
</asignatura>
<asignatura id="a10" curso="5">
<nombre>Ampliacion de Conmutacion</nombre>
<dia>17</dia>
</asignatura>
</calendario>
Código 92 .- Estructura de datos de la aplicación: agenda.xml
8.2 Hoja de estilo para transformación a HTML
La hoja de estilos XSL (Extensible Stylesheet Language), que se aplica en la
transformación XSLT (XSL Transform) del documento XML anterior para su
visualización sobre un navegador web es:
CAPITULO 8.- PLANOS DE CÓDIGO
147
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:output method="html" encoding="ISO-8859-1" indent="yes"/>
<xsl:variable name="numero_asig" select="count(//asignatura)"/>
<xsl:variable name="comienzo" select="/calendario/mes/@dia_comienzo"/>
<xsl:variable name="dias_mes" select="/calendario/mes/@n_dias"/>
<xsl:variable name="total" select="$comienzo + $dias_mes - 1"/>
<xsl:variable name="overflow" select="$total mod 7"/>
<xsl:variable name="n_elementos">
<xsl:choose>
<xsl:when test="$overflow > 0">
<xsl:value-of select="$total + 7 - $overflow"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$total"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<xsl:template match="calendario">
<html>
<head>
<title>Exámenes <xsl:value-of select="/calendario/mes/nombre"/></title>
</head>
<body bgcolor="lightblue">
<br/>
<h1 align="center">
Agenda de Exámenes <xsl:value-of select="/calendario/mes/nombre"/>
</h1>
<br/>
<table title="Calendario" border="2" bgcolor="lightgoldenrodyellow"
align="left">
<tr bgcolor="white">
<th>Lunes</th>
<th>Martes</th>
<th>Miercoles</th>
<th>Jueves</th>
<th>Viernes</th>
<th>Sabado</th>
<th>Domingo</th>
</tr>
<xsl:call-template name="mes"/>
</table>
CAPITULO 8.- PLANOS DE CÓDIGO
<div class="tablaCentral">
<table title="Fechas" align="right" border="1"
bgcolor="lightgoldenrodyellow" borderwidth="4">
<tr bgcolor="white">
<th class="curso">Curso</th>
<th class="nombre">Asignatura</th>
<th class="dia">Fecha</th>
</tr>
<xsl:apply-templates select="asignatura">
<xsl:sort select="dia" data-type="number"/>
</xsl:apply-templates>
<tr>
<td class="final" colspan="3" align="center"
bgcolor="white">Número de exámenes:
<xsl:value-of select="$numero_asig"/>
</td>
</tr>
</table>
</div>
<br/>
<br/>
<h3 align="center">Para consulta sobre las asignaturas:
<a href="{url}">
<xsl:value-of select="url"/>
</a>
</h3>
<br/>
<br/>
<br/>
<tr>
<td width="100%">
<table border="0" width="100%" cellpadding="2">
<tr>
<td width="100%" bgcolor="#add8e6" align="center">
<input type="submit" name="Volver" value="Volver"/>
</td>
</tr>
</table>
</td>
</tr>
</body>
</html>
</xsl:template>
148
CAPITULO 8.- PLANOS DE CÓDIGO
<!-- Solo es llamado una vez por 'root' -->
<!-- Utiliza recursividad con indice+7 para cada semana-->
<xsl:template name="mes">
<xsl:param name="indice" select="1"/>
<xsl:if test="$indice < $n_elementos">
<xsl:call-template name="semana">
<xsl:with-param name="indice" select="$indice"/>
</xsl:call-template>
<xsl:call-template name="mes">
<xsl:with-param name="indice" select="$indice + 7"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
<!-- Se llama el template 'mes' cada semana -->
<xsl:template name="semana">
<xsl:param name="indice" select="1"/>
<tr>
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice"/>
<xsl:with-param name="contador" select="$indice + 6"/>
</xsl:call-template>
</tr>
</xsl:template>
<!-- Es llamado por semana -->
<!-- Rutina que va imprimiendo cada dia de la semana, usando recursividad con:
indice+1-->
<xsl:template name="dias">
<xsl:param name="indice" select="1"/>
<xsl:param name="contador" select="1"/>
<xsl:choose>
<xsl:when test="$indice < $comienzo">
<td align="center">-</td>
</xsl:when>
<xsl:when test="$indice - $comienzo + 1 > $dias_mes">
<td align="center">-</td>
</xsl:when>
149
CAPITULO 8.- PLANOS DE CÓDIGO
<xsl:when test="$indice > $comienzo - 1">
<td align="center">
<xsl:choose>
<xsl:when test="($indice - $comienzo + 1) = ./asignatura/dia">
<text>Exámen</text>
</xsl:when>
<xsl:when test="($indice - $comienzo + 1) != ./asignatura/dia">
<xsl:value-of select="$indice - $comienzo + 1"/>
</xsl:when>
</xsl:choose>
</td>
</xsl:when>
</xsl:choose>
<xsl:if test="$contador > $indice">
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice + 1"/>
<xsl:with-param name="contador" select="$contador"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="asignatura">
<tr>
<td class="curso" align="center">
<xsl:value-of select="@curso"/>º</td>
<td class="nombre" align="center">
<xsl:value-of select="nombre"/>
</td>
<td class="dia" align="center">
<xsl:value-of select="dia"/>
<xsl:value-of select="../mes/nombre"/>
</td>
</tr>
</xsl:template>
</xsl:stylesheet>
Código 93 .- Código de la hoja de estilo agenda_html.xsl
150
CAPITULO 8.- PLANOS DE CÓDIGO
151
8.3 Hoja de estilo para transformación a PDF
La hoja de estilo que da formato al documento XML para su salida sobre un
documento PDF (Portable Document Format) es:
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format">
<xsl:output method="xml" version="1.0" indent="yes"/>
<xsl:variable name="comienzo" select="/calendario/mes/@dia_comienzo"/>
<xsl:variable name="dias_mes" select="/calendario/mes/@n_dias"/>
<xsl:variable name="total" select="$comienzo + $dias_mes - 1"/>
<xsl:variable name="overflow" select="$total mod 7"/>
<xsl:variable name="n_elementos">
<xsl:choose>
<xsl:when test="$overflow > 0">
<xsl:value-of select="$total + 7 - $overflow"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$total"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
CAPITULO 8.- PLANOS DE CÓDIGO
<xsl:template match="calendario">
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="simple" page-height="29.7cm"
page-width="21cm" margin-top="3cm" margin-bottom="2cm"
margin-left="2.5cm" margin-right="2.5cm">
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="simple">
<fo:flow flow-name="xsl-region-body">
<fo:block font-size="20pt" font-weight="bold" font-family="serif"
color="maroon" space-after="15mm" text-align="center">
Agenda de asignaturas pendientes
<xsl:value-of select="/calendario/mes/nombre"/></fo:block>
<fo:block font-size="14pt" font-weight="bold" font-family="serif"
color="maroon" space-after="5mm" text-align="left">
Calendario de exámenes</fo:block>
<fo:block font-size="14pt" text-align="center">
<fo:table table-layout="fixed" border="1px ridge"
background-color="peru">
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-body>
<xsl:call-template name="diassemana"/>
</fo:table-body>
</fo:table>
</fo:block>
152
CAPITULO 8.- PLANOS DE CÓDIGO
<fo:block font-size="14pt" text-align="center" space-after="13mm">
<fo:table table-layout="fixed" border="1px ridge"
background-color="moccasin">
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-column column-width="2.2cm"/>
<fo:table-body>
<xsl:call-template name="mes"/>
</fo:table-body>
</fo:table>
</fo:block>
<fo:block font-size="14pt" font-weight="bold" font-family="serif"
color="maroon" space-after="5mm" text-align="left">
Listado de asignaturas pendientes ordenadas por curso</fo:block>
<fo:block font-size="12pt">
<fo:table table-layout="fixed">
<fo:table-column column-width="1.7cm"/>
<fo:table-column column-width="1.25cm"
border-top-width="1cm"/>
<fo:table-column column-width="8cm"/>
<fo:table-body>
<xsl:apply-templates select="asignatura">
<xsl:sort select="@curso" data-type="text"/>
</xsl:apply-templates>
</fo:table-body>
</fo:table>
</fo:block>
<fo:block space-before="5mm" font-style="italic" font-family="serif"
color="maroon" text-indent="4cm">
<xsl:element name="fo:basic-link">
<xsl:attribute name="external-destination">
<xsl:value-of select="url"/>
</xsl:attribute>Para información de asignaturas, visitar la web de
la E.S.I.</xsl:element>
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
</xsl:template>
153
CAPITULO 8.- PLANOS DE CÓDIGO
<xsl:template name="diassemana">
<fo:table-row>
<fo:table-cell>
<fo:block line-height="1cm">Lunes</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Martes</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Miercoles</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Jueves</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Viernes</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Sabado</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="1cm">Domingo</fo:block>
</fo:table-cell>
</fo:table-row>
</xsl:template>
<xsl:template match="asignatura">
<fo:table-row>
<xsl:choose>
<xsl:when test="@curso='1'">
<xsl:attribute name="color">rgb(128,64,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso='2'">
<xsl:attribute name="color">rgb(255,128,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso= '3'">
<xsl:attribute name="color">rgb(128,64,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso= '4'">
<xsl:attribute name="color">rgb(255,128,0)</xsl:attribute>
</xsl:when>
<xsl:when test="@curso= '5'">
<xsl:attribute name="color">rgb(128,64,0)</xsl:attribute>
</xsl:when>
</xsl:choose>
154
CAPITULO 8.- PLANOS DE CÓDIGO
<fo:table-cell>
<fo:block line-height="0.6cm">
<xsl:value-of select="@curso"/>º Curso,</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="0.6cm">día
<xsl:value-of select="dia"/>,</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block line-height="0.6cm">
<xsl:value-of select="nombre"/>.</fo:block>
</fo:table-cell>
</fo:table-row>
</xsl:template>
<!-- Solo es llamado una vez por 'root' -->
<!-- Utiliza recursividad con indice+7 para cada semana-->
<xsl:template name="mes">
<xsl:param name="indice" select="1"/>
<xsl:if test="$indice < $n_elementos">
<xsl:call-template name="semana">
<xsl:with-param name="indice" select="$indice"/>
</xsl:call-template>
<xsl:call-template name="mes">
<xsl:with-param name="indice" select="$indice + 7"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
<!-- Le llama el template 'mes' cada semana -->
<xsl:template name="semana">
<xsl:param name="indice" select="1"/>
<fo:table-row>
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice"/>
<xsl:with-param name="contador" select="$indice + 6"/>
</xsl:call-template>
</fo:table-row>
</xsl:template>
155
CAPITULO 8.- PLANOS DE CÓDIGO
<!-- Es llamado por semana -->
<!-- Rutina que va imprimiendo cada dia de la semana, usando recursividad con:
indice+1-->
<xsl:template name="dias">
<xsl:param name="indice" select="1"/>
<xsl:param name="contador" select="1"/>
<xsl:choose>
<xsl:when test="$indice < $comienzo">
<fo:table-cell>
<fo:block line-height="0.8cm">-</fo:block>
</fo:table-cell>
</xsl:when>
<xsl:when test="$indice - $comienzo + 1 > $dias_mes">
<fo:table-cell>
<fo:block line-height="0.8cm">-</fo:block>
</fo:table-cell>
</xsl:when>
<xsl:when test="$indice > $comienzo - 1">
<fo:table-cell>
<fo:block line-height="0.8cm">
<xsl:choose>
<xsl:when test="($indice - $comienzo + 1) = ./asignatura/dia">
<fo:block color="rgb(128,64,0)">Exámen</fo:block>
</xsl:when>
<xsl:when test="($indice - $comienzo + 1) != ./asignatura/dia">
<xsl:value-of select="$indice - $comienzo + 1"/>
</xsl:when>
</xsl:choose>
</fo:block>
</fo:table-cell>
</xsl:when>
</xsl:choose>
<xsl:if test="$contador > $indice">
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice + 1"/>
<xsl:with-param name="contador" select="$contador"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
Código 94 .- Código de la hoja de estilo: agenda_pdf.xsl
156
CAPITULO 8.- PLANOS DE CÓDIGO
157
8.4 Hoja de estilo para transformación a WML
Esta hoja de estilo transforma la estructura de datos a un documento WML
(Wireless Markup Language), que puede ser entendido por un dispositivo móvil WAP
(Wireless Application Protocol):
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
<xsl:output encoding="iso-8859-1" doctype-public="-//WAPFORUM//DTD WML
1.1//EN" doctype-system="http://www.wapforum.org/DTD/wml_1.1.xml"
indent="yes"/>
<xsl:variable name="comienzo" select="/calendario/mes/@dia_comienzo"/>
<xsl:variable name="dias_mes" select="/calendario/mes/@n_dias"/>
<xsl:variable name="total" select="$comienzo + $dias_mes - 1"/>
<xsl:variable name="overflow" select="$total mod 7"/>
<xsl:variable name="n_elementos">
<xsl:choose>
<xsl:when test="$overflow > 0">
<xsl:value-of select="$total + 7 - $overflow"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$total"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<xsl:template match="/">
<wml>
<template>
<do type="prev">
<prev/>
</do>
<do type="Indice">
<go href="#indice"/>
</do>
</template>
<card id="indice" title="Agenda de Examenes">
<p align="center">
<br/>
<big>
<b>
<xsl:value-of select="calendario/mes/nombre"/>
</b>
</big>
<br/>
</p>
CAPITULO 8.- PLANOS DE CÓDIGO
<p>
<table columns="7">
<tr>
<td>L</td>
<td>M</td>
<td>X</td>
<td>J</td>
<td>V</td>
<td>S</td>
<td>D</td>
</tr>
<xsl:call-template name="mes"/>
</table>
</p>
</card>
<xsl:apply-templates select="calendario/asignatura"/>
</wml>
</xsl:template>
<xsl:template match="calendario/asignatura">
<card id="{@id}" title="Dia {dia}{../mes/nombre}">
<p align="left">
<big>Examen:
<b>
<xsl:value-of select="nombre"/>, </b>
<xsl:value-of select="@curso"/>Curso.</big>
</p>
</card>
</xsl:template>
<!-- Solo es llamado una vez por 'root' -->
<!-- Utiliza recursividad con indice+7 para cada semana-->
<xsl:template name="mes">
<xsl:param name="indice" select="1"/>
<xsl:if test="$indice < $n_elementos">
<xsl:call-template name="semana">
<xsl:with-param name="indice" select="$indice"/>
</xsl:call-template>
<xsl:call-template name="mes">
<xsl:with-param name="indice" select="$indice + 7"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
158
CAPITULO 8.- PLANOS DE CÓDIGO
159
<!-- Le llama el template 'mes' cada semana -->
<xsl:template name="semana">
<xsl:param name="indice" select="1"/>
<tr>
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice"/>
<xsl:with-param name="contador" select="$indice + 6"/>
</xsl:call-template>
</tr>
</xsl:template>
<!-- Es llamado por semana -->
<!-- Rutina que va imprimiendo cada dia de la semana, usando recursividad con:
indice+1-->
<xsl:template name="dias">
<xsl:param name="indice" select="1"/>
<xsl:param name="contador" select="1"/>
<xsl:choose>
<xsl:when test="$indice < $comienzo">
<td>-</td>
</xsl:when>
<xsl:when test="$indice - $comienzo + 1 > $dias_mes">
<td>-</td>
</xsl:when>
<xsl:when test="$indice > $comienzo - 1">
<td>
<xsl:choose>
<xsl:when test="($indice-$comienzo+1)=calendario/asignatura/dia">
<xsl:for-each select="calendario/asignatura">
<xsl:if test="($indice - $comienzo + 1) = dia">
<a href="#{@id}">
<xsl:value-of select="$indice - $comienzo + 1"/>
</a>
</xsl:if>
</xsl:for-each>
</xsl:when>
<xsl:whentest="($indice-$comienzo+1)!=calendario/asignatura/dia">
<xsl:value-of select="$indice - $comienzo + 1"/>
</xsl:when>
</xsl:choose>
</td>
</xsl:when>
</xsl:choose>
CAPITULO 8.- PLANOS DE CÓDIGO
<xsl:if test="$contador > $indice">
<xsl:call-template name="dias">
<xsl:with-param name="indice" select="$indice + 1"/>
<xsl:with-param name="contador" select="$contador"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
Código 95 .- Código de la hoja de estilo: agenda_wml.xsl
160
CAPITULO 9.- CONCLUSIONES
162
9. Conclusiones
Se exponen a continuación las conclusiones obtenidas de la realización de éste
Proyecto.
La especificación XML elaborada por el W3C, es una alternativa interesante a las
herramientas de elaboración de contenidos propietarias.
Su formato es abierto y por lo tanto accesible de forma independiente a la
aplicación, también dispone de una gran flexibilidad en el tratamiento y reutilización de
los contenidos.
Su utilización está condicionada a la disponibilidad de herramientas de uso
amigable para la edición, organización y utilización de los contenidos.
La opción más aconsejada para dar salida con formato a estas estructuras es la
utilización de hojas de estilo XSLT para la transformación.
XSLT no se limita a definir qué estilo aplicar a cada elemento del documento
XML, además puede realizar pequeñas instrucciones típicas de los lenguajes de
programación. A su vez, la salida no tiene porque ser únicamente un documento HTML,
sino pueden ser otros tipos, como WML, PDF, SVG, un documento de texto plano o
incluso otro documento XML.
XSLT es una de las tres partes de la recomendación XSL, junto a XPath y XSLFO, y en ella figuran las transformaciones que se desean realizar. Su sintaxis es XML y
está basado en reglas de transformación que se aplican al encontrar ciertos patrones.
XSLT, es la opción elegida para transformar documentos y es debido a que tiene
ciertas ventajas sobre las hojas de estilo CSS, una de las principales ventajas de XSL es
que permite que un documento XML se visualice en múltiples dispositivos distintos.
Como ejemplo, se podría tener un solo documento XML y un documento XSL
para cada dispositivo que se quiera incluir en la salida con formato, por ejemplo un
navegador web, un dispositivo móvil, incluso un documento imprimible con formato. Si
aparece un nuevo dispositivo, sólo se necesita crear un documento XSL para que el
documento XML se pueda visualizar sobre él.
CAPITULO 9.- CONCLUSIONES
163
Otras ventajas de XSLT sobre las hojas CSS:
•
Permite alterar el orden en la salida de los elementos del documento
origen XML .
•
Permite realizar cálculos, obtener en tiempo de ejecución la
información a presentar.
•
Permite combinar múltiples documentos.
Entre las distintas aplicaciones que podemos nombrar que hacen uso de esta
tecnología XSLT, mencionar su utilidad para:
• Adaptar la información de una web a las características del dispositivo
receptor (PDA, móvil, PC, ...)
•
Intercambio electrónico de información entre entidades que utilizan
distintos formatos de documentos XML.
• Combinar la información de documentos de distintos formatos en uno
sólo.
Una posibilidad entre las que nos ofrece XSL es su versión XSL-FO, con la cual
podemos dar formato imprimible a documentos XML.
El tema la paginación de la información de marcado, no es algo nuevo, en esto la
Semántica de Estilo de Documento y la Lengua de Especificación (DSSSL) son un
estándar internacional para el empleo con documentos SGML, aunque también trabaje
inalterado con documentos XML.
W3C también define una colección de semántica de paginación para la
interpretación orientada por impresión. Esta semántica de paginación es igualmente
conveniente para el Formato de Documento Portátil (PDF).
Extensible Stylesheet Language (XSL), conocido coloquialmente como
Extensible Stylesheet Language Formatting Objects (XSL-FO), combina la herencia de
CSS Y DSSSL en una especificación bien pensada y robusta de formatear la semántica
para paginar la información.
Se ha desarrollado una aplicación que implementa una agenda para exámenes y
hace uso de la unión de estas tecnologías. La herramienta se centra en un documento
XML desde el que se tiene acceso a los datos y tres hojas de estilo XSL, una para cada
terminal en el que se publica la salida con formato.
CAPITULO 9.- CONCLUSIONES
164
La agenda es presentada en un navegador web, un documento imprimible con
formato (PDF) y en un dispositivo móvil. En cada una de las tres modalidades, se
muestran diferencias con las demás.
9.1 Líneas futuras de desarrollo
Son varias las líneas que podrían desarrollarse a partir de la implementación de
este Proyecto.
Además de conocer la gama de procesadores tanto XSLT como XSL-FO que
existe, sería importante comparar algunas de las características principales de los
mismos.
En relación a la implementación de la aplicación de agenda para exámenes, se
podría diseñar una versión modelo cliente – servidor, en la que los datos se encuentren
centralizados por parte de un servidor y sea un conjunto de clientes los que puedan
acceder a la información con la instalación en sus máquinas de los navegadores y
browsers necesarios.
CAPITULO 10.- REFERENCIAS
166
10. Referencias
Especificaciones
[1] W3C – XML Path Language (XPath) 2.0,
http://www.w3.org/TR/2007/REC-xpath20-20070123/, 23 Enero 2007
[2] W3C – XSL Transformations (XSLT) Version 2.0,
http://www.w3.org/TR/2007/REC-xslt20-20070123/, 23 Enero 2007
[3] W3C – Extensible Stylesheet Language (XSL) Version 1.1
http://www.w3.org/TR/2006/REC-xsl11-20061205/, 5 Diciembre 2006
[4] W3C – Extensible Markup Language (XML) 1.1
http://www.w3.org/TR/2006/REC-xml11-20060816/, 16 Agosto 2006
[5] W3C – Extensible Markup Language (XML) 1.0 (Cuarta edición),
http://www.w3.org/TR/2006/REC-xml-20060816/, 16 Agosto 2006
[6] W3C – Extensible Stylesheet Language (XSL) Version 1.0,
http://www.w3.org/TR/2001/REC-xsl-20011015/,15 Octubre 2001
[7] W3C – XML Path Language (XPath) Version 1.0,
http://www.w3.org/TR/1999/REC-xpath-19991116, 16 Noviembre 1999
[8] W3C – XSL Transformations (XSLT) Version 1.0,
http://www.w3.org/TR/1999/REC-xslt-19991116, 16 Noviembre 1999
Artículos Personales
[9] Joseba Abaitua– http://www.serv-inf.deusto.es/abaitua/konzeptu/sgml.htm
[10] Victor Manuel Rivas Santos – http://geneura.ugr.es/~victor/cursillos/xml/XPath/
[11] Ibon Urretavizcaya – http://xml.utilitas.org/xslt_mini_como.html
[12] Jose Emilio Labra Gayo – http://www.di.uniovi.es/~labra/
[13] J. J. Melero – http://geneura.ugr.es/~jmerelo/XSLT/
[14] Victor Manuel Rivas Santos – http://geneura.ugr.es/~victor/cursillos/xml/FO/
[15] J. Tomás Nogales Flores – http://rayuela.uc3m.es/~nogales/cursos/xslt.html
[16] M. Rivas –
http://wwwdi.ujaen.es/~vrivas/docencia/cursillos/xml_baeza/alumnos/index.shtml#recur
sos
[17] Fernando Berzal– http://elvex.ugr.es/decsai/internet/xml.html#technologies
CAPITULO 10.- REFERENCIAS
167
[18] Daniel Prado – http://www.daniel.prado.name/articulos-xsl-xslt.asp
[19] Les Carr y Hugh Davis – http://users.ecs.soton.ac.uk/lac/xml/
[20] Gustavo Bonansea –
http://misopiniones.spaces.live.com/lists/cns!2737DC89A4AAB26B!202/
Artículos Instituciones Web
[21] Zvon – http://www.zvon.org
[22] W3C – http://www.w3.org/
[23] W3 Schools – http://www.w3schools.com
[24] Programación.net – http://www.programacion.net/articulos/xsl
[25] Tutorial-enlace.net – http://www.tutorial-enlace.net/tutoriales-XSLT.html
[26] Xml-utils – http://xml-utils.com/conferencia-xsl.html
[27] Apache Xalan – http://xalan.apache.org
[28] Saxon – http://saxon.sourceforge.net
[29] Top XML – http://www.topxml.com
[30] XML.com – http://www.xml.com
[31] WML Club – http://www.wmlclub.com/indexreal.htm
[32] Osmosislatina – http://xml.osmosislatina.com/curso/xsl.htm
[33] Tejedores del web – http://www.tejedoresdelweb.com/307/article-1057.html
[34] Programación.com – http://www.programacion.com/html/xml/principal.htm
Libros
[35] Elliotte Rusty Harold, Hungry Minds,1999 – XML Bible
[36] Dave Pawson, O’Reilly, 2002 – XSL-FO
[37] David Hunter, Wrox Press, 2003 – Beginning XML, 2nd Edition
[38] Richard Wagner, Hungry Minds, 2002 – XSLT For Dummies
[39] Doug Tidwell, O’Reilly, 2002 – XSLT
[40] Robert Eckstein & Michel Casablanca, 2001 – XML Pocket Reference, 2nd
Edition
[41] Dan Livingstone, Prentice Hall, 2002 – Guía esencial XML
[42] Alonso Rodriguez Zamora, Ra-Ma, 2004 – Publicación en Internet y tecnología
XML
[43] Gregorio Martin, Prentice Hall, 2005 – Curso de XML
[44] Eric M. Burke, O’Reilly, 2002 – Java y XSLT
GLOSARIO
GLOSARIO
B2B: Business to Business
CSS: Cascading Style Sheets
DTD: Document Type Definition
FO: Formatting Objects
FOP: Formatting Objects Processor
GML: General Markup Language
HTML: HyperText Markup Language
IP: Instruction Process
ISO: International Organization for Standardization
MIME: Multi-Purpose Internet Mail Extension
Namespaces: espacios de nombre
Parser: analizador
PDF : Portable Document Format
RTF : Rich Text Format
SGML: Structured Generalized Markup Language
SVG: Scalable Vector Graphics
URI: Uniform Resource Identifier
WAP: Wireless Application Protocol
WML: Wireless Markup Language
WWW: World Wide Web
W3C: World Wide Web Consortium
XDR: XML-Data Reduced Language
169
GLOSARIO
XHTML: Extensible HyperText Markup Language
XML: Extensible Markup Language
XML Schema: Esquema XML
XPath: XML Path Language
XPointer: XML Pointer Language
XSD: XML Schema Definition
XSL: Extensible Stylesheet Language
XSL-FO: XSL Formatting Objects
XSLT: XSL Transform
170