XSLT

XSLT (Extensible Stylesheet Language Transformations) es un lenguaje diseñado originalmente para transformar documentos XML en otros documentos XML u otros formatos como HTML para páginas web, texto sin formato o Objetos de formato XSL, que posteriormente se pueden convertir a otros formatos, como PDF, PostScript y PNG. La compatibilidad con JSON y la transformación de texto sin formato se agregó en actualizaciones posteriores de la especificación XSLT 1.0.

En agosto de 2022, la versión estable más reciente del lenguaje es XSLT 3.0, que alcanzó el estado de recomendación en junio de 2017.

Las implementaciones de XSLT 3.0 son compatibles con Java,.NET, C/C++, Python, PHP y NodeJS. Una biblioteca Javascript XSLT 3.0 también se puede alojar dentro del navegador web. Los navegadores web modernos también incluyen soporte nativo para XSLT 1.0.

Para una transformación de documento XSLT, el documento original no se modifica; más bien, se crea un nuevo documento basado en el contenido de uno existente. Por lo general, los documentos de entrada son archivos XML, pero se puede usar cualquier cosa a partir de la cual el procesador pueda construir un modelo de datos XQuery y XPath, como tablas de bases de datos relacionales o sistemas de información geográfica.

Si bien XSLT se diseñó originalmente como un lenguaje de propósito especial para la transformación de XML, el lenguaje es Turing-completo, lo que lo hace teóricamente capaz de realizar cálculos arbitrarios.

Historia

XSLT está influenciado por lenguajes funcionales y por lenguajes de coincidencia de patrones basados en texto como SNOBOL y AWK. Su antecesor más directo es DSSSL, que hizo por SGML lo que XSLT hace por XML.

• XSLT 1.0: XSLT formó parte del esfuerzo de desarrollo del Consorcio Web Mundial (W3C) eXtensible de Stylesheet Language (XSL) de 1998–1999, un proyecto que también produjo XSL-FO y XPath. Algunos miembros del comité de estándares que desarrolló XSLT, incluyendo James Clark, el editor, habían trabajado anteriormente en DSSSL. XSLT 1.0 fue publicado como recomendación de W3C en noviembre de 1999. A pesar de su edad, XSLT 1.0 sigue siendo ampliamente utilizado (a partir de 2018), ya que versiones posteriores no son compatibles nativamente en los navegadores web o para entornos como LAMP.

• XSLT 2.0: después de un intento abortivo de crear una versión 1.1 en 2001, el grupo de trabajo de XSL se unió al grupo de trabajo de XQuery para crear XPath 2.0, con un modelo de datos más rico y un sistema de tipo basado en XML Schema. Basándose en esto es XSLT 2.0, desarrollado bajo la redacción de Michael Kay, que alcanzó el estado de recomendación en enero de 2007. Las innovaciones más importantes de XSLT 2.0 incluyen:
  • Manipulación mediante expresiones regulares
  • Funciones y operadores para manipular fechas, tiempos y duraciónes
  • Múltiples documentos de salida
  • Grouping (creating hierarchic structure from flat input sequences)
  • Un sistema de tipo más rico y una comprobación de tipo más fuerte

• XSLT 3.0: se convirtió en una recomendación W3C el 8 de junio de 2017. Las nuevas características principales son:
  • Transformaciones de streaming: en versiones anteriores todo el documento de entrada tenía que leerse en memoria antes de que pudiera ser procesado, y la salida no podía ser escrita hasta que el procesamiento hubiera terminado. XSLT 3.0 permite streaming XML que es útil para procesar documentos demasiado grandes para adaptarse a la memoria o cuando las transformaciones están encadenadas en tuberías XML.
  • Paquetes, para mejorar la modularidad de hojas de estilo grandes.
  • Mejor manejo de errores dinámicos con, por ejemplo, una instrucción xsl:try.
  • Soporte para mapas y arrays, permitiendo a XSLT manejar JSON así como XML.
  • Las funciones ahora pueden ser argumentos a otras funciones (orden superior).

Modelo de diseño y elaboración

Diagrama de los elementos básicos y flujo de proceso de transformaciones de lenguaje eXtensible.

El procesador XSLT toma uno o más documentos de origen XML, además de una o más hojas de estilo XSLT, y los procesa para producir un documento de salida. A diferencia de los lenguajes de programación imperativos ampliamente implementados como C, XSLT es declarativo. El paradigma de procesamiento básico es la coincidencia de patrones. En lugar de enumerar una secuencia imperativa de acciones para realizar en un entorno con estado, las reglas de plantilla solo definen cómo manejar un nodo que coincida con un patrón similar a XPath, si el procesador encuentra uno, y el contenido de las plantillas comprende efectivamente funcional expresiones que representan directamente su forma evaluada: el árbol de resultados, que es la base de la salida del procesador.

Un procesador típico se comporta de la siguiente manera. En primer lugar, suponiendo que ya se ha leído y preparado una hoja de estilo, el procesador crea un árbol fuente a partir del documento XML de entrada. A continuación, procesa el nodo raíz del árbol de origen, encuentra la plantilla que mejor se adapta a ese nodo en la hoja de estilo y evalúa el contenido de la plantilla. Las instrucciones en cada plantilla generalmente indican al procesador que cree nodos en el árbol de resultados o que procese más nodos en el árbol de origen de la misma manera que el nodo raíz. Finalmente, el árbol de resultados se serializa como texto XML o HTML.

XPath

XSLT usa XPath para identificar subconjuntos del árbol del documento de origen y realizar cálculos. XPath también proporciona una variedad de funciones, que el propio XSLT aumenta aún más.

XSLT 1.0 usa XPath 1.0, mientras que XSLT 2.0 usa XPath 2.0. XSLT 3.0 funcionará con XPath 3.0 o 3.1. En el caso de 1.0 y 2.0, las especificaciones XSLT y XPath se publicaron en la misma fecha. Con 3.0, sin embargo, ya no estaban sincronizados; XPath 3.0 se convirtió en recomendación en abril de 2014, seguida de XPath 3.1 en febrero de 2017; XSLT 3.0 siguió en junio de 2017.

XQuery comparado

Las funcionalidades de XSLT se superponen con las de XQuery, que inicialmente se concibió como un lenguaje de consulta para grandes colecciones de documentos XML.

Los estándares XSLT 2.0 y XQuery 1.0 fueron desarrollados por grupos de trabajo separados dentro del W3C, que trabajaron juntos para garantizar un enfoque común donde fuera apropiado. Comparten el mismo modelo de datos, sistema de tipos y biblioteca de funciones, y ambos incluyen XPath 2.0 como sublenguaje.

Sin embargo, los dos idiomas tienen sus raíces en diferentes tradiciones y satisfacen las necesidades de diferentes comunidades. XSLT se concibió principalmente como un lenguaje de hoja de estilo cuyo objetivo principal era representar XML para el lector humano en la pantalla, en la web (como un lenguaje de plantilla web) o en papel. XQuery se concibió principalmente como un lenguaje de consulta de base de datos en la tradición de SQL.

Debido a que los dos idiomas se originan en diferentes comunidades, XSLT es más fuerte en su manejo de documentos narrativos con una estructura más flexible, mientras que XQuery es más fuerte en el manejo de datos, por ejemplo, al realizar uniones relacionales.

Tipos de medios

El elemento <output> puede tomar opcionalmente el atributo media-type, que permite establecer el tipo de medio (o tipo MIME) para la salida resultante, por ejemplo: <xsl:salida salida="xml" media-type="aplicación/xml"/>. La recomendación XSLT 1.0 recomienda los tipos de atributos más generales text/xml y application/xml ya que durante mucho tiempo no hubo ningún tipo de medio registrado para XSLT. Durante este tiempo, text/xsl se convirtió en el estándar de facto. En XSLT 1.0 no se especificaba cómo debían usarse los valores de media-type.

Con el lanzamiento de XSLT 2.0, el W3C recomendó el registro del tipo de medio MIME application/xslt+xml y luego se registró con la Autoridad de Números Asignados de Internet.

Los borradores de trabajo anteriores a 1.0 de XSLT usaban text/xsl en sus ejemplos de incrustación, y Microsoft implementó y continúa promoviendo este tipo en Internet Explorer y MSXML. También es ampliamente reconocido en la instrucción de procesamiento xml-stylesheet de otros navegadores. En la práctica, por lo tanto, los usuarios que deseen controlar la transformación en el navegador utilizando esta instrucción de procesamiento están obligados a utilizar este tipo de medio no registrado.

Ejemplos

Estos ejemplos usan el siguiente documento XML entrante

################################################################################################################################################################################################################################################################■persons titulada ■ nombre de usuario="JS1"■ NombreJohn.Identificado/nombre ■ nombre familiarSmith" Nombre familiar " ■/persona ■ nombre de usuario="MI1"■ NombreMorkaIdentificado/nombre ■ nombre familiarIsmincius" Nombre familiar " ■/persona■/personas relacionadas

Ejemplo 1 (transformación de XML a XML)

Esta hoja de estilo XSLT proporciona plantillas para transformar el documento XML:

¿Según la versión xml="1.0" encoding="UTF-8"?■xsl: hoja de estilo xmlns:xsl="http://www.w3.org/1999/XSL/Transform" versión="1.0"■ ■xsl:output método="xml" indent=Sí./ - No. match="/personas"■ ▪ ■xsl:apply-templates select="persona"/ ■/root Conf ■/xsl:template - No. match="persona"■ Nombre nombre de usuario="{@username}"■ ■xsl:valor de select="nombre" / Identificado/nombre ■/xsl:template■/xsl:stylesheet

Su evaluación da como resultado un nuevo documento XML, que tiene otra estructura:

¿Según la versión xml="1.0" encoding="UTF-8"?▪ Nombre nombre de usuario="JS1"■John.Identificado/nombre Nombre nombre de usuario="MI1"■MorkaIdentificado/nombre■/root Conf

Ejemplo 2 (transformación de XML a XHTML)

Procesando el siguiente archivo XSLT de ejemplo

¿Según la versión xml="1.0" encoding="UTF-8"?■xsl: hoja de estilo versión="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://www.w3.org/1999/xhtml"■ ■xsl:output método="xml" indent=Sí. encoding="UTF-8"/ - No. match="/personas"■ ■html ■head ▪ títuloPruebas XML Ejemplo■/título Identificado/cabeza ▪ ■h1Personas■/h1 título Identificado ■xsl:apply-templates select="persona"■ - No. select="nombre familiar" / ■/xsl:apply-templates ■/ul Identificado/cuerpo Identificado/html ■/xsl:template - No. match="persona"■ ■li ■xsl:valor de select="nombre familiar"- No., ■/xsl:texto acordadoxsl:valor-of select="nombre"/ ■/li ■/xsl:template■/xsl:stylesheet

con el archivo de entrada XML que se muestra arriba da como resultado el siguiente XHTML (los espacios en blanco se han ajustado aquí para mayor claridad):

¿Según la versión xml="1.0" encoding="UTF-8"?html xmlns="http://www.w3.org/1999/xhtml"■ ■head ▪ títuloPruebas XML Ejemplo■/título Identificado/cabeza ▪ ■h1Personas■/h1 título Identificado ■liIsmincius, Morka■/li ■liSmith, John■/li ■/ul Identificado/cuerpoIdentificado/html

Este XHTML genera el siguiente resultado cuando se procesa en un navegador web.

Rendered XHTML generado a partir de un archivo de entrada XML y una transformación XSLT.

Para que un navegador web pueda aplicar una transformación XSL a un documento XML en pantalla, se puede insertar una instrucción de procesamiento de hoja de estilo XML en XML. Entonces, por ejemplo, si la hoja de estilo del Ejemplo 2 anterior estuviera disponible como "example2.xsl", se podría agregar la siguiente instrucción al XML entrante original:

■ hoja de estilo xml href="example2.xsl" tipo="text/xsl" ?

En este ejemplo, text/xsl es técnicamente incorrecto de acuerdo con las especificaciones W3C (que dicen que el tipo debe ser application/xslt+xml), pero es el único tipo de medio que es ampliamente compatible con todos los navegadores a partir de 2009, y la situación no ha cambiado en 2021.

Implementaciones del procesador

• RaptorXML de Altova es un procesador XSLT 3.0 disponible en el kit de herramientas de desarrollo XMLSpy y como aplicación de servidor independiente, invocado mediante una interfaz REST.
• IBM ofrece procesamiento XSLT integrado en un dispositivo de hardware de uso especial bajo la marca Datapower.
• libxslt es una librería publicada bajo la Licencia MIT que puede ser reutilizada en aplicaciones comerciales. Se basa en libxml y se implementa en C para velocidad y portabilidad. Admite extensiones XSLT 1.0 y EXSLT.
  • Se puede utilizar en la línea de comandos a través de xsltproc que se incluye en macOS y muchas distribuciones de Linux, y se puede utilizar en Windows a través de Cygwin.
  • Los motores de diseño WebKit y Blink, utilizados por ejemplo en los navegadores web Safari y Chrome respectivamente, utiliza la biblioteca libxslt para hacer transformaciones XSL.
  • Existen enlaces para Python, Perl, Ruby, PHP, Common Lisp, Tcl y C++.
• Microsoft proporciona dos procesadores XSLT (tanto XSLT 1.0 solamente). El procesador anterior MSXML proporciona interfaces COM; desde MSXML 4.0 también incluye la utilidad de línea de comandos msxsl.exe. El. NET Runtime incluye un procesador XSLT integrado independiente en su System.Xml.Xsl biblioteca.
• Saxon es un procesador XSLT 3.0 y XQuery 3.1 con versiones de código abierto y patentadas para la operación independiente y para Java, JavaScript y. NET. Un producto separado Saxon-JS ofrece procesamiento XSLT 3.0 en Node.js y en el navegador.
• Xalan es un procesador de código abierto XSLT 1.0 de la Apache Software Foundation disponible para Java y C++. Una variante del procesador Xalan se incluye como el procesador XSLT predeterminado en la distribución Java estándar de Oracle.
• navegadores web: Safari, Chrome, Firefox, Opera e Internet Explorer todos los soportes XSLT 1.0 (sólo). Los navegadores pueden realizar transformaciones on-the-fly de archivos XML y mostrar la salida de transformación en la ventana del navegador. Esto se hace ya sea incrustando el XSL en el documento XML o haciendo referencia a un archivo que contiene instrucciones XSL del documento XML. Este último puede no trabajar con Chrome en archivos del sistema de archivos local debido a su modelo de seguridad.
• Motor Adobe AXSLE, una biblioteca privada

Rendimiento

La mayoría de los primeros procesadores XSLT eran intérpretes. Más recientemente, la generación de código es cada vez más común, utilizando lenguajes intermedios portátiles (como Java bytecode o.NET Common Intermediate Language) como destino. Sin embargo, incluso los productos interpretativos generalmente ofrecen fases separadas de análisis y ejecución, lo que permite crear un árbol de expresión optimizado en la memoria y reutilizarlo para realizar múltiples transformaciones. Esto brinda beneficios de rendimiento sustanciales en las aplicaciones de publicación en línea, donde la misma transformación se aplica muchas veces por segundo a diferentes documentos de origen. Esta separación se refleja en el diseño de las API de procesamiento XSLT (como JAXP).

Los primeros procesadores XSLT tenían muy pocas optimizaciones. Los documentos de hojas de estilo se leían en modelos de objetos de documentos y el procesador actuaba sobre ellos directamente. Los motores XPath tampoco estaban optimizados. Sin embargo, los procesadores XSLT utilizan cada vez más técnicas de optimización que se encuentran en lenguajes de programación funcionales y lenguajes de consulta de bases de datos, como la reescritura estática de un árbol de expresión (p. ej., para sacar los cálculos de los bucles) y la evaluación perezosa canalizada para reducir la huella de memoria de los resultados intermedios. (y permitir la "salida anticipada" cuando el procesador pueda evaluar una expresión como following-sibling::*[1] sin una evaluación completa de todas las subexpresiones). Muchos procesadores también usan representaciones de árboles que son significativamente más eficientes (tanto en el espacio como en el tiempo) que las implementaciones DOM de propósito general.

En junio de 2014, Debbie Lockett y Michael Kay introdujeron un marco de evaluación comparativa de código abierto para procesadores XSLT llamado XT-Speedo.