XSLT : XML Stylesheet Language Transformation & XPath : langage dadressage de parties de documents...

XSLT : XML Stylesheet Language Transformation

& XPath : langage d’adressage de parties de documents XML

Une introduction à XSLT & Xpath pour l'analyse de documents XML

2

Cours XML –M2-CCI / Y.Laborde

2 XSLT : mise en pratique

Feuille de style et transformation

(3) Processeur XSLT

(1) Feuille de styleXSLT (+Xpath)

(2) DocumentXML

(4) Document transforméXML / HTML / texte / ...

4


4Un exemple : la fiche de description du film Vertigo

<?xml version="1.0" encoding="ISO-8859-1"?>

<FILM>

<TITRE>Vertigo</TITRE>

<IMAGE>Vertigo.gif</IMAGE>

<AUTEUR>Alfred Hitchcock</AUTEUR>

<ANNEE>1958</ANNEE>

<GENRE>Drame</GENRE>

<PAYS>Etats Unis</PAYS>

<RESUME>Scottie Ferguson, ancien inspecteur de police, est sujet au vertige depuis qu'il a vu mourir son collègue. Elster, son ami, le charge de surveiller sa femme, Madeleine, ayant des tendances suicidaires. Amoureux de la jeune femme Scottie ne remarque pas le piège qui se trame autour de lui et dont il va être la victime...

</RESUME>

</FILM>

5


5Un exemple de transformation HTML de la fiche de description du film Vertigo

Version HTML dudocument Vertigo.xml(affiché par Netscape)

<html> <head><meta http-equiv="Content-Type" content="text/html; charset=utf-8 »><title>Film: Vertigo</title </head> <body bgcolor="white »><p><img SRC="Vertigo.gif" align="left" height="220"> <h1><i>Vertigo</i></h1>Drame, <i>Etats Unis</i>, 1958</p><p>Mis en scène par <b>Alfred Hitchcock</b><h3>Résumé</h3>Scottie Ferguson, ancien inspecteur de police, est sujet au vertige depuis qu’il a vu mourir son collègue. Elster, son ami, le charge de surveiller sa femme, Madeleine, ayant des tendances suicidaires. Amoureux de la jeune femme Scottie ne remarque pas le piège qui se trame autour de lui et dont il va être la victime...</p></body></html>

Une mise en forme a été appliquéeau cours de la transformation dudocument par un processeur XSLT.

Les balises XML ont disparu auprofit de balises HTML.

Document HTML produit

6


6Un exemple de transformation EXCEL de la fiche de description du film Vertigo

Version EXCEL dudocument Alien.xml

La transformation du document a produit un document EXCEL.

Les balises XML ont disparu auprofit de celles propres à EXCEL

(non montrées ici).

Titre Auteur Année Pays Genre Résumé

Alien Ridley Scott

1979 USA Science-fiction

Près d’un vaisseau spatial échoué sur une lointaine planète, des Terriens en mission découvrent de bien étranges "oeufs". .

7


7 Principe de la transformation XSLT

8


8 Transformation en un document HTML

root

AAA BBB

TextTextCCC

DocumentXML

source

TransformationDocument

HTMLproduit

Processeur XSLT

Feuille de style XSLT :

règles de la transformation

Arbre XML source Arbre HTML résultant

Pour produire un document HTML : on doit transformer l'arbre XML en un arbre HTML

html

head body

……

9


9Exemples d’utilisation

Mettre en forme les information d'un document XML Connaissant à l'avance la structure logique du document

Composer des sous-documents Créer une version sans les <RESUME> ou sans les <PRIX>…

Quantifier Nombre de projection d'un <FILM> dans le mois...

Convertir dans un format spécifique XML vers XML, Hyperbase, Unitexte, sans balise... ou vers des

formats de lecture : (x)html, pdf, Word, Excel, Open Office, LaTex...

Maintenir et enrichir un document Possibilité d’ajouter de l’information (ex: images, prix moyens...)

10


10 Intérêt du couple XML/XSLT

AVANTAGES :On ne maintient pas différentes versions du

document pour les différents formats de sortie ou les différents sous-documents => maintenance

On peut appliquer les mêmes feuilles de style à plusieurs documents => simplicité

On se concentre soit sur les données du document soit sur ses représentation => modularité

11


11Objectif du diaporama

Introduction aux principes généraux par

l'approche procédurale

13


13

<?xml version="1.0"?><xsl:stylesheet version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:output encoding= "UTF-8" method="html" />

<xsl:template match="/"><html>

<META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=UTF-8" />

<body> <xsl:value-of

select="."> </body></html>

</xsl:template>

</xsl:stylesheet>

Une première feuille de styleCette feuille de style récupère tout le texte d’un document XML

14


14Explications

<html><META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=UTF-8">

<body> Vertigo Vertigo.gif Alfred Hitchcock 1958 Drame Etats Unis Scottie Ferguson, ancien inspecteur de police, est sujet au vertige depuis qu'il a vu mourir son collègue. Elster, son ami, le charge de surveiller sa femme, Madeleine, ayant des tendances suicidaires. Amoureux de la jeune femme Scottie ne remarque pas le piège qui se trame autour de lui et dont il va être la victime... </body></html>

• Le processeur lit la feuille, imprime ce qui est littéral (le texte ou les balises non préfixés par « xsl: ») et évalue/exécute les instructions préfixées par « xsl: »

• Ici les balises ajoutées sont en HTML : à partir du document on génère une page HTML. Le résultat de la transformation peut ainsi être affiché par un navigateur.

Appliquée au document Vertigo.XML, cette feuille de style donne :

15


15Pour résumer

Une feuille de style est un document XML L'élément racine est xsl:stylesheet avec deux

attributs obligatoires (version et xmlns:xsl)

D'autres instructions peuvent apparaître, comme xsl:template ou xsl:value-of

Tout ce qui est préfixé par « xsl:» est une instruction XSLT, qui est exécutée par le processeur et remplacée par son résultat.

Tout ce qui n'est pas "préfixé" est reproduit littéralement

16


16 Prenons un exemple plus complet :<?xml version="1.0" encoding="UTF-8"?>

<CINEMA>

<NOM>Epée de bois</NOM>

<ADRESSE>100, rue Mouffetard</ADRESSE>

<METRO>Censier-Daubenton</METRO>

<SALLE NO='1' PLACES='320'>

<TITRE>Alien</TITRE>

<REMARQUE>Réservation conseillée</REMARQUE>

<SEANCES>

<SEANCE>15:00</SEANCE>



</SEANCES>

</SALLE>

<SALLE NO='2' PLACES='120'>

<TITRE>Vertigo</TITRE>

<SEANCES>


</SEANCES>

</SALLE>

</CINEMA>

17


17Extraire le texte contenu dans une balise

18


18L'instruction xsl:value-of

Remplacer cette instruction par le texte

du premier élément… … trouvé à cet endroit

19


19

L’arbre est toujours parcouru de haut en bas et de gauche à droite (i.e. dans l’ordre physique de déclaration des entités

, , , ...)① ② ③ ④ .

①

②

③

④

20


20 XPath

21


21xsl:value-of convertit le nœud en texte

en supprimant les éventuelles balises incluses

<p>du texte et <hi style="italics">d'autres</hi> éléments</p>

<xsl:value-of select="p" />

Soit le document XML :

L'expression XPath retourne tous les « nœud » <p>,

XSLT prend le premier et le convertit en texte y compris ses fils :

Du texte et d'autres éléments

Soit l'instruction XSLT …

22


22xsl:for-each

<xsl:for-each select= "...expression Xpath...">

...traitement une à une les nœuds trouvés...

</xsl:for-each>

23


23

<p><i>15:00</i></p><p><i>18:00</i></p><p><i>21:00</i></p><p><i>22:00</i></p>

xsl:for-each

24


24xsl:for-each

25


25xsl:for-each

26


26<?xml version="1.0"?><xsl:stylesheet version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/"> <html><body> <p>Nom du cinéma: <xsl:value-of select = "//NOM"/> </p>

<xsl:for-each select="//SALLE"> <p>Film à l’affiche : <xsl:value-of select= "./TITRE"/>

</p> <p>Première séance : <xsl:value-of select= "./SEANCES/SEANCE"/>

</p> </xsl:for-each>

</body> </html> </xsl:template>

</xsl:stylesheet>

xsl:for-each

27


27 Le nœud contexte

28


28 Imbrications de xsl:for-each

On ne sait pas combien il y aura de titres de niveau 1, de niveau 2, etc.

Il faut traiter tous les titres de niveaux 1, puis dans chaque niveau 1, traiter les niveaux 2, etc.

On devra donc imbriquer des boucles xsl:for-each

29


29 Une table des matières (1)

Le livre a comme racine <BOOK> et son titre général du livre est donné dans une balise fille <TITLE>.

Les chapitres du livre sont des balises <chap> possédant un attribut level indiquant leur niveau hiérarchique et ayant alors un élément fils <title> dont le texte est le titre.

Par ailleurs, les niveaux sont imbriquées les uns dans les autres.

<BOOK> <TITLE>LES LANGAGES XML</TITLE> <chap level="1"> <title>Le langage XML</title> ... <chap level="2"> <title>Les balises XML</title> ... </chap> <chap level="2"> <title>Les attributs XML</title> ... </chap> </chap> <chap level="1"> <title>Le langage XSLT</title> ... </chap> <chap level="2"> <title>L'nstruction template</title> ... </chap> <chap level="2"> <title>L'instruction value-of</title> ... </chap> </chap> ...</BOOK>

30


30

select="chap[@level = '1']"

select="chap[@level='1']/title"

Sélectionne les éléments title directement en dessous de chap dont l’attribut level vaut '1’

Prédicats pour les attributs des nœuds

31


31Une table des matières simple (2)

<xsl:for-each select="/BOOK"> <p>Titre : <xsl:value-of select= "./TITLE"/></p>

<xsl:for-each select="./chap[@level = '1']"> <h1><xsl:value-of select="./title"/></h1> <xsl:for-each select="./chap[@level = '2']"> <h2><xsl:value-of select="./title"/></h2> <xsl:for-each select="./chap[@level = '3']"> <h3><xsl:value-of select="./title"/></h3> </xsl:for-each> </xsl:for-each> </xsl:for-each>

<hr/> </xsl:for-each>

L’expression Xpath commence par « . » : chap est recherché parmi les enfants des nœuds contextes trouvés (ici, un BOOK)

Par rapport au nouveau contexte chap, on désigne les enfants title.

Idem pour toutes les autres.

32


32Classer avec xsl:sort

Les éléments sont extraits avec for-each ; mais avant d’être traités un à un, ils sont classés par xsl:sort – ici par ordre alphanumérique («ascending») – en fonction du contenu du select de sort.Ici les films sont donc classés par leurs titres.

33


33 xsl:sort (syntaxe)

34


34Ajouter un index : xsl:number

A. 15:00 , B. 18:00 , C. 21:00 , D. 22:00

Les positions sont traduites d'après le format de l’instruction number

35


35xsl:output

Indication du jeu de caractères de la sortie : encoding='...'

Indication du type de sortie (text, xml, html...) : method='...'

Un peu plus sur XPath

XPath permet d’écrire des « chemins XML » mais également d’utiliser des fonctions

et des opérateurs.

37


37 XPath : les « chemins » en quatre points

XPath permet de pointer sur des éléments de l'arborescence du document.

Une expression XPath est constituée (1) d'étapes (steps), séparées par des slashs, « / »

Chaque étape contient (2) un nœud asserté (node test) qui sert à spécifier le nœud par : le nom d’un élément, d’un attribut, d’un espace de nom ou « * » (tous les types de nœuds : élts, attr, esp.noms).

Optionnellement l’expression peut avoir (3) des prédicats (à droite de chaque node test) et (4) des axes (à gauche de chaque node test)

L'expression retourne un sac de nœuds (node set) : les nœuds qui correspondent au dernier nœud asserté – si elle en trouve.

"/CINEMA/SALLE[NO="1"]/SEANCES"

Axe implicite .../.../.../Etapes/.../... [Prédicat]*

38


38(1) les étapes

39


39Quelques cas...

//SEANCE est-il identique à //SEANCES/SEANCE ?

Note : "//..." part de la racine : //p : tous les p du document, à toute profondeur depuis la racine .//p : tous les p sous le nœud contexte

Différences entre : //BBB/p

Tous les p du document directement en dessous de tous les BBB //BBB//p

Tous les p du document en dessous de tous les BBBAvec //BBB//p, chaque p est sélectionné une fois dans le sac de nœuds résultant, même si plusieurs BBB sont imbriqués et font différents chemins valides vers le même p :

il n’y a jamais de doublon dans un sac de nœuds.

40


40(2) : les node tests (ou tests de nœuds)

Chaque étape comprend un node test Le nœud cherché peut être une balise, un attribut (@nom)

ou un nœud texte text()(qui renvoie le texte des nœuds sans celui de leurs fils)

Existent également des valeurs génériques : *(tout type de

nœud : élts, esp.noms), @*(tout attribut) , node()(tout nœud : texte, commentaires…)

Le point "." indique le contexte actuel Le double point ".." permet de remonter d'un niveau

dans l'arborescence.

41


41Exemples

//p/@id : retourne la valeur de l’attribut id, tandis que//p[@id]: retourne tous les nœuds p qui ont un attribut id

Ne pas confondre un nœud texte et le texte contenu : /BOOK/text/front : retourne tous les nœuds front directement enfants de text ;

avec value-of retourne la valeur (le texte) du premier nœud front, sans les balises imbriquées

/BOOK/text/front/text() : retourne le texte de tous les nœuds front directement enfants du noeud text ; avec value-of retourne la valeur (le texte) du premier nœud front

/BOOK/text/front/@id/text()Ne retourne rien ! Il n'y a pas de nœud texte descendant d'un attribut. (@id retourne la « valeur » de l’attribut)

/SALLE/node() : retourne tous les types de nœuds fils de SALLE (éléments, commentaires...)

42


42(3) : les prédicats

Chaque étape peut comprendre un ou plusieurs prédicat, qui est une expression XPath entre crochets placée après le node test. //chap[@title='1']sélectionne les chap dont l'attribut title vaut '1’ //p[@id][@name]retourne tous les nœuds p ayant les attributs id et name //*[@*='bbb'] retourne tous les nœuds ayant un attribut valant 'bbb'

Le prédicat permet de filtrer les nœuds en ajoutant des conditions. L’expression dans le prédicat a deux valeurs : vraie ou fausse. L’expression est convertie si besoin en valeur booléenne :

=> est faux : un sac de nœud vide, le nombre zéro ou la chaîne vide,=> est vrai : tout le reste. Dans le premier exemple, l’expression retourne déjà une valeur booléenne grâce à

l’opérateur « = » //p[name] : sélectionne tous les p contenant un élément enfant name. p est le

contexte de l’expression Xpath name. //*[@NO]: retourne tous les nœuds ayant un attribut NO //p[../liste] : retourne tous les p fils directs de liste

43


43Fonctions XPath utiles

Les conditions sur la position d’un nœud sont souvent utilisées dans les prédicats.

Les fonctions last() et position() renvoie respectivement le numéro cardinal du dernier nœud d’un sac de nœuds et le numéro cardinal du nœud courant. Note : last() et position() s’écrivent toujours avec les

parenthèses et sans argument. Plutôt que [position() = 1], pour demander les nœuds

qui sont le premier enfant de leur père, on peut utiliser une notation courte : [1].

44


44Exemples

<xsl:for-each select="/hi[@rend = ‘italics’]">

</xsl:for-each>

<xsl:for-each select="/p[name/@id]">

</xsl:for-each>

<xsl:for-each select="/text/p [not(position()=last())]"><!– tous les p qui ne sont pas les derniers parmi les p de parent text -->

</xsl:for-each>

<xsl:for-each select="/text/p[position() != last())]"><!– idem que précédemment <=> autre notation -->

</xsl:for-each>

<xsl:for-each select="/text/p[position() >= 1]">

</xsl:for-each>

Elementtext

Elementp

Elementp

Elementp

Elementp

Text Text TextElement

name

Text

id='p5'

n='8'

<xsl:value-of select="text/p[3]"/><xsl:value-of select="text/p[name]"/><xsl:value-of select="text/p/name"/><xsl:value-of select="text[p/name]/p[3]"/><xsl:value-of select="text/p[name/@n]"/><xsl:value-of select="text/p[not(text())]"/><xsl:value-of select="text/p[last()]"/><xsl:value-of select="text/p[not(position() = last())]"/>

46


46(4) : les axes

Dans la forme abrégée de la syntaxe XPath utilisée jusqu'ici, les node test sont cherchés parmi les enfants avec /, ou parmi les descendants avec //.

Il est donc impossible avec cette notation d'indiquer un chemin qui remonte vers les autres directions : ancêtres, parents, ou frères du nœud contexte.

C’est ce que permettent les axes.

47


47XML, une histoire de famille

Document/

Prologue<?xml version=“1.0”?>

Element ROOTcorpus

Elementtext

Elementp

Elementp

Elementp

Text

Text

Text TextElement

name

Text

Frères précédents

Parent

Enfants

Descendants

Ascendants

Frères suivants

Elementp

48


48 Document/

Prologue<?xml version=“1.0”?>

Element ROOTFitnessCenter

ElementMember

ElementName

ElementPhone

ElementFavoriteColor

TextJeff

Text555-4321

Textlightgrey

ElementName

TextJeff

Frères précédents

Ascendants

Frères suivants

Parent

Enfants

Descendants

XML, une histoire de famille

ElementPhone

49


49Noter les axes

On peut désigner à chaque étape d'autres directions que l’axe parent/enfant grâce à une « notation longue » :le note test est précédé du nom de l'axe suivi de "::"

Exemple select="./ancestor::div"

Select="./ancestor::SALLE/TITRE

following-sibling::node() | preceding-sibling::node()

Recherche tous les div parmi les ascendants

Sélectionne tous les nœuds descendant du même père respectivement à droite et à gauche

Remonte aux SALLE ascendant, puis descend à son enfant direct TITRE

En anglais : « sibling » signifie « enfant de même parent »

50


50Document

/

PI<?xml version=“1.0”?>


ElementMember

ElementName

ElementPhone

ElementPhone


TextJeff

Text555-1234

Text555-4321

Textlightgrey

ancêtre

Frêre précédent Frêres suivants

ancestor::* sélectionne tous les ancêtres, c-à-d : - Member - FitnessCenter

preceding-sibling::* sélectionne tous les frères à gauche, c-à-d : - Name

following-sibling::* sélectionne tous les frères à droite, c-à-d : - Phone - FavoriteColor

51


51Document

/



ElementMember

ElementName

ElementPhone

ElementPhone


TextJeff

Text555-1234

Text555-4321

Textlightgrey

descendants

À partir de FitnessCenter, descendant::* ou //* sélectionne tous les descendants, c-à-d : - Member - Name - Phone, etc.

52


52Liste des axes

ancestor: sélectionne tous les ancêtres ancestor-or-self: sélectionne le nœud courant et tous ses ancêtres attribute: sélectionne tous les attributs child: sélectionne tous les enfants (descendants directs) descendant: sélectionne tous les descendants descendant-or-self: sélectionne le nœud courant plus tous ses descendants following: sélectionne tout ce qui suit le nœud courant dans le document following-sibling: sélectionne tous les frères à droite namespace: sélectionne tous les namespaces ouverts parent: sélectionne le parent preceding: sélectionne tout ce qui précède le nœud courant dans le document preceding-sibling: sélectionne tous les frères à gauche self: sélectionne le nœud courant

53


53Abréviations utiles

L'axe « child:: » est l'axe par défaut « @ » abrège l'axe « attribute:: » « // » abrège l’axe « descendant-or-

self:: » « . » abrège « self:: » « .. » abrège l'axe « parent:: » « / » abrège la racine

54


54Principaux opérateurs

Opérateurs arithmétiques +, -, *, div, mod Note : une balise XML peut contenir un tiret, il faut donc

encadrer “-” d’espace.

Operateurs booléens : not, and, or Operateurs relationnels : <, >, =, <=, >=, !=, | (ou), & (et) < et > doivent être notés < et > pour satisfaire aux

contraintes XML

< > = <= >= !=< > = <= >= !=

Pour exprimer :Noter :

55


55Rappel XML :ordre des éléments et valeur des attributs

On ne peut pas accéder aux attributs par leur numéro d'ordre : ils sont accessibles seulement par leur nom, leur ordre n'est pas signifiant.

impossibles : @titre[1] ou //*[@titre[1]] Ainsi, dans la conception d'un document XML, il ne faut pas

confier d'information à l'ordre des attributs. Les éléments correspondent un peu aux structures de données

informatiques dites "tableaux" et les attributs aux tableaux associatifs ou "hashes"

Expression de conditionsOpération sur les chaînes

57


57 xsl:if

<xsl:if test="//SEANCE"><p>Il existe au moins une séance de programmée !</p>

</xsl:if>

Permet de filtrer ou de choisir entre différentes possibilités.

Si l’expression XPath de @test renvoie une valeur non nulle ou vraie, alors le contenu de xsl:if est exécuté.

58


58 Exemples de xsl:if

<xsl:for-each select="name"> <xsl:if test="@type='person'"> <xsl:value-of select='.'> </xsl:if></xsl:for-each>

<xsl:for-each select="name[@type='person']"> <xsl:value-of select='.'></xsl:for-each>

Remarquez qu’en fait, c’est équivalent à :

59


59 Dans le contexte de xsl:if,XPath retourne une valeur booléenne

Une expression XPath peut être utilisée avec xsl:if pour voir si elle retourne vrai ou faux : elle retourne vrai si elle retourne :

- un sac de nœuds non vide- une valeur numérique différente de 0- une valeur booléenne vraie- une chaîne de caractères non vide

elle retourne faux dans les cas contraires

60


60 xsl:choose

<xsl:choose> <xsl:when test='expression XPath'> [action] </xsl:when> <xsl:when test='expression XPath'> [action] </xsl:when> <xsl:otherwise> [action] </xsl:otherwise></xsl:choose>

61


61 Extraire une sous-chaîne

Dans un nœud texte, on peut extraire une sous chaîne.ex. Extraire l’année seule dans "février-2009"

Utiliser la fonction XPath "substring-after()" qui prend deux arguments : La chaîne source La chaîne à partir de laquelle sélectionner le texte (pattern).

<xsl:if test="docDate"> <xsl:text> (année: </xsl:text> <xsl:value-of select= "substring-after(docDate, '-')" /> <xsl:text>)</xsl:text> <xsl:if>

62


62 Extraire une sous-chaîne

février-2010 substring-after(docDate, ‘-’)

2010

docDate

XPath dans ce cas retourne une chaîne, et non plus un « sac de nœuds ».

En attendant XSLT 2.0 et les expressions régulières, les fonctions chaînes de XPath paraissent rudimentaires :

63


63 Fonctions sur des chaînes

64


64

Par exemple, on veut récupérer les éléments en italique ayant la valeur IT dans l'attribut @rend.

Mais @rend peut également contenir "IT BO" ou "BO IT" pour marquer italique + gras, etc.

On ne les extraira pas avec :select="//*[@rend = 'IT']", qui recherchera les @rend avec comme valeur exacte IT.

contains permet ici de récupérer tous les italiques :

select="//*[contains(@rend, 'IT')]"

Tester la présence d’une sous-chaîne

65


65

Ces fonctions ne sont utiles que sur des contenus très normalisés.

XSLT n’est pas adapté au traitement de chaînes de caractères.

Il est impossible par exemple de s’en servir pour extraire les phrases d'un texte en se basant sur la ponctuation.

XSL et le traitement des chaînes

Quantifier

67


67 count(), la fonction magique

Cette fonction XPath permet de retourner le nombre de nœuds trouvés dans l’expression XPath entre parenthèses

Permet de dénombrer tout phénomène exprimé en XML

<xsl:value-of select="count(//p[@type = 'intro'])"/>

<xsl:value-of select="count(//*[@lang = 'en'])"/>

<xsl:value-of select="count(//div/p[1]/*[@ana= 'exemple'])"/>

68


68Utiliser des variables

Jusqu’à présent on a systématiquement mis le résultat d’une expression XPath dans xsl:value-of, qui affiche directement le résultat.

Mais si l’on veut stocker et manipuler la valeur, pour afficher par exemple un pourcentage plutôt que le chiffre brut ?

69


69xsl:variable

hello world

helloNom de la variable :

Valeur de la variable :

70


70Stocker une valeur calculée

Définition de 3 variables :<xsl:variable name="nbrChap"

select="count(//chap)" /><xsl:variable name="nbrChap1"

select="count(//chap[@title='1'])" /><xsl:variable name="nbrChap2"

select="count(//chap[@title='2'])" />Calcul du pourcentage de chapitres de niveau 1 :<xsl:value-of

select="($nbrChap1 * 100) div $nbrChap" />Calcul du pourcentage de chapitres de niveau 2 :<xsl:value-of

select="($nbrChap2 * 100) div $nbrChap" />

• Évite de recalculer plusieurs fois count(//chap)• Code plus rapide et plus modulaire (raffinement)

71


71 Portée des variables

Une variable reste utilisable dans tout l’élément dans lequel elle a été déclarée dans la feuille de style et dans les sous-éléments de celui-ci. Une fois sortie de cet élément, elle est détruite Une variable déclarée directement comme enfant de xsl:stylesheet peut être utilisée dans toute la feuille de style.

Une variable déclarée dans un élément (xsl:template, xsl:if, etc.) ne peut être utilisée que dans cet élément et ses sous-éléments.

72


72 Quelques fonctions arithmétiques

73


73 Utiliser un template pour calculer les pourcentages

Problème : on répète n fois la même opération pour calculer des pourcentages

Solution : factoriser cette opérationXSLT permet de créer une sous-routine

(un template) qui retourne une valeur en fonction d'arguments

74


74

Appel du template

xsl:with-param permet de transmettre les arguments

xsl:param permet de nommer les arguments reçus

Définition du template

Déf. des 3 variables comme précédemment

75


75 L'intérêt d'une approche "procédurale"

Nous avons vu une façon d'utiliser XSLT où l'on sait où chercher l'information à extraire.

Cette démarche est adaptée pour les cas où l'on fait une extraction de faible volume dans des endroits précis de la structure.

Mais…

L'approche par templates

77


77 L'intérêt d'une approche par templates

Si l'on veut – plutôt qu'extraire un élément – recopier la totalité du document sauf un élément ?

Ou si l'on veut extraire un grand nombre d'éléments ?

XML a une structure non limitée : il faudrait un nombre irréaliste de for-each et if

Il est plus économique dans ce cas d'indiquer ce que l'on veut enlever ou modifier que ce que l'on veut extraire.

78


78

Plutôt que de décrire des opérations, on dessine un nouvel arbre en indiquant seulement les points à modifier de l'arbre existant.

79


79 Retour en arrière

Toutes les feuilles de style commençaient par <xsl:template match="/">

Cet élément xsl:template sert à regrouper des actions à faire à un "moment" précis

Ce moment est désigné dans l'attribut @match@match attend une expression XPath, ici "/"

indique la racine du document.Un template avec match="/" est exécuté en

premier, puisque la racine est la première chose que cherche le processeur.

80


80Comment utiliser les templates ?

Il suffit de prévoir pour l’élément que l’on veut traiter un élément template avec un @match qui lui correspond. @match peut correspondre à tout nœud : élément, attribut (avec @), texte (avec text()) ou commentaire (avec comment()).

Exemple : un template qui s’appliquera à chaque élément <SALLE> dans le document :

<xsl:template match= "SALLE">...

<xsl:template>

81


81Exemple : mettre un titre HTML à chaque texte

Cette nouvelle règle permet de relancer l’analyse et donc de la continuer comme le traitement du document...

82


82 xsl:apply-templates

Dans l'exemple précédent,apply-templates sert à relancer l'analyse (la recherche d'un template avec un attribut match qui correspond) dans la sous-arborescence (les

descendants) du nœud traité par le template

Si on ne met pas apply-templates le processeur est « éteint », il abandonne tout ce qui est en deçà (i.e. la sous-arborescence) !

83


83 Que fait le processeur ?

Après avoir construit une représentation du document, le processeur rentre dans l'arborescence.

Il cherche dans la feuille de style un template qui correspond à sa première position, qui est "/"

S'il n'en trouve pas, il passe aux descendants et recommence.

S’il trouve un nœud texte, il imprime son contenu.

84


84 Document/


Elementcorpus

Elementtext

Elementp

Elementp

Elementp

Elementp

Text

Text

Text TextElement

name

Text

Le processeur parcours les éléments dans un ordre prévisible et leurs attributs dans un ordre non prévisible.

85


85

Tant que parmi les descendants le processeur ne trouve pas de templates à appliquer, il continue à descendre dans l’ordre enfant / frère, en imprimant les nœuds texte.

Elementp

Elementp

Text

Elementname

Si un template avec match="p" est défini, le processeur l’applique, sinon il descend au nœud texte, l’imprime, et remonte au p suivant

Idem : s’il n’existe pas de template pour name, passe aux nœuds enfants

Que fait le processeur ? (suite)

86


86

Elementp

Elementp

Text

Elementname

<xsl:template match="p"> <p><xsl:apply-templates /></p></xsl:template>

Ce template est exécuté à chaque p rencontré.

Une balise p est ouverte, l’analyse reprend dans la sous-arborescence (d’autres templates peuvent être exécutés), puis le p est fermé

<xsl:template match="name"> M. ***</xsl:template>

Toutes les balises name et leurs contenus sont remplacés par « M. *** ».

Que fait le processeur ? (suite)

87


87 L’enchâssement

Dans un template, l’ instructions, xsl:apply-templates a un effet spécial : elle relance la recherche de templates parmi les enfants. Quand le processeur a fini de traiter les descendants, il reprend et

termine l’exécution du template d'où il est parti du fait de l'instruction apply-templates

Sinon, il ne rentre pas dans la sous-arborescence. Avec les xsl:apply-template les templates sont donc

"enchâssés" autant de fois que nécessaire pendant l'exécution.

xsl:template permet de traiter les éléments inclus, contrairement à value-of

88


88 L'enchâssement (2)

<?xml version="1.0"?><xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:template match="/">

<html><body> <xsl:apply-templates />

</body> </html> </xsl:template>

<xsl:template match="p"> <item><xsl:value-of select="." /> </item> </xsl:template>

</xsl:stylesheet>

1. Ligne imprimée en tout premier

2. Passe à la descendance, alors que le template n'est pas fini. Imprime le texte contenu dans les éléments sauf p qui est traité explicitement

3. Tous les p sont traitésmais pas leurs descendants car le processeur n'a pas été relancé avec xsl:apply-templates !

4. Quand la descendance est traitée, "remonte" de "templates appelant" en "templates appelant" et fini chacun. Cette ligne est donc imprimée en tout dernier

89


89Utilisation dexsl:apply-templates

On peut mettre plusieurs xsl:apply-templates dans le même template.o C’est le cas lorsque l’on ne veut pas parcourir tout le document mais

seulement certaines parties.o C’est aussi le cas lorsque l’on veut procéder à l’analyse selon un ordre

particulier ou que l’on veut traiter les attributs après les descendants.o Etc.

<xsl:template match="/"><html><body>

<h1>1. les salles</h1><xsl:apply-templates select="//SALLE"><h1>2. les numéros de salles</h1><xsl:apply-templates select="//SALLE/@NO">

</body></html></xsl:template>

90


90apply-templates : utiliser @select

<xsl:template match="/"><liste_seances><xsl:text> Cinéma:

<xsl:value-of select="//NOM" />
</xsl:text> <xsl:apply-templates select="//SALLE"/></liste_seances>

</xsl:template>

<xsl:template match="SALLE"> <item>Salle <xsl:value-of select="./@NO" /> : <xsl:for-each select=".//SEANCE" /> <horaire><xsl:value-of select=".//SEANCE" /> </horaire> </xsl:for-each/> </item> </xsl:template>

Ici on passe directement aux <SALLE>

Ici on devrait également utiliser xsl:apply-templates plutôt que for-each (qui reste une approche procédurale) !!!

91


91

Document transformé :<liste_seances> Cinéma: Epée de bois

<item>Salle 1 :

<horaire>15:00</horaire>



</item>

<item>Salle 2


</item>

</liste_seances>

apply-templates : utiliser @select

92


92

@select permet ici de descendre directement plus bas dans la sous-arborescence en "sautant" toute une partie.

On peut aussi désigner un endroit qui n'est pas dans la sous arborescence (en évitant de produire une boucle infinie !).

Note : par défaut, un xsl:apply-templates contient un @select="node()" qui lui fait sélectionner ses enfants

apply-templates : utiliser @select

93


93 Supprimer les balises

Une feuille de style contenant ce seul template recopie le document source en enlevant toutes les balises :

<xsl:template match="/"><xsl:apply-templates />

</xsl:template>

EN effet, par défaut, dans tous les nœuds où il ne trouve pas de xsl:template qui s’applique, le processeur imprime le contenu pour les nœuds de type texte et passe aux enfants pour les autres types de nœuds.

94


94Supprimer du texte

Plutôt que d'indiquer au processeur des chemins à parcourir qui excluent certaines parties de texte, on peut modifier son action par défaut (recopier le texte) sur les nœuds à exclure :

<?xml version="1.0"?><xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:template match=”NOM | ADRESSE | METRO | …"><!– le template ne contient rien : ni action, ni relance duprocesseur avec apply-templates. Le contenu est donc abandonné -->

</xsl:template>

</xsl:stylesheet>

95


95La clef : les templates par défaut

Pourquoi, par défaut, le processeurs descend dans l'arborescence et imprime les nœuds textes ?

Une feuille de style a deux templates par défaut ; Ces templates sont appliqués quand le processeur ne trouve pas dans

la feuille de style un template correspondant au nœud traité

<xsl:template match="/ | *”><xsl:apply-templates/>

</xsl:template>

Correspond à la racine (/) ou (|) à tout élément (*). Action = avancer le processeur aux enfants (incluant élément, attribut et nœud texte car apply-template a par défaut @select=“node()”), et leur appliquer les templates.

Correspond à tout nœud texte. Action = imprimer son contenu

<xsl:template match="text()”><xsl:value-of select="."/>

</xsl:template>

96


96

Quand plusieurs templates peuvent s’appliquer…

pourquoi le processeur applique :<xsl:template match= "SALLE">et non le template par défaut :<xsl:template match="/ | *">,alors que les deux sont en concurrence ?

=> Le processeur applique le template le plus spécifique. On peut utiliser cette propriété pour prévoir un cas général et

des cas particuliers :@match="p" : s’applique à tous les p@match="p[1]" : s’applique à tous les aînés des fratries.

97


97 Redéfinir les templates par défaut

On peut redéfinir les templates par défaut pour modifier le comportement du processeur.

Si on ajoute <xsl:template match="text()"></xsl:template>

le processeur parcours toujours l'arborescence mais n'imprime plus les nœuds textes.

98


98

Exemple de modification des templates par défaut

On veut extraire du document seulement le contenu des nœuds REMARQUE.

Dans ce cas de figure la majorité du document est à exclure, seul un tag est à conserver.

On peut utiliser deux possibilités :1. Indiquer le chemin qui mène aux nœuds voulus2. Laisser le cheminement par défaut dans l'arborescence,

mais modifier le comportement par défaut pour ne pas recopier les nœuds textes

99


99 Méthode 1

Laisser le comportement par défaut, mais utiliser @select pour mener directement sur les REMARQUE


<xsl:template match="/"><xsl:apply-templates select="//REMARQUE">

</xsl:template>

</xsl:stylesheet>

100


100 Méthode 2

On modifie le comportement par défaut : on laisse le cheminement dans l'arborescence, mais les nœuds textes ne sont plus recopiés, sauf pour le nœud voulu.


<xsl:template match="text()"></xsl:template>

<xsl:template match="REMARQUE"><REMARQUE><xsl:value-of select='.'/></REMARQUE>

</xsl:template>

</xsl:stylesheet>

101


101Pour résumer (1)

Le processeur parcours l’arborescence, piloté par des templates, qui peuvent l'arrêter à des endroits précis, exécuter des instruction XSLT, et le relancer

Quand il ne trouve pas de template à appliquer, le processeur parcours l'arborescence, relancé par un template par défaut, dans un ordre enfants vers frères, et imprime le texte.

A moins qu’un template capte le processeur dans l’arborescence et ne le relance pas, l’arbre est parcouru entièrement, et tous les nœuds textes sont répliqués.

102


102Pour résumer (2)

Avec des templates on pilote le processeur : En insérant des templates à des points avec match En relançant ou non avec apply-templates En sélectionnant des sous arbres avec @select En utilisant ou modifiant les templates par défaut.

L’ensemble de ces moyens d’action permet d'utiliser cette approche déclarative (par template) comme la plus économique pour décrire une transformation de l’arborescence source en une arborescence cible.

Grouper

104


104 Extraire les valeurs différentes

Comment produire une liste sans doublon des valeurs de @lang ? Avec <xsl:for-each select="//@lang"> la

liste produite peut contenir plusieurs fois la même valeur.

Comment regrouper les nœuds sur une valeur commune ? Par exemple à partir de plusieurs tag correction

(<corr resp="DC" date="12-06-2002">), les classer par correcteur sans les connaître à l'avance.

105


105 Solution : xsl:key

xsl:key déclare une variable dans laquelle des nœuds sont regroupés par "clefs".

xsl:key a trois attributs obligatoires : @name : donne un nom à la variable @match : une expression XPath indiquant les

nœuds à collecter @use : une expression XPath indiquant quelle

valeur utiliser pour grouper ces nœuds.

106


106<xsl:key

name="grouperParResp" match="//corr" use="@resp"

/>

On recherche les tags corr

On les groupes selon la valeur de leur attribut @resp (le contexte de cette expression XPath est le nœud corr)

en se <corr sic='désaisissant' resp='DB'>dessaisissant</corr> ... <corr sic='desine' resp='DB'>dessine</corr> déjà les traits ... <corr sic='l'originial' resp='CF'>l'original</corr> ... <corr sic='uotre' resp='CF'>notre</corr>

DB

CF

<corr sic='désaisissant' resp='DB'>dessaisissant</co

rr>

<corr sic='desine' resp='DB'>dessine</corr>

<corr sic='l'originial' resp='CF'>l'original</corr>

<corr sic='uotre' resp='CF'>notre</corr>

Clefs Nœuds collectés

107


107

L’élément key définit un groupe de nœud, lui attribue un nom et définit l’expression (la clef) qui permet de différencier les nœuds au sein de ce groupe.

108


108 Utilisation

Une fois créée une variable xsl:key peut être utilisée pour obtenir les nœuds associés à une clef.

la fonction XPath key(nom_table, clef) retourne tous les nœuds associés à l'entrée clef dans la table nom_table

<xsl:for-each select="key(grouperParResp, 'DB')"> Texte d'origine : <xsl:value-of select="@sic"/> Texte corrigé : <xsl:value-of select="."/></xsl:for-each>

Texte d'origine : désaisissantTexte corrigé : dessaisissantTexte d'origine : desineTexte corrigé : dessine

Appliqué à l'exemple précédent :

109


109 Trouver les valeurs uniques

Avec la fonction key() on ne peut que retrouver les nœuds associés à une clef, on ne peut pas lister directement les clefs d'une variable xsl:key.

Pour une liste de valeurs différentes, par exemple la liste des valeurs utilisées dans @lang, il faut utiliser une méthode détournée : utiliser une expression qui extrait un élément de chaque groupe

correspondant à une clef. Par exemple ne prendre que les éléments dont l'index dans le groupe dont

il fait parti est 1 Pour savoir si un nœud est le même que le premier retourné par un groupe

, on peut comparer la valeur que retourne generate-id() qui retourne un identifiant unique constant pour chaque nœud.

110


110Exemple

<xsl:key name="langues" match="//@lang" use="."/>

<xsl:for-each

select="//@lang[generate-id(.)=

generate-id(key(Langues', .)[1])]"> ...

•key(Langues', .) retourne le groupe des nœuds doublons du nœud traité.•key(Langues', .)[1] retourne le premier élément du groupe•generate-id retourne un identifiant unique pour un nœud. L'id du nœud contexte doit être le même que l'id du premier nœud du groupe des nœuds doublons.

• On sélectionne uniquement le premier nœud de chaque groupe, donc un nœud par groupe.

111


111

Cette méthode peut être utilisée avec un nœud différent entre match et use :

<xsl:key name="Langue" match="*[@lang]" use="@lang"/><table> <tr>

<td>Langues</td><td>Nombre d'éléments dans cette langue</td>

</tr> <xsl:for-each select="//*[@lang and generate-id(.)=

generate-id(key('Langue', @lang)[1])]"> <tr> <td><xsl:value-of select="@lang" /></td> <td><xsl:value-of select="count(key('Langue', @lang))"/> </td> </tr> </xsl:for-each></table>

112


112

@use peut être n'importe quelle expression calculée. Par exemple on peut grouper les p en fonction du nombre de notes qu’ils contiennent xsl:key name="pParNote" match="//p" use="count(note)«

On peut imaginer maintenant de regarder pour chaque groupe la position moyenne en début ou fin de texte, etc.

Ajout d’information, Editer le corpus source

114


114

Jusqu’ici XSLT était utilisé pour extraire des données, pas pour éditer le corpus source.

XSLT impose de nombreuses limites à une utilisation pour ajouter de l’informations : il est difficile de « recopier » à l’identique.

L’édition d’un corpus avec XSLT ne peut donc se faire que sur des corpus très normalisés.

115


115Recopier à l’identique : copy-of

116


116xsl:copy

<xsl:template match="node() | @*"> <xsl:copy> <xsl:apply-templates

select="node() | @*"/> </xsl:copy></xsl:template>

<xsl:template match="xptr[not(@id)]">

</xsl:template>

En utilisant récursivement la fonction copy dans un template, on peut obtenir cette duplication et définir des templates pour ajouter des modifications

117


117 xsl:element et xsl:attribut

118


118 Exemple 1 : déplacer un élément

Dans un corpus les notes sont regroupées à la fin du document. Des éléments ptr ont permis d’enregistrer l’endroit des appels de note ; leur attribut @target permet de les associer à la note dont l’attribut @id correspond

Le but est de remonter les notes, conformément aux prescription TEI, directement à leur point d’insertion dans le texte et supprimer les pointeurs ptr.

119


119<xsl:template match="node() | @*"> <xsl:copy> <xsl:apply-templates

select="@* | node()"/> </xsl:copy></xsl:template>

<xsl:template match="ptr"><xsl:variable name="id" select="@target" /><xsl:element name="note">

<xsl:for-each select="./ancestor::text/back/note[@id=$id]/@*"> <xsl:attribute name="{name(.)}"> <xsl:value-of select="."/> </xsl:attribute>

</xsl:for-each><xsl:value-of select=".//ancestor::text/back/note[@id=$id]"/>

</xsl:element></xsl:template>

<xsl:template match="note"></xsl:template>

</xsl:template>Cf. ci-joint "ajout.xsl"

Conclusion

121


121 Limites d'XSLT

Délicat pour l'ajout d'annotation au corpus Délicat de contrôler complètement la réécriture

Lourd et insuffisant pour la manipulation des chaînes de caractère (les nœuds texte) Prévu pour la manipulation de la structure, de l'encodage plus que du contenu

des nœuds textes Inutilisable avec de très gros documents

Prévoir dix fois la taille du fichier en mémoire vive. Ces limites sont dues à l'approche "arborescente" : XSLT permet de

manipuler une arborescence en mémoire. Une autre représentation du contenu, dite "séquentielle" permet plus de

précision et n’est pas limité par la taille du document, mais demande l’utilisation d’un langage de programmation.

122


122 Efficacité comme langage de requête

Deux stratégies à cumuler : à dominante procédurale ou déclarative.

Economie et plasticité grâce à l’utilisation de templates et templates par défaut.

Adapté à l’extraction d’information, la projection de sous-corpus ou la conversion vers d’autres formats.

La version 2 de XSLT apportera des améliorations (expressions régulières, typage, regroupement), sans changer cette dominante « extraction », plus que« édition », dans la « transformation »

XSLT : XML Stylesheet Language Transformation & XPath : langage dadressage de parties de documents...

Documents

Transcript of XSLT : XML Stylesheet Language Transformation & XPath : langage dadressage de parties de documents...