Utiliser PHP pour transformer du XML à l'aide de XSL (deuxième partie)

Table des matières

• Introduction
• Quelques notions plus avancées
  • XML et XSL : les axes
  • XSL : variables, paramètres et modèles de valeur
    • XSL : variables et paramètres
    • XSL : les modèles de valeur
  • XSL : observations sur quelques fonctions
  • XSL : instructions utiles
    • XSL : <xsl:copy>…</xsl:copy> (instruction à deux balises, ouvrante et fermante)
    • XSL : <xsl:copy-of select="…" /> (instruction à une balise, autofermante)
    • XSL : <xsl:number … /> (instruction à une balise, autofermante)
    • XSL : <xsl:call-template name="…"></xsl:call-template> (instruction à une ou deux balise[s])
• Conclusion
• Références

Introduction

La première partie de ce document est une page qui présente XML, XSL, XSLT de manière succincte mais "auto-portante", en ne négligeant pas les espaces de nommage, et décrit la manière de s'en servir en PHP. Cette première partie élémentaire est plutôt centrée sur les notions de bases essentielles utiles, notamment, pour transformer un document XML en un document HTML comportant une mise en forme.

La présente page s'attache à des notions un peu plus avancées autorisant des manipulations plus complexes, principalement dans le cadre d'une transformation d'un document XML en un autre document XML.

Quelques notions plus avancées

XML et XSL : les axes

Une utilisation un peu avancée de XSL ne peut pas ignorer la notion d'axe. En fait, tous les nœuds d'un document XML ne sont pas de la même espèce. Ils sont divisés en ensembles qui s'appellent des axes. Ce nom vient sans doute du fait que ces axes contraignent les recherches select de nœuds dans une certaine direction.

D'après la recommandation "XML Path Language (XPath) 3.1" du W3C de décembre 2015 [1], il y a 13 axes, certains regardant vers l'avant et d'autres vers l'arrière :

Vers l'avant :

• child : les enfants du nœud courant,
• descendant : tous les descendants du nœud courant (enfants, petits-enfants, etc.),
• attribute : les attributs du nœud courant, non vide seulement pour les éléments,
• self : juste le nœud courant,
• descendant-or-self : la réunion de descendant et de self,
• following-sibling : sibling voulant dire frère ou sœur, cet axe désigne les nœuds frères situés après le nœud courant dans l'ordre du document - NOTA: si le nœud courant est un attribut ou un espace de nommage, l'axe est vide,
• following : tous les descendants du nœud racine qui ne sont pas des descendants du nœud courant et viennent après lui dans l'ordre du document,
• namespace : les espaces de nommage du nœud courant.

Vers l'arrière :

• parent : le parent du nœud courant (ou l'ensemble vide s'il n'a pas de parent) - NOTA: un attribut n'est pas un enfant de son élément mais peut quand même avoir un élément parent,
• ancestor : tous les ancêtres du nœud courant (son parent, le parent de son parent, etc.),
• preceding-sibling : les nœuds frères situés avant le nœud courant dans l'ordre du document - NOTA: si le nœud courant est un attribut ou un espace de nommage, l'axe est vide,
• preceding : tous les descendants du nœud racine qui ne sont pas des ancêtres du nœud courant et viennent avant lui dans l'ordre du document,
• ancestor-or-self : la réunion de ancestor et de self, qui contient toujours au moins le nœud racine,

L'axe child est l'axe par défaut. En conséquence, pour sélectionner un nœud dans un autre axe, il faut le dire explicitement ; ainsi @*, une notation abrégée pour attribute::*, concorde avec tout attribut.

XSL : variables, paramètres et modèles de valeur

XSL : variables et paramètres

Parmi tous les éléments de XSLT [4], il faut réserver une place à part aux variables et paramètres en raison de leur importance en programmation, comme dans tout langage.

Il est possible de définir des variables et de leur affecter des valeurs. Seulement, XML oblige, la syntaxe est inhabituelle.

<xsl:variable name="maVariable">
   <ul>Cette liste de contacts donne:
   <li>le nom</li>
   <li>le prénom</li>
   <li>la profession et la spécialité en français</li>
   <li>la profession et la spécialité en anglais</li>
   <li>le pays de domiciliation en français</li>
   <li>le pays de domiciliation en anglais</li>
   </ul>
</xsl:variable>

L'instruction qui précède définit la variable $maVariable. Tout ce qui se trouve entre les deux balises <xsl:variable name="maVariable"> et </xsl:variable> est la valeur de la variable. Une telle variable peut être utilisée en lieu et place d'une expression XPath. Il est aussi possible d'affecter une valeur à une variable en utilisant l'attribut select, comme pour les paramètres.

En effet, il est aussi possible de définir des paramètres et de leur affecter des valeurs. La différence principale avec une variable est qu'une variable... n'est pas variable (une fois affectée [entre ses balises ou par select], sa valeur ne peut pas être changée) tandis qu'un paramètre reçoit une valeur par défaut mais peut recevoir une nouvelle valeur grâce à l'instruction xsl:with-param (voir exemple plus bas). La valeur du paramètre peut être transmise à un modèle en déclarant le paramètre au début du modèle par xsl:param (mécanisme similaire à celui qui permet de passer des valeurs "en paramètres" à une fonction appelée par un programme principal).

<xsl:param name="monParam" select="'valeur initiale'" />

L'instruction qui précède définit le paramètre $monParam et lui affecte la valeur par défaut 'valeur initiale' (guillemets simples à l'intérieur des guillemets doubles).

XSL : les modèles de valeur

Les variables et paramètres peuvent, entre autres choses, être utilisées dans le cadre des modèles de valeur. La valeur "chaîne de caractères" d'un nœud attribut (ou d'un nœud texte à partir de XSLT 2.0) peut, dans certaines circonstances, contenir une expression entre accolades. Ce sont des modèles de valeur d'attribut (ou de texte).

Un modèle de valeur est une chaine composée de parties variables (expression XPath entre accolades) ou fixes. Si une partie fixe doit contenir une accolade, elle doit être doublée (comme {{ ou }}, mécanisme d'échappement). Lors de l'utilisation, les parties variables sont calculées et transformées en chaînes puis toutes les parties sont concaténées. Le résultat de l'évaluation d'un modèle de valeur est appelé sa valeur effective. En XSLT 1.0, une seule partie est autorisée. Si plusieurs sont présentes, seule la première est prise en compte (restriction non appliquée, semble-t-il, par l'interpréteur de w3schools [5]).

Tous les attibuts ne peuvent pas recevoir des modèles de valeur. À l'exception de l'attribut "format" de xsl:result-document, les modèles de valeur ne sont pas permis pour :

• les attributs dont la valeur est une expression ou un motif,
• les attributs des éléments de déclaration,
• les attributs des objets XSLT nommés,
• les déclarations d'espace de nommage.

XSL : observations sur quelques fonctions

• XSLT dispose de fonctions de manipulation d'objets, de nombres ou de chaînes de caractères dont l'emploi ne devrait pas poser de problème particulier [6]. En outre, il propose quelques fonctions propres à la transformation de XML. Les suivantes méritent d'être présentées, en raison de leur utilité ou de leur comportement spécifique.
   
• node() : en tant qu'expression Xpath, cette fonction représente tout nœud SAUF le nœud racine et les attributs. Employée dans un select, dans un modèle, elle sélectionne donc tout enfant du nœud courant (sauf les attributs).
  Plus précisément, il y a de nombreux tests de nœuds et node() est le moins spécifique d'entre eux [2]. La liste suivante donne les sélecteurs les plus fréquemment utilisés avec les nœuds avec lesquels ils concordent :
  • node() : tout nœud,
  • text() : uniquement les nœuds textuels,
  • comment() : les nœuds commentaires,
  • * : tout nœud élément,
  • machin : tout nœud nommé "machin",
  • processing-instruction() : tous les nœuds instructions (de la forme <?nom valeur?>).
  Dans la notation qui précède, l'axe n'est pas précisé et, dans ce cas, l'axe child est supposé par défaut. C'est pour cela que node() sélectionne des nœuds qui sont des enfants et ne sélectionne pas des attributs. Pour changer d'axe, il faut le préciser explicitement ; ainsi @*, une notation abrégée pour attribute::*, concorde avec tout attribut.
   
• position() et last()
  Ces deux fonctions fort utiles donnent respectivement le rang du nœud courant dans la liste de nœuds en cours de traitement (en commençant à 1) et le nombre de nœuds dans cette liste. Cependant, savoir ce que contient la liste n'est pas toujours facile. Du coup, ces fonctions paraissent parfois capricieuses.
  Dans l'exemple suivant, le deuxième modèle est appliqué à chaque nœud "contact" trouvé. Il appelle le modèle "showSpec" par call-template (qui ne change pas le nœud courant). Ce troisième modèle affiche pour chaque nœud "contact" sa valeur de position() et de last(), soit comme le montre le résultat affiché en-dessous... 2/7, 4/7 et 6/7 alors qu'il y a seulement trois nœuds "contact".
  Ce résultat bizarre s'explique par le fait suivant: : lancé par l'instruction apply-templates du premier modèle, dans sa construction de l'arbre issu de "contacts", l'interpréteur prend en considération comme enfants de "contacts" tous les nœuds de même niveau que "contact", y compris les nœuds textes composés seulement d'espaces ou, comme ici, de retours à la ligne
  
  De ce fait, la liste des nœuds en cours de traitement (du fait de apply-templates) comporte bien 7 nœuds (last() = 7) et, chaque nœud "contact" étant précédé d'un retour à la ligne (de pure lisibilité), il occupe un rang pair (2, 4 et 6).
  Ce comportement est peu intuitif car il semble un peu contraire à la philosophie XML de rendre explicite la structure par des éléments formés à l'aide de balises soigneusement fermées pour constituer un document bien formé… (sans doute une conséquence de devoir accepter comme licite une structure telle que <a>Un texte A <b>Un contenu B</b></a>).
  Si, sans changer la feuille de style, les retours à la ligne sont supprimés du document xml source (sans autre modification), le résultat devient conforme aux attentes.
  
  En effet, la fratrie de "contact" ne contient plus de nœud texte. Cette solution n'est cependant pas satisfaisante car, d'une part, la lisibilité compte et, d'autre part, modifier le XML source à la main n'est pas une pratique recommandée.
  Pour ne pas modifier à la main le XML source, il existe bien une instruction xsl:strip-space qui retire les espaces au sein de tous les éléments cités dans son attribut elements - ici, appliquée à "contacts", elle joint tous les descendants et conduit au résultat voulu.
  
  Cette solution est meilleure que la précédente mais, pour l'auteur de la présente page, elle n'est pas idéale car elle consiste à ajouter une couche de bricolage à une couche de bizarrerie ! De plus, pour compenser ses effets pervers, il faut en général la combiner avec l'instruction xsl:preserve-space qui en limite les effets… bricolage au carré sur bizarrerie, on vous dit.
  Si possible, la meilleure solution consiste à maîtriser la liste de nœuds traitée. Ici, cela peut être obtenu en obligeant l'instruction apply-templates à se restreindre aux nœuds voulus (avec son attribut select). Les nœuds textes non balisés n'étant plus alors pris en considération, il n'est plus nécessaire de les éliminer.
  
  Bien sûr, il faudra adapter cette modalité aux cas particuliers à traiter.
   
• Par ailleurs, lorsque XSLT est mis en œuvre à partir de PHP, il est possible d'ajouter aux fonctions xsl les fonctions de PHP. Cela peut être nécessaire pour disposer, par exemple, de capacités de calcul étendues. Cette possibilté s'active en ajoutant, dans le programme php, l'instruction PHP $monProc->registerPHPFunctions() après la création de l'instance de XSLTProcessor par $monProc = new XSLTProcessor().
  ATTENTION : il faut inclure l'espace de nommage adéquat xmlns:php="http://php.net/xsl" dans la déclaration de la feuille de style. La table suivante donne un exemple d'utilisation.
   

XSL : instructions utiles

Les exemples de feuilles de style XSL montrés plus loin sont tous appliqués au même document XML reproduit ci-dessous (enregistré dans le fichier exemple.xml [afficher son code source pour voir le XML]). Il représente sommairement une liste bilingue de contacts. Certains nœuds sont dotés d'un attribut donnant la langue dans laquelle est exprimée la valeur du nœud. Aucun espace de nommage n'est invoqué.

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="exemple.xsl"?>
<contacts>
    <contact>Contact :
        <nom>Dupont</nom>
        <prenom>Joseph</prenom>
        <profession langue="fr">Ingénieur<specialiste>Mécanique</specialiste></profession>
        <profession langue="en">Engineer<specialiste>Mechanics</specialiste></profession>
        <domicile langue="fr">France</domicile>
        <domicile langue="en">France</domicile>
    </contact>
    <contact>Contact :
        <nom>Doe</nom>
        <prenom>John</prenom>
        <profession langue="fr">Avocat<specialiste>Affaires</specialiste></profession>
        <profession langue="en">Lawyer<specialiste>Business</specialiste></profession>
        <domicile langue="fr">États-Unis</domicile>
        <domicile langue="en">United States</domicile>
    </contact>
    <contact>Contact :
        <nom>Schumacher</nom>
        <prenom>Hans</prenom>
        <profession langue="fr">Cordonnier<specialiste>Chaussures</specialiste></profession>
        <profession langue="en">Shoemaker<specialiste>Shoes</specialiste></profession>
        <domicile langue="fr">Allemagne</domicile>
        <domicile langue="en">Germany</domicile>
    </contact>
</contacts>

XSL : <xsl:copy>…</xsl:copy> (instruction à deux balises, ouvrante et fermante)

L'instruction xsl:value-of, introduite dans la première partie, réalise une copie de la valeur d'un nœud c'est-à-dire de son contenu, à l'exclusion des balises xml qui le définissent. Cependant, lorsque la transformation fait passer d'un document source XML à un document résultat également en XML, il est parfois utile de copier intégralement le nœud - c'est ce que fait l'instruction xsl:copy.

ATTENTION : xsl:copy peut copier balises et valeurs mais NE COPIE PAS les attributs ni les enfants du nœud.

Le contenu de xsl:copy, placé entre ses deux balises, indique ce que l'instruction doit inscrire dans l'élément copié. La table suivante en donne quelques exemples.

En conclusion xsl:copy est une instruction à fort potentiel.

XSL : <xsl:copy-of select="…" /> (instruction à une balise, autofermante)

À la différence de xsl:copy, cette instruction fait une copie intégrale du nœud sélectionné et de ses descendants, y compris les attributs et les espaces de nommage.

XSL : <xsl:number … /> (instruction à une balise, autofermante)

Cette instruction, "numérote", fournit un moyen simple de numéroter des nœuds du document résultat. Elle délivre un entier en tenant compte de la position du nœud courant dans le document source et permet de spécifier son format. Sa syntaxe est assez riche puisque sa forme complète est la suivante.

La table suivante donne quelques exemples d'application.

XSL : <xsl:call-template name="…"></xsl:call-template> (instruction à une ou deux balise[s])

Cette instruction exécute un modèle spécifique, appelé par son nom. Ce dernier est défini par l'attribut name de la balise template du modèle.

Conclusion

Le lecteur parvenu à ce stade non épuisé
... et qui brûle d'en savoir plus
... ... est maintenant en mesure de se débrouiller tout seul en étudiant les documents cités en référence de cette partie et de la première partie ;-).

Références

• [1]↑ XML Path Language (XPath) 3.1.
• [2]↑ Tomalak contribution and discussion, stackoverflow.
• [3]↑ Recommandation W3C "XSL Transformations (XSLT)".
• [4]↑ Texte de référence pour les éléments de XSLT
• [5]↑ Interpréteur XSLT en ligne de w3schools
• [6]↑ Fonctions XSLT sur w3schools

© Sellig Zed, septembre 2016. Texte et illustrations diffusés sous licence Creative Commons "Attribution - Pas d'utilisation commerciale" 4.0 International (cf. http://creativecommons.org/licenses/by-nc/4.0/).

 Validé avec le vérificateur du W3C