XML Schema documentation de cours avance avec exemples

(1)

Introduction à XML

1. Le langage XML

1.1. XML dans son contexte :

XML est une technologie de description et de structuration de données. Actuellement, on trouve deux moyens pour stocker les données sur ordinateur : dans un fichier binaire ou dans un fichier de texte. Si on désire comparer les deux :

C’est dans ce contexte qu’on a essayé d’imaginer un langage capable de posséder les avantages du binaire (notamment la mise en forme) combinés avec la souplesse de lecture des fichiers textes.

Le système de balises est le moyen utilisé pour décrire, structurer et mettre en forme de l’information. Un exemple très simple si on veut indiquer qu’une partie du texte doit être en rouge on peut écrire :

Texte quelconque <rouge> cette phrase est en rouge </rouge>

Dans cet exemple, la balise ouvrante ici "<rouge>" indique que le texte qui suit doit être en rouge. La balise fermante ici "</rouge>" indique que l’enrichissement stylistique prend fin.

1.2. Historique : de SGML à XML Le SGML

XML dérive d'un langage développé dans les années 80, le SGML. Ce langage était complexe à apprendre et utiliser quotidiennement.

Le SGML (Standard Generalized Markup Language, langage de balisage standard généralisé), est le premier langage de type texte auto_descriptif. Adopté comme standard en 1986, SGML a été conçu dans le but de faciliter la gestion d’importants fichiers par les gros systèmes.

Le SGML est constitué de plusieurs composants. Ceux-ci changent pour chaque application SGML :

- Définition du type de document (DTD) : ce composant sert à préciser la structure du document ; - Instance du document : il s'agit du texte réel du document comportant les éléments SGML qui ont été définis dans la DTD et qui identifient les diverses parties du texte.

- Synthèse du document : ce composant sert à préciser les principaux aspects de l'application SGML. C'est à ce niveau que sont déterminées les options et qu'est précisé le jeu de caractères qui sera utilisé ainsi que les autres fonctions similaires.

Ce langage servant à préciser la structure d'un document quelconque, il est compréhensible que sa généralité le rende difficile d'apprentissage, et complexe d'emploi. En particulier, il était inadapté à l'écriture de documents pour Internet. Il a donc été nécessaire d'en dériver le langage HTML.

Le HTML

HTML (Hypertexte Markup Language) est un langage de balisage comme le SGML. Il n’est pas destiné au stockage de données mais à leur affichage. C'est aujourd'hui le standard du développement

Fichiers binaires Fichiers textes - Ne peuvent être ouverts ou crées que par des

applications pouvant les comprendre ou générer, ils sont donc propriétaires ;

- Problèmes de versions ;

- Ils sont plus faciles à lire et à écrire, la gestion de données est donc rapide

- Ils ne sont pas propriétaires et peuvent être lus par un très grand nombre d’applications ; - Ils assurent le partage d’informations ; - Pas de mise en forme, que du texte brute sans

couleurs ni image . . . - Moins rapides

(2)

Ce langage est facile à apprendre et à utiliser ; il a d'ailleurs donné lieu au développement de nombreux outils de publication sur Internet tels que les éditeurs HTML (Dreamweaver, FrontPage, ….).

Le HTML étant une application SGML, il est donc lié lui aussi à une DTD. Il en existe parfois plusieurs par version d'HTML. Celles de la version 4.01 se trouvent référencées sur le site web du W3C : DTD HTML 4.01 Strict, Transitional, Frameset...

Un inconvénient du HTML est son champ d'action limité : il n'est ainsi pas possible de définir autre chose qu'une page Web. Au bout de quelques années, la demande se faisant de plus en plus forte pour la

définition d'un nouveau format, et le langage HTML rencontrant ses limites, le W3C a commencé à organiser des groupes de travail sur un autre descendant du SGML, le XML.

XML

Le XML (eXtensible Markup Langage) est un dérivé du SGML est destiné à décrire et structurer les données.

Le plus important point commun avec le SGML est le fait que tout document XML peut être basé sur une DTD ou un Schéma. Cette association n'est cependant pas obligatoire, et un fichier XML peut très bien se suffire à lui-même.

Une autre caractéristique importante est que dans un document XML, la mise en forme des données est totalement séparée des données elles-mêmes. Cela permet de séparer complètement l'information (le contenu) de son apparence (le contenant), et donc de fournir plusieurs types de sortie pour un même fichier de données, en fonction de l'utilisateur ou de l'application demandeuse (autre document XML, tableau, graphique, image, animation multimédia, fichier HTML, fichier PDF...).

De plus, la possibilité de créer les éléments que l'on désire permet de rendre le fichier lui-même lisible -et modifiable- par un être humain : on peut donner aux informations contenues dans un tel fichier le nom que l'on veut, et les ordonner selon son désir.

Un document XML peut ainsi prévoir plusieurs cibles, comme par exemple l'écran d'un téléphone portable, celui d'un ordinateur de bureau, une base de données, une application logicielle, etc.

Il est également possible d'effectuer des sélections par tri, des générations automatiques de tables des matières et bien d'autres fonctions encore, grâce au langage de feuilles de style XSLT.

La figure suivante récapitule la succession ces langages :

Le WML pour le Wap des téléphones mobiles, le MathML pour les mathématiques.

II. Mise en œuvre 1. Procédure

XML permet de nettement séparer forme et fond. Par exemple, cela signifie que pour produire un document HTML à partir de données en utilisant le format XML, il est nécessaire d'écrire au moins deux fichiers, le premier contenant les données à mettre en forme, le second les informations nécessaires à cette mise en forme. En pratique, et dans un souci de normalisation et de généralisation, il peut s'avérer

nécessaire d'ajouter un troisième fichier à l'ensemble :

1. Optionnel : un fichier peut être nécessaire pour définir a priori les balises auxquelles le document XML pourra avoir recours. Ce fichier peut être soit une Document Type Definition soit un Schema (voir plus loin dans le cours) ;

(3)

2. Le document contenant les données elles-mêmes, c'est-à-dire le document XML à proprement parler (une instance du document, au sens SGML) ;

3. Le document contenant les informations de mise en forme, permettant de produire un fichier dans le format de sortie voulu : une feuille XSLT (eXtensive Stylesheet Language Transformations). Dans le cas d'un format de sortie HTML, il peut être également nécessaire d'ajouter une feuille de style CSS. En résumé, si l'on veut produire un fichier HTML à partir de données mises sous format XML, il faut :

1. Créer éventuellement un fichier définissant les balises utilisables ; 2. Créer le fichier de données XML ;

3. Créer la feuille de style XSL permettant la production du fichier HTML ; 4. Créer éventuellement une feuille de style CSS.

III. Structure d'un document XML 1. Exemple : une bibliographie

<?xml version="1.0" encoding="ISO-8859-1"?> <biblio> <livre> <titre>Les Misérables</titre> <auteur>Victor Hugo</auteur> <nb_tomes>3</nb_tomes> </livre> <livre lang="en"> <titre>David Copperfield</titre> <auteur>Charles Dickens</auteur> </livre> </biblio>

Sur l'exemple précédent, un fichier XML est composé d'un prologue, d'un élément racine et d'un arbre. Cet arbre est constitué d'éléments imbriqués les uns dans les autres (ayant une relation parent-enfant) et d'éléments adjacents.

Les premières lignes forment le prologue, constitué dans l'exemple précédent de la déclaration XML, et éventuellement d'une déclaration de type de document (une DTD) ;

L'élément biblio est notre élément racine (en anglais : document element) ; il est constitué de trois éléments livre. Dans chacun d'entre eux nous retrouvons la même composition, c'est-à-dire : un élément titre, un élement auteur et éventuellement un élément nb_tomes. L'élément livre, de plus, a un attribut lang ;

2. Le prologue

a. Déclaration XML

Cette déclaration fait partie des "instructions de traitement". Exemple de déclaration XML : <?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>

On distingue trois informations fournies dans cette déclaration :

1. version : version du XML utilisée dans le document, 1.0 en ce qui nous concerne (la dernière version du langage, 1.1, date de février 2004 mais ne change rien quant à ses bases) ;

(4)

2. encoding : le jeu de codage de caractères utilisé. Le jeu de caractère habituel pour le français est le ISO-8859-1. Par défaut, l'attribut encoding a la valeur UTF-8.

3. standalone : dépendance du document par rapport à une déclaration de type de document. Si standalone a la valeur yes, le processeur de l'application n'attend aucune déclaration de type de document extérieure au document. Sinon, le processeur attend une référence de déclaration de type de document. La valeur par défaut est no.

Cette déclaration est facultative, mais il est préférable de l'utiliser, auquel cas les attributs version, encoding et standalone doivent être placés dans cet ordre. Si elle est utilisée, elle doit être placée en toute première ligne du document XML.

b. Instructions de traitement

Une instruction de traitement est une instruction interprétée par l'application servant à traiter le document XML. Elle ne fait pas totalement partie du document. Les instructions de traitement qui servent le plus souvent sont la déclaration XML ainsi que la déclaration de feuille de style. Exemple d'instruction de traitement :

<?xml-stylesheet type="text/xsl" href="biblio.xsl"?>

Dans cet exemple, l'application est xml-stylesheet, le processeur de feuille de style du XML. Deux feuilles de style différentes peuvent être utilisées, les XSL (propres au XML) ainsi que les CSS (feuilles de style apparues avec le HTML). L'attribut type indique de quel type de fichier il s'agit

(text/css pour les feuilles de style CSS, par exemple) et l'attribut href indique l'URL du fichier. Cette instruction de traitement est notamment utilisée par les navigateurs Internet pour la mise en forme du document.

c. Déclaration de type de document (DTD)

Cette déclaration, lorsqu'elle est présente, permet de définir la structure du document. Elle peut être de deux types, externe ou interne. Exemple de déclaration de type de document :

<!DOCTYPE biblio SYSTEM "biblio.dtd">

Ce type de déclaration est celui d'une déclaration de type de document externe (voir le chapitre sur les DTD). Elle définit l'ensemble des éléments utilisables dans le document, y compris l'élément-racine (ici biblio) ainsi que le nom de fichier biblio.dtd dans lequel se trouve définie la structure du document. L'autre type de document permettant de définir la structure d'un fichier, le schéma XML.

IV. La syntaxe du XML 3. Les commentaires

En XML, les commentaires se déclarent de la même façon qu'en HTML. Ils commencent donc par . Ils doivent impérativement se trouver à l’extérieur d’une balise PCDATA

<element> Un peu de texte </element>

Remarque : En raison de la compatibilité XML/SGML, la chaîne de caractères -- est interdite dans un commentaire.

4. L'arbre d'éléments

Un document XML peut se représenter sous la forme d'une arborescence d'éléments. Cette arborescence comporte une racine (unique), des branches et des feuilles.

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

(5)

<!—Premier enfant --> <livre>

<titre>Les Misérables</titre> <auteur>Victor Hugo</auteur> <nb_tomes>3</nb_tomes> </livre> <livre lang="en"> <titre>David Copperfield</titre> <auteur>Charles Dickens</auteur> </livre> </biblio> Élément racine

L'élément-racine (en anglais : document element) est, comme son nom l'indique, la base du document XML. Il est unique et englobe tous les autres éléments. Il s'ouvre juste après le prologue, et se ferme à la toute fin du document. Dans l'exemple ci-dessus, l'élément racine est biblio.

Les éléments

Les éléments forment la structure même du document : ce sont les branches et les feuilles de l'arborescence. Ils peuvent contenir du texte, ou bien d'autres éléments, qui sont alors appelés "éléments enfants", l'élément contenant étant quant à lui appelé logiquement "élément parent".

Exemple d'élément contenant du texte :

<titre>Les Misérables</titre> Exemple d'élément contenant d'autres éléments : <livre>

<titre>L'Assommoir</titre> <auteur>Émile Zola</auteur> <couverture couleur="rouge" /> </livre>

D'autres éléments sont vides : ils ne contiennent pas d'élément-enfant. Exemple d'élément vide : <couverture couleur="rouge" />

Les attributs

Tous les éléments peuvent contenir un ou plusieurs attributs. Un attribut est composé d'un nom et d'une valeur. Il ne peut être présent que dans la balise ouvrante de l'élément (par exemple, on n'a pas le droit d'écrire </livre lang="en">).

Exemple d'utilisation d'un élément avec attribut :

<instrument type="vent">trompette</instrument>

Les valeurs des attributs doivent toujours être mises entre des guillemets, au contraire du Html où leur absence n'a plus beaucoup d'importance.

Ainsi, l'écriture suivante est incorrecte car il manque les guillemets. <date anniversaire=071185>

La bonne écriture est :

Les entités

Certains caractères ayant un sens précis en XML, il est nécessaire de leur trouver un remplaçant lorsque l'on a besoin de les insérer dans un document. On a recours dans ce cas à des entités prédéfinies. Ces entités sont :

(6)

< < > > " " ' &aquot; Exemple, pour avoir :

<verite>deux<trois>un</verite> On doit écrire :

Les sections CDATA

Le sections CDATA permettent de transmettre les données qu’elles contiennent telles quelles à l’application, via le parseur. Exemple :

<verite>[CDATA[deux<trois>un]]</verite>

5. Règles de composition

Le XML impose des règles de syntaxe très spécifiques par rapport au Html. En outre, on retrouvera ces mêmes règles de syntaxe dans tous les langages dérivés du XML comme le XHTML

Le XML est un langage de balises [Markup Language].

Mais au contraire du Html où les balises sont définies, vous devez inventer vos balises. Rappelez-vous, le XML est eXtensible. Il faut donc écrire soi-même le nom des balises utilisées.

Il y a quelques règles pour la composition des noms (mais elles ne dérouteront pas les habitués du Javascript) :

Les noms peuvent contenir des lettres, des chiffres ou d'autres caractères. Les noms ne peuvent débuter par un nombre ou un signe de ponctuation. Les noms ne peuvent commencer par les lettres xml (ou XML ou Xml...). Les noms ne peuvent contenir des espaces.

La longueur des noms est libre mais on conseille de rester raisonnable.

On évitera certains signes qui pourraient selon les logiciels, prêter à confusion comme "-", ";", ".", "<", ">", etc.

Les caractères spéciaux pour non francophones comme é, à, ê, ï, ù sont à priori permis mais pourraient être mal interprétés par certains programmes.

On profitera de cette liberté dans les noms pour les rendre le plus descriptif possible comme par exemple <gras_et_italique>.

Les balises sont sensibles au majuscules et minuscules [case sensitive].

Ainsi, la balise <Message> est différente de la balise <message>. La balise d'ouverture et la balise de fermeture doivent donc être identiques. Ainsi par exemple ; <Message> ... </message> est incorrect et <message> ... </message> est correct.

Une tendance se dégage pour n'écrire les balises qu'en minuscules, limitant ainsi les erreurs possibles.

Toute balise ouverte doit impérativement être fermée.

Fini les écritures bâclées du Html où l'on pouvait dans certains cas omettre la balise de fin comme pour le paragraphe <p> ou l'élément de liste <li>.

(7)

Ainsi en Html, ce qui suit est affiché correctement : <p>

<ul> <li>Point 1 <li>Point 2

Le XML est beaucoup plus strict. On devrait avoir : <p>

<ul>

<li>Point 1</li> <li>Point 2</li> <p>

Les éventuelles balises uniques ou appelées aussi balises vides, comme <br>, <meta> ou <img> en Html, doivent également comporter un signe de fermeture soit balise/. Ainsi une balise

Les balises doivent être correctement imbriquées.

Le XML étant très préoccupé par la structure des données, des balises mal imbriquées sont des fautes graves de sens.

Ainsi l'écriture suivante est incorrecte car les balises ne sont pas bien imbriquées : <parent><enfant>Loïc</parent></enfant>

L'écriture correcte avec une bonne imbrication des éléments est : <parent><enfant>Marine</enfant></parent>

Tout document XML doit comporter une racine.

En fait, la première paire de balises d'un document XML sera considéré comme la balise de racine [root].

Par exemple : <racine>

... suite du document XML ... </racine>

Si on ose faire un lien avec le Html, votre élément racine était <body> ... </body>. Tous les autres éléments seront imbriqués entre ces balises de racine.

Par exemple : <parents> <enfants> <petits_enfants> ... </petits_enfants> </enfants> </parents>

Les valeurs des attributs doivent toujours être mises entre des guillemets.

Le XML peut avoir (comme le Html) des attributs avec des valeurs. En XML, les valeurs des attributs doivent obligatoirement être entre des guillemets, au contraire du Html où leur absence n'a plus beaucoup d'importance.

(8)

La bonne écriture est :

Le XML est un langage strict. Votre document doit impérativement respecter la syntaxe du XML. On dira alors que le document est "bien formé" [Well-formed]. Seuls les documents "bien formés" seront affichés correctement. A la moindre erreur de syntaxe, le document ne sera pas ou ne sera que

partiellement affiché.

6. Un premier document XML

Rien de bien compliqué mais ce document sera étoffé en cours d'étude.

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

La déclaration <?xml version="1.0"?> indique au navigateur que ce qui suit est un document XML selon sa version 1.0. Vous remarquerez que cette balise ne comporte pas de signe de fermeture car cette balise n'est pas encore du XML.

On en profite généralement pour notifier le "character set" qui indique à l'interpréteur XML [Parser] le jeu de caractères à utiliser. Le jeu de caractères "ISO-8859-1" a, pour nous francophones, l'avantage d'accepter la plupart des lettres avec des accents. Mais il existe d'autres jeux de caractères comme UTF-8 ou UTF-16 plutôt destinés aux anglo-saxons car ils ne reprennent pas les accents.

<racine>

L'élément racine indispensable au XML. Vous pouvez utiliser, à votre convenance, n'importe quel nom à l'intérieur de cette balise de racine.

... suite du document XML ...

Votre document XML proprement dit, qui respectera bien entendu scrupuleusement la syntaxe du XML ("bien formé").

</racine>

Le document XML se termine obligatoirement à la fermeture de la balise de racine.

Elaboration du fichier

Voici un petit fichier XML.

<?xml version="1.0"?> <racine> <enfants> <masculin>Loic</masculin> <feminin>Marine</feminin> </enfants> </racine>

(9)

Et on l'enregistre (non pas en type de document Texte) en " Type : Tous (*.*) " sous un nom avec une extension .xml.

Résultat dans Microsoft Explorer 5 et +

Depuis le version 5 de Microsoft Internet Explorer, les fichiers XML s'affichent sans problèmes.

Vous remarquerez qu'il y a un petit signe - affiché devant des balises englobantes (voir le pointeur sur la capture d'écran). Il suffit de cliquer sur le signe pour masquer celles-ci. Et bien entendu de cliquer sur le signe + pour les faire réapparaître.

(10)

Résultat sous Netscape 6 et +

Le même fichier ne sera visible sur Netscape qu'à partir de la version 6. L'interprétation de ce fichier XML est pour le moins différente.

Au risque de me faire des ennemis, le XML et surtout le XSL est surtout l'affaire de Microsoft Explorer qui les prend mieux en compte. Espérons que ce ne soit que momentané.

7. Afficher le XML avec CSS

Le CSS

Pour afficher les balises XML, on peut faire appel aux bonnes vieilles feuilles de style (CSS), maintenant classiques dans le paysage Html. A chaque balise "inventée" dans le fichier XML, on va définir un élément de style que le navigateur pourra alors afficher.

Un exemple de XML + CSS

A seule fin de démonstration, voici un exemple des possibilités d'une feuille de style CSS associée à un document XML.

Voici notre document XML de départ :

<?xml version="1.0" encoding="ISO-8859-1"?> <racine> <enfant> <nom>Loïc</nom> <lien>garçon</lien> <date>07/11/83</date>

<data>Le petit qui me dépasse d'une tête.</data> </enfant>

<nom>Marine</nom> <lien>fille</lien> <date>20/12/85</date>

<data>La petite fille chérie à son papa.</data> </enfant>

(11)

Affiché dans le navigateur, cela nous donne :

On ajoute un fichier .css dont voici le contenu : <style type="text/css"> racine , enfant {} nom { display: block; width: 250px; font-size: 16pt ; font-family: arial ;

font-weight: bold; background-color: teal; color: white; padding-left: 10px; } lien { display: block; font-size: 12pt; padding-left: 10px; } date {

display: block; font-size: 12pt; color: red ; font-weight: bold;

padding-left: 10px; }

data {

display: block;

font-size: 11pt ; font-style: italic; font-family: arial ; padding-left: 10px; }

(12)

Après avoir ajouté un lien vers le fichier css dans le fichier xml : <?xml-stylesheet href="css.css" type="text/css"?> On obtient finalement :

Mais il y a encore un autre moyen, plus performant et aux possibilités plus étendues : afficher du XML avec le XSL soit le langage de feuilles de style eXtensible. Le pendant du XML au CSS.

8 Des éditeurs XML expliqués

N'attendez pas de miracle des éditeurs XML ! Comme en XML vous fabriquez sur mesure vos balises, les éditeurs ne peuvent avoir qu'un rôle d'aide à l'encodage et à la structure de votre document.

Les éditeurs XML sont cependant d'une grande utilité si vous avez de nombreuses balises récurrentes dans votre document XML. En outre, s'il en nécessaire d'actualiser souvent les données du votre fichier Xml, il sera beaucoup plus facile de vous retrouver dans l'interface d'un éditeur que dans le fouillis de balises du code source.

(13)

Nous allons reproduire le fichier XML qui nous a servi d'exemple jusqu'ici (simple.xml).

Cliquez sur "Root_Element" dans la fenêtre Structure pour l'élément racine et saisissez document au clavier. Cliquez ensuite sur "Child_Element" et encodez la balise enfant.

Ajoutons le sous-élément nom. Cliquez à cet effet sur l'élément enfant, avec le bouton droit de la souris et sélectionnez dans le menu contextuel Insert ! Child Element.

Dans la fenêtre Structure, le curseur d'insertion clignote dans le sous-élément ajouté. On y ajoute la balise nom.

On accède ensuite au cadre de droite soit dans la fenêtre Valeur et on saisit Loic. A ma connaissance, XML Notepad ne permet pas de reprendre le jeu de caractères "ISO-8859-1".

Ajoutons les autres sous-éléments lien, date et data. On clique sur nom ! bouton droit ! Insert ! Element et on encode les données.

On va maintenant répéter la série de balises de sous-éléments. On clique sur enfant ! bouton droit ! Duplicate et la série est reproduite. On

(14)

Pour voir le document terminé, menu View ! Source. En outre, dans la fenêtre ouverte, on vous signale si le document est "bien formé [well formed].

XML Spy

Avec XML Spy, on dispose d'un programme déjà plus professionnel. Il est à notre avis assez remarquable pour la structure qu'il met en place.

Nous allons reproduire le fichier XML qui nous a servi d'exemple jusqu'ici (simple.xml). Commençons par l'élément racine. On prend le menu XML / Insert / Element et on encode la balise racine.

(15)

On passe aux sous-éléments. Après avoir cliqué dans la zone enfant, on demande 4 éléments soit menu XML / Add child / Element que l'on répète 4 fois et on remplit les balises et les données.

Et l'on refait la même chose pour les autres données enfant.

Ceci n'est vraiment qu'un très bref aperçu de XML Spy dont les possibilités sont nettement plus nombreuses et étendues.

(16)

1 / 9

Initiation aux schémas XML

I. Introduction

1. Limitations des DTD

- Premièrement, les DTD ne sont pas au format XML. Cela signifie qu'il est nécessaire d'utiliser un outil spécial pour manipuler un tel fichier, différent de celui utilisé pour l'édition du fichier XML.

- Deuxièmement, les DTD ne supportent pas les « espaces de nom » (voir plus loin). En pratique, cela implique qu'il n'est pas possible d'importer des définitions de balises définies par ailleurs dans un fichier XML défini par une DTD.

- Troisièmement, le « typage » des données (c'est-à-dire la possibilité de spécifier par exemple qu'un attribut ne doit être qu'un nombre entier) est extrêmement limité.

2. Apports des schémas

Conçu pour pallier les déficiences pré-citées des DTD, XML Schema propose des nouveautés en plus des fonctionnalités fournies par les DTD :

Le typage des données est introduit, ce qui permet la gestion de booléens, d'entiers, d'intervalles de temps... Il est même possible de créer de nouveaux types à partir de types existants.

La notion d'héritage. Les éléments peuvent hériter du contenu et des attributs d'un autre élément.. Le support des espaces de nom.

Les indicateurs d'occurrences des éléments peuvent être tout nombre non négatif (rappel : dans une DTD, on est limité à 0, 1 ou un nombre infini d'occurences pour un élément).

Les schémas sont très facilement concevables par modules.

II. Les premiers pas

1. Introduction

Le but d'un schéma est de définir une classe de documents XML. Il permet de décrire les autorisations d'imbrication et l'ordre d'apparition des éléments et de leurs attributs, tout comme une DTD. Mais il permet aussi d'aller au-delà.

Un premier point intéressant est qu'un fichier Schema XML est un document XML. Cela permet à un tel document d'être manipulé de la même manière que n'importe quel autre fichier XML, et en particulier par une feuille de style XSDL. Le vocabulaire de XML Schema est composé d'environ 30 éléments et attributs.

2. Structure de base

Comme tout document XML, un Schema XML commence par un prologue, et a un élément racine. <?xml version="1.0" encoding="ISO-8859-1"?>

<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"> déclarations

</xsd:schema>

L'élément racine est l'élément xsd:schema. Pour le moment, oubliez l'attribut xmlns:xsd qui fait référence à l'espace de noms utilisé pour l'écriture du fichier. Il faut simplement retenir que tout élément d'un schéma doit commencer par le préfixe xsd.

III. Déclarations d'éléments et d'attributs

1. Déclarations d'éléments

Un élément, dans un schéma, se déclare avec la balise <xsd:element>. Par exemple, <?xml version="1.0" encoding="ISO-8859-1"?>

<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"> <xsd:element name="contacts" type="typeContacts" />

(17)

</xsd:schema>

Le schéma précédent déclare deux éléments : un élément contacts et un élément remarque. Chaque élément est « typé » -c'est-à-dire qu'il doit respecter un certain format de données. L'élément contacts est ainsi du type typeContacts, qui est un type complexe défini par l'utilisateur. L'élément remarque quant à lui est du type xsd:string qui est un type simple prédéfini de XML Schema.

Chaque élément déclaré est associé à un type de données via l'attribut type. Les éléments pouvant contenir des élément-enfants ou posséder des attributs sont dits de type complexe, tandis que les éléments n'en contenant pas sont dits de type simple.

2. Déclarations d'attributs a. Déclaration simple

À la différence des éléments, un attribut ne peut être que de type simple. Cela signifie que les attributs, comme avec les DTD, ne peuvent contenir d'autres éléments ou attributs. De plus, les déclarations d'attributs doivent être placées après les définitions des types complexes, autrement dit, après les éléments xsd:sequence, xsd:choice et xsd:all (voir plus loin).

Exemple : <?xml version="1.0" encoding="ISO-8859-1"?> <xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"> . . . . . . <xsd:element name="image"> <xsd:complexType>

<xsd:attribute name="source" type="xsd:anyURI" use="required"/> </xsd:complexType>

</xsd:element> . . . </xsd:schema>

b. Contraintes d'occurences

Tout comme dans une DTD, un attribut peut avoir un indicateur d'occurences.

L'élément attribute d'un Schema XML peut avoir trois attributs optionnels : use, default et fixed. Des combinaisons de ces trois attributs permettent de paramétrer ce qui est acceptable ou non dans le fichier XML final (attribut obligatoire, optionnel, possédant une valeur par défaut...).

Par exemple, la ligne suivante permet de rendre l'attribut maj optionnel, avec une valeur par défaut au 11 octobre 2003 s'il n'apparaît pas (le format de date est standardisé : cette date s'écrit donc à l'anglo-saxonne année-mois-jour ; cela permet en outre de plus facilement classer les dates).

<xsd:attribute name="maj" type="xsd:date" use="optional" default="2003-10-11" /> Il est à noter que la valeur de l'attribut default doit être conforme au type déclaré. Par exemple : <xsd:attribute name="maj" type="xsd:date" use="optional" default="-43" /> produirait une erreur à la validation du schéma.

c. Regroupements d'attributs

XML Schema propose une fonctionnalité supplémentaire, permettant de déclarer des groupes d'attributs (groupes auxquels il est possible de faire appel lors d'une déclaration d'éléments). Cela permet d'éviter de répéter des informations de déclarations. Exemple :

<xsd:attributeGroup name="AttributsLivre"> <xsd:attribute name="isbn" type="IsbnType"/> <xsd:attribute name="prix" type="xsd:float"/> </xsd:attributeGroup>

(18)

3 / 9 <xsd:sequence>

<xsd:element name="titre" type="xsd:string"/> <xsd:element name="auteur" type="xsd:string"/> </xsd:sequence>

<xsd:attributeGroup ref="AttributsLivre"/> </xsd:complexType>

d. Déclaration d'élément ne contenant que du texte avec un (ou plusieurs) attribut(s)

Un tel élément est de type complexe, car il contient au moins un attribut. Afin de spécifier qu'il peut contenir également du texte, on utilise l'attribut mixed de l'élément xsd:complexType. Par défaut, mixed="false"; il faut dans ce cas forcer mixed="true". Par exemple,

<xsd:element name="prix">

<xsd:complexType mixed="true">

<xsd:attribute name="devise" use="required" /> </xsd:complexType>

</xsd:element>

3. Déclaration et référencement

La procédure précédente de déclaration d'éléments peut amener à une structure de type « poupée russe » des déclarations. Pour des raisons de clarté, il est beaucoup plus avantageux d'ordonner ces déclarations. Il est recommandé de commencer par déclarer les éléments et attributs de type simple, puis ceux de type complexe. On peut en effet faire référence, dans une déclaration de type complexe, à un élément de type simple prélablement défini. Par exemple...

<xsd:element name="livre"> <xsd:complexType>

<xsd:sequence>

<xsd:element name="auteur" type="xsd:string" />

<xsd:element name="pages" type="xsd:positiveInteger" /> </xsd:sequence>

</xsd:complexType> </xsd:element>

... est plus difficile à maintenir que...

<xsd:element name="pages" type="xsd:positiveInteger" /> <xsd:element name="auteur" type="xsd:string" />

<xsd:element name="livre"> <xsd:complexType> <xsd:sequence> <xsd:element ref="auteur" /> <xsd:element ref="pages" /> </xsd:sequence> </xsd:complexType> </xsd:element>

IV. Les types de données

1. Introduction

Ainsi que nous l'avons déjà brièvement signalé, XML Schema permet de spécifier des types de données bien plus finement que le langage DTD. Il distingue notamment types simples et types complexes.

2. Types simples a. Généralités

Les types de données simples ne peuvent comporter ni attributs, ni éléments enfants. Il en existe de nombreux, prédéfinis, mais il est également possible d'en "dériver" de nouveaux (nous reviendrons plus loin sur cette fonctionnalité). Enfin, il est possible de déclarer des "listes" de types.

(19)

b. Bibliothèque de types intégrés

Nombreux sont les types prédéfinis dans la bibliothèque de types intégrés de XML Schema. la figure suivante en donne la hiérarchie, et leur liste détaillée figure sur le site du W3C.

Les types de données les plus simples (les chaînes de caractères) que permettaient les DTDs sont conservés, mais d'autres ont fait leur apparition. On pourra envisager, par exemple, dans un schéma décrivant un bon de commande, la déclaration d'un attribut quantite :

<xsd:attribute name="quantite" type="xsd:positiveInteger" use="required" default="1" />

... qui force la valeur de l'attribut à un être un entier positif. Un bon de commande XML suivant ce schéma, ayant une commande spécifiant quantite="-3" sera alors automatiquement refusé par le système.

(20)

5 / 9

c. Listes

Il également possible de créer une liste personnalisée, par « dérivation » de types existants. Par exemple :

<xsd:simpleType name="numéroDeTéléphone"> <xsd:list itemType="xsd:unsignedByte" /> </xsd:simpleType>

Un élément conforme à cette déclaration serait <téléphone>01 44 27 60 11</téléphone>.

d. Unions

Les listes et les types simples intégrés ne permettent pas de choisir le type de contenu d'un élément. On peut désirer, par exemple, qu'un type autorise soit un nombre, soit une chaîne de caractères particuliers. Il est possible de le faire à l'aide d'une déclaration d'union. Par exemple, sous réserve que le type simple numéroDeTéléphone ait été préalablement défini (voir précédemment), on peut déclarer...

<xsd:simpleType name="numéroDeTéléphoneMnémoTechnique"> <xsd:union memberTypes="xsd:string numéroDeTéléphone" /> </xsd:simpleType>

Les éléments suivants sont alors des "instances" valides de cette déclaration : <téléphone>18</téléphone>

<téléphone>Pompiers</téléphone>

3. Les types complexes a. Introduction

Un élément de type simple ne peut contenir pas de sous-élément. Il est nécessaire pour cela de le déclarer de type complexe. On peut alors déclarer des séquences d'éléments, des types de choix ou des contraintes d'occurences

b. Séquences d'éléments

Nous savons déjà comment, dans une DTD, nous pouvons déclarer un élément comme pouvant contenir une suite de sous-éléments dans un ordre déterminé. Il est bien sûr possible de faire de même avec un schéma.

On utilise pour ce faire l'élément xsd:sequence, qui reproduit l'opérateur , du langage DTD. Ainsi... <xsd:complexType name="typePersonne">

<xsd:sequence>

<xsd:element name="nom" type="xsd:string" /> <xsd:element name="prénom" type="xsd:string" />

<xsd:element name="dateDeNaissance" type="xsd:date" /> <xsd:element name="adresse" type="xsd:string" />

<xsd:element name="adresseElectronique" type="xsd:string" /> <xsd:element name="téléphone" type="numéroDeTéléphone" /> </xsd:sequence>

</xsd:complexType>

Salarié est composé de la séquence nom, prénom, dateDeNaissance, adresse, adresseElectronique, téléphone. (obligatoirement dans l’ordre).

c. Choix d'élément

On peut vouloir modifier la déclaration de type précédente en stipulant qu'on doive indiquer soit l'adresse d'une personne, soit son adresse électronique en utilisant l’élément xsd:choice :

<xsd:complexType name="typePersonne"> <sequence>

<xsd:element name="dateDeNaissance" type="xsd:date" /> <xsd:choice>

(21)

<xsd:element name="adresseElectronique" type="xsd:string" /> </xsd:choice>

</sequence>

<xsd:element name="téléphone" type="numéroDeTéléphone" /> </xsd:complexType>

Ce connecteur a donc les mêmes effets que l'opérateur | dans une DTD.

d. L'élément all

Cet élément est une nouveauté par rapport aux DTD. Il indique que les éléments enfants doivent apparaître une fois (ou pas du tout), mais dans n'importe quel ordre. Cet élément xsd:all doit être un enfant direct de l'élément xsd:complexType. Par exemple...

<xsd:complexType> <xsd:all>

<xsd:element name="dateDeNaissance" type="xsd:date" /> <xsd:element name="adresse" type="xsd:string" />

<xsd:element name="adresseElectronique" type="xsd:string" /> <xsd:element name="téléphone" type="numéroDeTéléphone" /> </xsd:all>

</xsd:complexType>

... indique que chacun de ces éléments peut apparaître une fois ou pas du tout (équivalent de l'opérateur ? dans une DTD), et que l'ordre des éléments n'a pas d'importance (cela n'a pas d'équivalent dans une DTD).

e. Indicateurs d'occurences

Dans une DTD, un indicateur d'occurence ne peut prendre que les valeurs 0, 1 ou l'infini. Dans XML Schema, les indicateurs d’occurrences sont exprimés via les attributs minOccurs et maxOccurs. La valeur autorisée pour minOccurs est un nombre entier positif; la valeur autorisée pour maxOccurs est un nombre entier positif ou la valeur prédéfinie unbounded, spécifiant que le nombre autorisé d’occurrences n’est pas borné. Les attributs minOccurs et maxOccurs peuvent être associés aux éléments

xsd:element ou aux constructeurs xsd:sequence, xsd:choice et xsd:all. La valeur par défaut des attributs minOccurs et maxOccurs est 1.

Le tableau suivant récapitule les possibilités :

Dans une DTD Valeur de minOccurs Valeur de maxOccurs

* ₀ unbounded

+ 1 (pas nécessaire, valeur par défaut) unbounded

? ₀ _{1 (pas nécessaire, valeur par défaut)}

rien 1 (pas nécessaire, valeur par défaut) 1 (pas nécessaire, valeur par défaut)

impossible nombre entier n quelconque nombre entier m quelconque supérieur ou égal à n Exemple :

<xsd:element name="recette"> <xsd:complexType>

<xsd:sequence>

<xsd:element name="titre" type="xsd:string"/>

<xsd:element name="commentaire" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>

<xsd:element name="ingredient" maxOccurs="unbounded"/> <xsd:element name="image" minOccurs="0"/>

</xsd:sequence> </xsd:complexType> </xsd:element>

(22)

7 / 9

f. Création de type complexe à partir de types simples

Il est possible également de créer un type complexe à partir d'un type simple.

On peut avoir besoin de définir un élément contenant une valeur simple, et possédant un attribut, comme <poids unite="kg">67</poids>, par exemple. Un tel élément ne peut pas être déclaré de type simple, car il contient un attribut. Il faut dériver un type complexe à partir du type simple positiveInteger :

<xsd:complexType name="typePoids"> <xsd:simpleContent>

<xsd:extension base="xsd:positiveInteger">

<xsd:attribute name="unite" type="xsd:string" /> </xsd:extension>

</xsd:simpleContent> </xsd:complexType>

L'élément xsd:simpleContent indique que le nouvel élément ne contient pas de sous-élément.

VI. Les dérivations

1. Introduction

Les types simples et complexes permettent déjà de faire plus de choses que les déclarations dans le langage DTD. Il est possible de raffiner leur déclaration de telle manière qu'ils soient une "restriction" ou une extension d'un type déjà existant, en vue de préciser un peu plus leur forme. Nous allons nous limiter dans ce cours d'initiation à la restriction des types simples.

2. Restriction de type a. Généralités

La dérivation par restriction permet de créer de nouveaux types simples à partir des types simples prédéfinis par le format XML Schema. On utilise pour ce faire des facettes, qui sont des contraintes supplémentaires appliquées à un type simple particulier.

Une facette permet de placer une contrainte sur l'ensemble des valeurs que peut prendre un type de base. Par exemple, on peut souhaiter créer un type simple, appelé MonEntier, limité aux valeurs comprises entre 0 et 99 inclus. On dérive ce type à partir du type simple prédéfini nonNegativeInteger, en utilisant la facette maxExclusive.

<xsd:simpleType name="monEntier">

<xsd:restriction base="nonNegativeInteger"> <xsd:maxExclusive value="100" />

</xsd:restriction> </xsd:simpleType>

Il existe un nombre important de facettes qui permettent de :

fixer, restreindre ou augmenter la longueur minimale ou maximale d'un type simple énumérer toutes les valeurs possibles d'un type

prendre en compte des expressions régulières

fixer la valeur minimale ou maximale d'un type (voir l'exemple ci-dessus) fixer la précision du type...

b. Exemples

Ici, le type de l’attribut difficulty est un type dérivé défini par le concepteur du schéma qui fait usage de la facette xsd:enumeration afin de restreindre le type prédéfini xsd:string.

<xsd:attribute name="difficulty" use="optional" default="difficult"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="easy"/> <xsd:enumeration value="medium"/> <xsd:enumeration value="difficult"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute>

(23)

Pour limiter la longueur d'une chaîne : <xsd:simpleType name="typeMotLangueFrancaise"> <xsd:restriction base="xsd:string"> <xsd:length value="21" /> </xsd:restriction> </xsd:simpleType>

Plus complexe, on peut utiliser des expressions régulières, qui permettent de spécifier quels sont les caractères autorisés, à l'aide de l'élément xsd:pattern. Par exemple...

<xsd:simpleType name="typeAdresseElectronique"> <xsd:restriction base="xsd:string">

<xsd:pattern value="(.)+@(.)+" /> </xsd:restriction>

</xsd:simpleType>

Dans cet exemple, (.)+ signifie que l'on peut mettre n'importe quel caractère au moins une fois, et qu'entre les deux chaînes doit impérativement apparaître le caractère @.

Un numéro ISBN est un référent international pour une publication. Il s'agit d'un numéro à 10 ou 13 chiffres. On peut le déclarer ainsi :

<xsd:simpleType name="typeISBN"> <xsd:restriction base="xsd:string"> <xsd:pattern value="[0-9]{10}" /> </xsd:restriction>

</xsd:simpleType>

Pour plus d’infos sur les facettes, voir W3C à l'adresse http://www.w3.org/TR/xmlschema-0/#SimpleTypeFacets.

VII. Diverses autres fonctionnalités

1. Inclusion de schémas

Un Schema XML a rapidement tendance à devenir rapidement suffisamment long pour que sa complexité apparente rebute l'œil humain. Il est alors plus raisonnable de le scinder en plusieurs morceaux, chacun chargé de définir précisément tel ou tel sous-domaine du schéma. Il est en effet possible d'inclure plusieurs schémas dans un seul, à l'aide de l'élément xsd:include. Cela offre de plus l'énorme avantage de modulariser un schéma, et donc de pouvoir sans difficulté importer certaines parties à partir de schémas déjà existants.

Supposons par exemple que nous ayons défini le schéma d'une bibliographie dans le cadre plus général de l'écriture d'un mémoire. Ce Schema XML est stocké à l'URL http://www.monsite.org/schemas/biblio.xsd. Nous avons besoin d'une bibliographie pour une autre aplication -par exemple, dresser la liste d'un ensemble de ressources pour un site Web de e-formation. Nous pouvons inclure le schéma précédemment écrit à l'aide de la commande...

<xsd:include schemaLocation="http://www.monsite.org/schemas/biblio.xsd" /> Il s'agit d'une sorte de « copier-coller » du contenu de la bibliographie dans le schéma en cours d'écriture. La seule condition est que le targetNameSpace soit le même dans le Schema XML inclus et dans le Schema XML importateur.

2. Documentation

XML Schema permet, outre l'utilisation des commentaires comme tout format XML, l'adjonction de documentation aux éléments.

La documentation à l'intention des lecteurs humains peut être définie dans des éléments xsd:documentation, tandis que les informations à l'intention de programmes doivent être incluses dans des éléments xsd:appinfo. Ces deux éléments doivent être placés dans un élément xsd:annotation. Ils disposent d'attributs optionnels : xml:lang et source, qui est une référence à une URI pouvant être

(24)

9 / 9

Les éléments xsd:annotation peuvent être ajoutés au début de la plupart des constructions.

V. Espaces de nom

1. Introduction

La notion d'espace de nom est complexe ; elle permet à un document XML quelconque d'utiliser les balises définies dans un schéma donné. Cette notion apparaît :

dans les feuilles de style XSL, où nous utilisions des éléments préfixés par xsl, après avoir écrit <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> dans un schéma, où nous utilisions des éléments préfixés par xsd, après avoir écrit <xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">.

Cela signifie que l'espace de nom auquel ces balises font référence, là où elles sont définies, est un schéma particulier que l'on peut consulter.

2. Comment lier un fichier XML à un schéma ?

Nous n'allons pas ici entrer dans les détails de la notion d'espace de nom, mais simplement apprendre à valider un document XML d'après un Schema XML. On utilise pour ce faire le préfixe xmlns.

Un schéma est en effet un document XML, et on trouve dans son élément racine l'attribut

xmlns:xsd="http://www.w3.org/2001/XMLSchema". Cela signifie que dans le document, tous les éléments commençant par xsd sont référencés à cette URL. Donc si on a déposé un schéma à l'adresse http://www.monsite.org/collection_schemas/biblio, on peut l'appeler par <xsd:biblio xmlns="http://www.monsite.org/collection_schemas/biblio">.

Dans le cas d'une référence locale, on fait référence au schéma dans le document XML en utilisant l'attribut noNamespaceSchemaLocation. Par exemple,

<biblio xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="biblio10.xsd">.

(25)

Mise en forme à l'aide de feuilles de style XSL

(XPath et XSLT)

I. Présentation

1. Introduction

XSL signifie eXtensive Stylesheet Langage, ou langage extensible de feuille de style. Cette abréviation recouvre en fait trois langages :

XPath désigne un moyen d'accéder à un nœud quelconque de l'arborescence d'un document XML à partir d'un autre nœud quelconque.

XSLT signifie eXtensible Stylesheet Langage Transformation.

XSL-FO signifie eXtensible Stylesheet Langage - Formating Objects, et désigne un langage permettant le contrôle de la mise en page finale de la transformation. Ce langage est particulièrement destiné à la production de contenus au format PDF.

Ce cours se limitera à aborder les deux premiers langages.

Le XSLT permet de transformer un document XML source en un autre qui peut être soit XML, HTML ou texte.

Le fonctionnement du XSL est fondé sur les manipulations de modèles (templates). Les éléments du document XML d'origine sont remplacés (ou légèrement modifiés) par ces modèles. Un modèle contient ainsi le texte (éléments, attributs, texte...) de remplacement d'un élément donné.

Tout élément pouvant être remplacé dans le fichier de sortie par tout type de contenu texte, XSL est un outil privilégié de production de fichiers HTML à partir de sources XML. Un fichier XSL étant un fichier XML, il doit respecter les normes de syntaxe de ce format.

2. Structure d'un document XSL

La structure de base d'un document XSL commence par un prologue, puis un élément

<xsl:stylesheet> pouvant contenir quelques attributs, notamment une déclaration d'espace de noms ainsi que le numéro de version. L'exemple suivant présente l'appel à cet élément tel que nous le

pratiquerons dans ce cours :

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

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

</xsl:stylesheet>

L'élément <xsl:stylesheet> est l'élément racine du document XSL. C'est lui qui contient tous les modèles, y compris celui qui est associé à la racine du document XML, modèle que l'on note

<xsl:template match="/">. L'attribut match="/" indique que ce modèle s'applique à la racine du document XML.

II. Exemples de mises en forme

1. Exemple simple

a. Introduction

Il est possible de traiter de manière simple un fichier XML contenant une information relativement linéaire. Ainsi, l'exemple déjà présenté d'une composition de bouteille d'eau, dans le cas d'une seule bouteille, se prête facilement à une simple mise en forme HTML.

b. Exemple

Exemple d'un document XML lié à une feuille de style XSL simple : <?xml version="1.0" encoding="ISO-8859-1"?>

<?xml-stylesheet type="text/xsl" href="bouteille1.xsl"?> <bouteille>

<marque>Cristaline</marque>

<composition>calcium 71mg/l, magnésium 5,5mg/l, chlorure 20mg/l, nitrate 1mg/l, traces de fer.</composition>

(26)

2 / 16 XPath_XSLT <departement>Loiret</departement> </source> <code_barre>3274080005003</code_barre> <contenance>150cl</contenance> <ph>7,45</ph> </bouteille>

Et voici la feuille de style XSL associée :

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

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

<title>Exemple de sortie HTML</title>

<body>

<h1>Bouteille de marque <xsl:value-of select="bouteille/marque" /></h1> <h2>Composition:</h2>

<p><xsl:value-of select="bouteille/composition" /></p> <h2>Lieu d'origine:</h2>

<p>Ville de <b><xsl:value-of select="bouteille/source/ville" /></b>, dans le département <b><xsl:value-of select="bouteille/source/departement" /></b></p> <h2>Autres informations</h2>

<ul>

<li>Contenance: <xsl:value-of select="bouteille/contenance" /></li> <li>pH: <xsl:value-of select="bouteille/ph" /></li>

</ul> </body> </html>

</xsl:template> </xsl:stylesheet>

III. Les expressions de sélection

1. Introduction

Connues en anglais sous le nom de XSL patterns, les expressions de sélection sont des chaînes de caractères qui permettent de sélectionner des nœuds dans un document source. Il est également possible d'utiliser une syntaxe spéciale, appelée XPath, qui permet, en se fondant sur la structure arborescente du document XML (le Document Object Model -DOM), de faire référence à des éléments et/ou des attributs.

2. Sélection d'éléments et d'attributs a. Sélection d'élément, syntaxe de base

L'exemple le plus simple d'expression de sélection est le nom d'un type d'élément. Cette expression sélectionne tous les éléments du type précisé descendant ou ancêtre d'un nœud donné. Exemple :

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

L'opérateur / permet de définir le chemin d'accès aux éléments à sélectionner, et donc leur parenté. Par exemple, section/paragraphe sélectionne les éléments section du nœud courant et pour chaque élément section, sélectionne les éléments paragraphe qu'il contient. En d'autres termes, cette expression sélectionne les petits-fils paragraphe du nœud courant qui ont pour père un nœud section.

Un nom d'élément peut être remplacé par * dans une expression. Par exemple, */paragraphe sélectionne tous les petits-fils paragraphe quel que soit leur père.

L'utilisation de // permet d'appliquer la recherche aux descendants et non pas seulement aux fils directs. Par exemple, section//paragraphe sélectionne tous les éléments paragraphe descendant d'un élément section fils direct du nœud courant.

Le caractère . sélectionne le nœud courant. Par exemple, .//paragraphe sélectionne tous les descendants paragraphe du nœud courant.

(27)

La chaîne .. sélectionne le père du nœud courant. Par exemple, ../paragraphe sélectionne tous les nœuds paragraphe frères du nœud courant.

b. Sélection d'élément, appel de fonctions

L'expression comment() sélectionne tous les nœuds commentaires fils du nœud courant.

L'expression text() sélectionne tous les nœuds fils du nœud courant, ne contenant que du texte. L'expression node() sélectionne tous les nœuds fils du nœud courant.

L'expression id("UnIdentifiant") sélectionne l'élément, normalement unique, qui a un attribut attr de type ID (cf. le paragraphe "Déclaration d'attribut de type ID") valant "UnIdentifiant".

c. Sélection d'élément et DOM

Il est également possible de « naviguer » dans les branches de l'arborescence du document XML, en utilisant les ressources du DOM. Différents types de syntaxes sont possibles, fondées sur une expression de la forme Element[Expression]. Par exemple :

elt[i] où i est un nombre entier désigne le i-ème descendant direct d'un même parent ayant le nom indiqué. Par exemple, paragraphe[3] désigne le 3ème enfant de l'élément courant, portant le nom paragraphe. Attention, la numérotation commence à 1 et non à 0.

elt[position()>i] où i est un nombre entier sélectionne tous les éléments précédés d'au moins i éléments de même nom comme descendants du même parent. Par exemple,

paragraphe[position()>5] sélectionne tous les éléments paragraphe dont le numéro d'ordre est strictement supérieur à 5.

elt[position() mod 2=1] sélectionne tout élément qui est un descendant impair.

elt[souselt] sélectionne tout élément elt qui a au moins un descendant souselt (à ne pas confondre avec elt/souselt, qui sélectionne tout élément souselt ayant pour parent elt...). elt[first-of-any()] sélectionne le premier élément elt fils de l'élément courant.

elt[last-of-any()] sélectionne le dernier élément elt fils de l'élément courant.

elt[first-of-type()] sélectionne l'élément elt fils de l'élément courant, s'il est premier de son type. Considérons l'exemple suivant. L'élément elt peut contenir des nœuds de type texte elt1 et elt2 dans n'importe quel ordre. On cherche à évaluer l'expression elt2[first-of-type()]. Deux cas se présentent : soit elt commence par au moins un élément elt1, avec éventuellement un élément elt2 ensuite, soit il commence par un élément elt2. L'expression ne sélectionne le premier élément elt2 que dans le second cas, où il n'est précédé par aucun élément de même type. elt[last-of-type()] sélectionne de même l'élément elt fils de l'élément courant, s'il est le

dernier de son type.

Par exemple, l'expression section/paragraphe[last-of-type() and first-of-type()] sélectionne les éléments paragraphe fils uniques dont le père est un élément section ; l'expression

section/paragraphe[last-of-any() and first-of-any()] sélectionne les éléments paragraphe

dont le père est un élément section qui ne contient qu'un seul élément paragraphe.

La fonction ancestor() permet la sélection d'un ancêtre du nœud courant. Elle reçoit en argument une expression de sélection et recherche le premier ancêtre du nom correspondant à la sélection. Par exemple, ancestor(chapitre)/titre sélectionne l'élément titre du chapitre contenant l'élément courant.

d. Sélection d'attributs

Les attributs d'un élément sont sélectionnés en faisant précéder leur nom par le caractère @. Les règles relatives à la sélection des éléments s'appliquent également aux attributs :

section[@titre] sélectionne les éléments section qui ont un attribut titre.

section[@titre="Introduction"] sélectionne les éléments section dont l'attribut titre a pour valeur Introduction.

Si l'on veut afficher le contenu de l'attribut, on le fait précéder du caractère /. Par exemple, <xsl:value-of select="paragraphe/@titre" /> permet l'affichage du titre de l'élément paragraphe fils de

(28)

4 / 16 XPath_XSLT

e. Opérateurs logiques

Les opérateurs logiques not(), and et or peuvent être utilisés, comme par exemple

section[not(@titre)], qui sélectionne les éléments section qui n'ont pas d'attribut titre. Attention : lorsque, dans le schéma XML par exemple, l'attribut est défini comme ayant une valeur par défaut, même s'il n'est pas explicité dans le document XML, il est considéré comme existant.

II. XPath

1. Introduction

Comme son nom l'indique, XPath est une spécification fondée sur l'utilisation de chemin d'accès permettant de se déplacer au sein du document XML. Dans ce but, un certain nombre de fonctions ont été définies. Elles permettent de traiter les chaînes de caractères, les booléens et les nombres.

Le XPath établit un arbre de nœuds correspondant au document XML. Les types de nœuds peuvent être différents : nœud d'élément, nœud d'attribut et nœud de texte. En vue d'une utilisation plus aisée, le XPath comprend un mécanisme qui associe à tous ces types une chaîne de caractères.

La syntaxe de base du XPath est fondée sur l'utilisation d'expressions. Une expression peut s'appliquer à quatre types d'objets :

un ensemble non ordonné de nœuds ; une valeur booléenne (vrai ou faux) ; un nombre en virgule flottante ; une chaîne de caractères.

Chaque évaluation d'expression dépend du contexte courant. Une des expressions les plus importantes dans le standard XPath est le chemin de localisation. Cette expression sélectionne un ensemble de nœuds à partir d'un nœud contextuel.

2. Chemin de localisation a. Introduction

Un chemin de localisation peut être de type absolu ou relatif.

Dans le cas où il est de type absolu, il commence toujours par le signe / indiquant la racine du document XML ;

Dans le cas où il est de type relatif, le nœud de départ est le nœud contextuel courant.

La syntaxe de composition d'un chemin de localisation peut être de type abrégé ou non abrégé. Toute syntaxe non abrégée ne trouve pas forcément d'équivalenct en syntaxe abrégée.

Un chemin de localisation est composé de trois parties :

un axe, définissant le sens de la relation entre le nœud courant et le jeu de nœuds à localiser; un nœud spécifiant le type de nœud à localiser;

0 à n prédicats permettant d'affiner la recherche sur le jeu de nœuds à récupérer.

Par exemple, dans le chemin child::section[position()=1], child est le nom de l'axe, section le type de nœud à localiser (élément ou attribut) et [position()=1] est un prédicat. Les doubles :: sont obligatoires.

La syntaxe d'une localisation s'analyse de gauche à droite. Dans notre cas, on cherche dans le nœud courant, un nœud section qui est le premier nœud de son type.

b. Axes

child : contient les enfants directs du nœud contextuel.

descendant : contient les descendants du nœud contextuel. Un descendant peut être un enfant, un petit-enfant...

parent : contient le parent du nœud contextuel, s'il y en a un.

ancestor : contient les ancêtres du nœud contextuel. Cela comprend son père, le père de son père... Cet axe contient toujours le nœud racine, excepté dans le cas où le nœud contextuel serait lui-même le nœud racine.

following-sibling : contient tous les nœuds cibles du nœud contextuel. Dans le cas où ce nœud est un attribut ou un espace de noms, la cible suivante est vide.

preceding-sibling : contient tous les prédécesseurs du nœud contextuel ; si le nœud contextuel est un attribut ou un espace de noms, la cible précédente est vide.

(29)

following : contient tous les nœuds du même nom que le nœud contextuel situés après le nœud contextuel dans l'ordre du document, à l'exclusion de tout descendant, des attributs et des espaces de noms.

preceding : contient tous les nœuds du même nom que le nœud contextuel situés avant lui dans l'ordre du document, à l'exclusion de tout descendant, des attributs et des espaces de noms.

attribute : contient les attributs du nœud contextuel ; l'axe est vide quand le nœud n'est pas un élément. namespace : contient tous les nœuds des espaces de noms du nœud contextuel ; l'axe est vide quand le nœud contextuel n'est pas un élément.

self : contient seulement le nœud contextuel.

attribute : les attributs du noeud

descendant-or-self : contient le nœud contextuel et ses descendants.

ancestor-or-self : contient le nœud contextuel et ses ancêtres. Cet axe contiendra toujours le nœud racine.

c. Prédicats

Le contenu d'un prédicat est une prédiction. Chaque expression est évaluée et le résultat est un booléen. Par exemple, section[3] est équivalent à section[position()=3].

Ces deux expressions sont équivalentes : chacune d'entre elles produit un booléen. Dans le premier cas, il n'y a pas de test, on sélectionne simplement le troisième élément, l'expression est obligatoirement vraie. Dans le second cas, un test est effectué par rapport à la position de l'élément section ; lorsque la position sera égale à 3, l'expression sera vraie.

d. Syntaxe non abrégée

Cette syntaxe va être présentée par plusieurs exemples... Les parties qui dépendent du fichier XML analysé sont écrites de cette manière.

child::para : sélectionne l'élément para enfant du nœud contextuel.

child::* : sélectionne tous les éléments enfants du nœud contextuel.

child::text() : sélectionne tous les nœuds de type texte du nœud contextuel.

child::node() : sélectionne tous les enfants du nœud contextuel, quel que soit leur type. attribute::name : sélectionne tous les attributs name du nœud contextuel.

attribute::* : sélectionne tous les attributs du nœud contextuel.

descendant::para : sélectionne tous les descendants para du nœud contextuel.

ancestor::div : sélectionne tous les ancêtres div du nœud contextuel.

ancestor-or-self::div : sélectionne tous les ancêtres div du nœud contextuel et le nœud contextuel

lui-même si c'est un div.

descendant-or-self::para : sélectionne tous les descendants para du nœud contextuel et le nœud

contextuel lui-même si c'est un para.

self::para : sélectionne le nœud contextuel si c'est un élément para, et rien dans le cas contraire.

child::chapitre/descendant::para : sélectionne les descendants para de l'élément chapitre enfant

du nœud contextuel.

child::*/child::para : sélectionne tous les petits-enfants para du nœud contextuel.

/child:: : sélectionne l'élément racine du document.

/descendant::para : sélectionne tous les éléments para descendants du document contenant le nœud

contextuel.

/descendant::olist/child::item : sélectionne tous les éléments item qui ont un parent olist et qui

sont dans le même document que le nœud contextuel.

child::para[position()=1] : sélectionne le premier enfant para du nœud contextuel.

child::para[position()=last()] : sélectionne le dernier enfant para du nœud contextuel.

child::para[position()=last()-1] : sélectionne l'avant-dernier enfant para du nœud contextuel.

child::para[position()1] : sélectionne tous les enfants para du nœud contextuel autres que le

premier.