Story Transcript
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 .................................................................................................. 84 Regla .............................................................................................................. 86 Regla ............................................................................................................... 87 Regla .............................................................................................................. 88 Regla ......................................................................................................................... 88 Regla , y .............................................................. 89 Regla .............................................................................................................. 90 Regla ................................................................................................................ 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 ........................................................................ 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 ( … ). Si un elemento estuviese vacío, la propia etiqueta incluirá el cierre de la misma (). 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 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:
< ejemplo xmlns = “doc_validacion.xsd ” > . . .
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.
< xsd:schema xmlns:xsd= “http://www.w3.org/2001/XMLSchema” > . . .
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: , al que normalmente se le añade la versión de XML a la que se ajusta el documento: . 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:
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:
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 , la declaración 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:
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
Hola , 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: , o bien 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:
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:
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:
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:
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 , 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:
Java y XSLT Eric M. Burke Beginning XSLT 1.0 Jeni Tennison XSLT Qickly Bob Ducharme .... .....
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
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 , 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 y , 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.
Código 27 .- Elemento
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:
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=”/”:
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: , 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 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 , 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: Código 30 .- Estructura de un template
CAPITULO 5.- EL LENGUAJE DE TRANSFORMACIÓN XSLT
81
Como primer ejemplo de un template: El precio es:
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.
..........
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:
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:
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:
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:
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: