Generate XSL

Introduction

Generate-XSL est un langage d'annotions permettant de décrire la compilation d'une transformation XSL, en pré-calculant certaines évaluations dans un but d'optimisation des performances.

Ces annotations s'expriment sous forme d'éléments et d'attributs XML appartenant au namespace Generate-XSLhttp://jimetevenard.com/ns/generate-xsl ajoutés dans la transformation XSL.

Après compilation, on obtient une XSLT générée dans laquelle la valeur des variables, le résultat des appels de fonction, des appels de templates ou des structures de boucles et conditions annoté(e)s sont sérialisés.

L'objectif principal de ce système d'annotation est d'optimiser le traitement d'une XSLT sans affecter son fonctionnement d'origine.
Ainsi cette XSLT reste maintenable et testable, et des test comparés de la XSL source et de la XSL générée permettent d'identifier facilement les éventuels effets de bord de la compilation.

Exemple :

Le code suivant :

<xsl:choose generate:build="#all" >
    <xsl:when test="true()" >
        <xsl:value-of select="'Yep !'" />
    </xsl:when>
    <xsl:otherwhise>
        <xsl:value-of select="'Nope !'" />
    </xsl:otherwhise>
</xsl:choose>

Devient, après compilation :

<xsl:value-of select="'Yep !'" />

Dans cet exemple, on a exprimé par l'attribut @generate:build la volonté de pré-évaluer ce <xsl:choose/>.
Ainsi, les différents xsl:when/@test ont été évalués et seul le code contenu dans le cas pertinent est retranscrit dans la XSL générée

Modes de pré-évaluation

Comme en XSLT, la notion de modes existe dans la compilation XSLT.

En effet, considérons le cas suivant :

<xsl:template match="/" >
    <!-- appel de template compilé -->
    <xsl:call-template generate:build="#all"  generate:use-build-mode="call-foo"  name="foo" />
</xsl:template>
<xsl:template name="foo" >
    <xsl:sequence generate:build="call-foo"  select="someXPath" />
</xsl:template>

Dans le présent exemple, il est souhaité que l'élément <xsl:sequence/> du template foo ne soit pré-évalué que dans le cadre d'un appel lui-même pré-évalué de ce template.

Il se pourrait en effet que ce template soit appelé ailleurs dans la XSLT, indépendamment du processus de pré-évaluation.

Ici, l'élement <xsl:sequence/> ne sera pré-évalué que dans le mode call-foo, mode que nous avons spécifié via l'attribut @generate:use-build-mode de <xsl:call-template/>

Contexte de la pré-évaluation

La pré-évaluation de la XSL est une phase liée au build d'un projet.
Elle est donc totalement ignorante des données ou du contexte d'exécution.

L'ensemble du contexte XPath, variables, paramètres, etc. disponibles pendant la phase de compilation est appelée contexte de génération
Le développeur qui met en place les annotations doit s'assurer que les expressions XPath évaluées sont effectivement évaluables dans ce contexte.

Il peut s'aider en cela des éléments <generate:use-import/>, <generate:use-variable/> et <generate:use-param/>, ainsi que de l'attribut @generate:use pour rendre visibles des variables, des paramètres ou des imports (et donc les variables globales, les paramètres et les fonctions qu'ils déclarent) dans le contexte de génération.

Implémentation XSLT

Le présent projet est une implémentation en XSLT de ce système d'annotations.

Son utilisation se fait en deux étapes :

La transformation generate.xsl prend en entrée la transformation XSL source, et produit en sortie une XSL intermédiaire.

Cette XSL intermédiaire doit ensuite être appelée sans entrée (template inital "init"), et produit en sortie la XSL compilée.
Si des paramètres ont été annotés comme visibles dans le contexte de génération, ils peuvent être passés à cette XSL intermédiaire.

Driver Java

Une API Java basé sur Saxon est fourni pour faciliter la transformation.
La classe com.jimetevenard.xslt.Driver assure la compilation d'après un fichier de scenari.

<scenari>
    <scenario name="mon-scenario" >
        <source-xsl-path>source.xsl</source-xsl-path>
        <target-xsl-path>target-dir/generated.xsl</target-xsl-path>
        <params>
            <param name="param-Qname"  select="//xpath" />
            <!-- <param... />* -->
        </params>
    </scenario>
    <!-- <scenario... />* -->
</scenari>

Syntaxe du langage d'annotations

Les annotations consistent en éléments <generate:*/> et attributs @generate:*.

Les attributs @generate:* se placent sur des instructions <xsl:*/>, pour spécifier le comportement, lors de la génération, des instructions sur lesquelles ils sont placés.

Les éléments <generate:*/> doivent être des enfants de la racine <xsl:stylesheet/> ou d'autres éléments <generate:*/>.
Ceci pour ne pas perturber le comportement de la XSLT.

Attributs et éléments du langage

• Compiler des instructions XSL
  • Compiler une instruction par l’ajout de l’attribut @generate:build
  • Dupliquer un template avec l’élément <generate:copy-template/>
    • Modifier le templace dupliqué avec les éléments <generate:set-match/>, <generate:set-mode/>, <generate:set-priority/>, <generate:set-name/>, <generate:set-as/>, <generate:set-visibility/>, <generate:redefine-variable/> et <generate:with-param/>
• Contrôle des modes de compilation
  • Spécifier un mode de compilation avec l'attribut @generate:use-build-mode
  • La valeur de l'attribut @generate:build correspond au(x) mode(s) de compilation cible(s)
• Modifier la structure de la XSLT
  • Générer des variables (globales?(copy-template?)) avec l’élément <generate:variable/>
  • Redéfinir une variable existante avec <generate:redefine-variable/>
  • Générer des imports avec l’élément <generate:import/>
  • Générer des paramètres globaux avec l’élément <generate:param/>
  • Ajouter un bloc de code avec l’élément <generate:target-block/>
• Structures de contrôle du langage d’annotations
  • Structures conditionnelles : éléments <generate:if/> et <generate:choose/>
  • La boucle <generate:for-each/>
• Utiliser des variables et paramètres dans le contexte de génération
  • l’attribut @generate:use
  • les éléments <generate:use-variable/>, <generate:use-import/> et <generate:use-param/>
• Identifier une instruction XSL
  • Ajout d’un identifiant par l’attribut @generate:id

<xsl:variable name="foo"  generate:build="#all"  select="concat('he','llo')" />

<xsl:variable name="foo" >hello</xsl:variable>

<xsl:if generate:build="#all"  test="true()" >
    <xsl:message>Hello !</xsl:message>
</xsl:if>

<xsl:message>Hello !</xsl:message>

<xsl:for-each generate:build="#all"  select="('foo','bar','baz')" >
    <xsl:message generate:build="#all"  select="current()" />
</xsl:for-each>

<xsl:message>foo</xsl:message>
<xsl:message>bar</xsl:message>
<xsl:message>baz</xsl:message>

<generate:for-each select="('a','p','div')"  name="currentElement" >
    <generate:copy-template idRef="bar" >
        <generate:set-match value="{$currentElement}" />
    </generate:copy-template>
</generate:for-each>
<xsl:template match="*"  generate:id="bar" >
    <xsl:message select="name()" />
</xsl:template>

<xsl:template match="a" >
    <xsl:message select="name()" />
</xsl:template>
<xsl:template match="p" >
    <xsl:message select="name()" />
</xsl:template>
<xsl:template match="div" >
    <xsl:message select="name()" />
</xsl:template>

<generate:variable name="foo"  select="count('foo','bar')" />
<generate:variable name="bar"  generate:build="#all"  select="count('hello','world')" />

<xsl:variable name="foo"  select="count('foo','bar')" />
<xsl:variable name="bar" >2</xsl:variable>

<generate:redefine-variable name="toto"  select="'bar'" />
<xsl:variable name="toto"  select="'foo'" />

<xsl:variable name="toto"  select="'bar'" />

<xsl:variable name="foo"  select="'foo'" />
<generate:target-block>
    <xsl:variable name="bar"  select="'bar'" />
</generate:target-block>

<xsl:variable name="foo"  select="'foo'" />
<xsl:variable name="bar"  select="'bar'" />

<xsl:variable name="foo"  generate:use="yes"  select="('foo','bar','baz')" />
<xsl:variable name="toto"  generate:build="#all"  select="count($foo)" />
<!-- Pour pré-évaluer $toto, $foo doit être visible dans le contexte de compilation. -->

<xsl:use-variable name="foo"  select="('foo','bar','baz')" />
<xsl:variable name="toto"  select="14" />
<generate:redefine-variable name="toto"  select="count($foo)" />

<xsl:template generate:id="bar"  match="/" >
    <!-- (...) -->
</xsl:template>
<generate:remove idRef="bar" />