Cours gratuits » Cours informatique » Cours développement web » Cours XML » Supports de cours sur les Bases du langage XML

Supports de cours sur les Bases du langage XML

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

SUPPORTS DE COURS SUR

LE LANGAGE XML

1.COURS D'INTRODUCTION A XML

GENERALITES

XML n'est pas un langage à proprement parler comme peut l'être HTML : XML est une famille de langages ayant en commun le respect de certaines règles. Nous allons voir que là où HTML est simple, bien défini et non contraignant à la fois, XML est extensible et rigoureux.

En pratique, un fichier XML est un simple fichier texte, contenant des balises. La particularité de XML est qu'aucune balise n'est prédéfinie : c'est au concepteur de définir les balises qui ont du sens pour lui.

Ces éléments permettent d'ores et déjà de dégager les intérêts de XML :

•  Les documents sont faciles à compléter ou à modifier, il suffit d'un simple éditeur de texte parce qu'il s'agit d

e fichiers texte avec un format connu et simple ;

•  l'aspect textuel autorise également des recherches de base, soit à travers l'éditeur de texte, soit à l'aide des commandes de base du système d'exploitation (grep sous Linux) ;

•  comme il s'agit d'un format ouvert, des outils génériques sont disponibles et directement utilisable, du parser (lecture et chargement du fichier en mémoire) à la transformation automatique avec XSLT ;

•  l'utilisateur peut différencier le fond de la forme, ne travailler que sur la structure logique du document sans se soucier de sa présentation ; cela car XML est clairement avant tout une solution de stockage et pas de publication.

Sur l'aspect stockage et recherche, le langage XML semble s'opposer aux bases de données. On l'a vu XML permet la saisie et les modifications sans autre logiciel qu'un traitement de texte. Même une modification du schéma est facile à gérer en XML, au moins sur un unique document XML. De plus, XML ne nécessite pas dans un premier temps l'apprentissage d'un langage comme SQL. Cependant, l'efficacité des recherches reste l'avantage des bases de données.

XML est donc un standard ouvert et universel. On le trouve aujourd'hui dans les domaines les plus variés :

•  édition (description d'ouvrage avec DocBook),

•  graphisme (format SVG),

•  mathématiques (formules avec MathML),

•  chimie (CML permet la description de molécules en 3D),

•  musique (partition musicale avec MusicML), ? etc.

UN DOCUMENT XML EN PRATIQUE

On a dit qu'un document XML était essentiellement du texte. Au milieu de ce texte, on va pouvoir trouver des éléments (ou balises), des attributs associés aux éléments et enfin des entités.

Les règles que doit suivre un document XML sont les suivantes (si toutes ces contraintes sont respectées, le document XML est dit bien formé) :

•  la première ligne doit être de la forme <?xml version="1.0" encoding="iso-8859-1" ?> ; les deux attributs spécifient la version de

XML utilisée (1.0 ou 1.1) et le codage des caractères (utf-8 par défaut)

;

•  les balises sont repérées par les caractères < et >, on écrira par exemple <balise>contenu</balise> ; la balise ouvrante peut contenir des attributs ;

•  toujours donner une valeur aux attributs, en suivant la syntaxe<balise attr="val"> (les guillemets sont obligatoires, les attributs ne sont pas répétés dans la balise fermante) ;

•  les entités sont systématiquement de la forme &nom; ;

•  fermer toutes les balises ouvertes ; une balise sans contenu pourra être ouverte et immédiatement fermée en faisant suivre son nom d'un slash, par exemple avec la balise br(passage à la ligne en HTML) : <br

/> ;

•  veiller à l'ordre de fermeture des balises : la première ouverte est toujours la dernière fermée ;

•  respecter la casse : on peut utiliser majuscules et minuscules dans les noms de balises mais une fois qu'un nom d'élément a été fixé, il faut s'y tenir, la balise <cv> ne pourra être fermée ni par </Cv> ni par </CV> ;

•  ne pas utiliser de caractères réservés à XML dans le texte du document : <, > et & ; ces caractères pourront être respectivement obtenues à l'aide des entités &lt;, &gt; et&amp; ;

•  les noms de balises et d'attributs doivent être des noms XML :

o    le premier caractère est une lettre quelconque ou un _(underscore ou tiret bas) ;

o    les caractères suivants peuvent être des lettres, des chiffres, des tirets bas

(_), des traits d'union (-) ou des points (.) ; o il n'y a pas de limitation sur la longueur d'un nom XML.

À noter que cette dernière règle interdit à un nom de balise de commencer par un chiffre. Cependant, la liberté pour choisir un nom d'élément reste grande car on peut y faire figurer n'importe quelle lettre... or, le codage privilégié dans les documents et applications XML est l'UTF-8 qui contient les alphabets latin, arabe, japonais, etc. Plus spécifiquement, on n'hésitera pas à utiliser des lettres accentuées dans les noms d'éléments.

Finalement, voici un exemple de document XML bien formé :

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

<!-- commentaire : voici mon curriculum vitae -->

<cv>

<!-- commentaire : état civil -->

<identité naissance="1980">

<nom>Moustique</nom>

<prénom>Jules</prénom>

<prénom>Édouard</prénom>

<nationalité>grolandaise</nationalité>

</identité>

<!-- commentaire : mes diplômes maintenant -->

<diplome année="2005" intitulé="Master ID" mention="TB" />

<diplome année="2003" intitulé="Licence " mention="AB" /> </cv>

TECHNOLOGIES LIEES

La simplicité et l'ouverture de XML fait qu'un document XML peut facilement être modifier par un être humain, sans outil spécifique.

La rigueur de XML (sensibilité à la casse, guillemets obligatoires pour encadrer les valeurs des attributs, fermeture systématique des balises, etc.) autorise des traitements automatiques, qui pourront être partagés par tous les langages XML.

•  contraindre un langage XML : DTD, Schémas, Relax NG ;

•  mise en page avec CSS 

<?xml-stylesheet type="text/css">

href=""

en particulier utilisation de la propriété display (block ouinline) ;

•  interrogration, requêtes sur un document XML avec XPath ou XQuery ;

•  transformation de documents avec XSLT ;

•  mise en page avec XSL-FO (Formatting Objects) et un programme comme FOP).

L'ECRITURE DE DTD

2.

COURS SUR L'ECRITURE DE DTD

 

MOTIVATIONS

Nous avons vu comment il était possible d'écrire du XML en respectant ses règles de syntaxe et d'obtenir ainsi un document XMLbien formé.

Nous allons maintenant décrire comment spécifier des contraintes plus précises et propres à notre langage XML. Cela va prendre ici la forme d'une DTD (Définition de Type de Document).

On dira alors qu'en plus d'être bien formé, le document est valide par rapport à une certaine DTD.

Cette spécification d'une grammaire pour un langage et la possibilité de tester automatiquement son respect par un document donné, présentent les avantages suivants :

•  faciliter l'échange et la mise en commun de documents produits par des rédacteurs différents ;

•  aider les développeurs qui conçoivent des outils automatiques pour traiter les documents respectant la même DTD.

LIER UN FICHIER XML A UNE DTD

DTD INTERNE

Dans ce cas, la spécification de la DTD arrive dans l'entête du document XML : on trouve d'abord le mot-clef DOCTYPE suivi de l'élément servant de racine au document et enfin la DTD elle-même entre crochets :

<?xml version="1.0" encoding="iso-8859-1" ?> <!DOCTYPE cv [ .

.

.

]>

<cv> .

.

.

</cv>

DTD EXTERNE

Cette fois, la DTD est détachée dans un fichier séparé, on se contente d'y faire référence dans l'entête du document XML. On retrouve le mot-clef DOCTYPE suivi de l'élément servant de racine, puis le mot-clef SYSTEMsuivi d'une URI menant au fichier DTD.

À noter également que la première ligne doit faire apparaître l'attributstandalone avec la valeur no.

<?xml version="1.0" encoding="iso-8859-1" standalone="no" ?>

<!DOCTYPE cv SYSTEM ""> <cv> .

.

.

</cv>

À noter que, sans toucher au document XML, il est possible de faire le lien au moment de la validation. Par exemple, avec xmllint, on écrira :

xmllint --dtdvalid --noout

DTD MIXTE

Enfin, il est possible de mélanger les deux notations pour avoir une partie de la DTD dans un fichier séparé et une autre partie embarquée dans le document XML

:

<?xml version="1.0" encoding="iso-8859-1" standalone="no" ?> <!DOCTYPE cv SYSTEM "" [ .

.

.

]>

<cv> .

.

.

</cv>

DEFINIR LES ELEMENTS ET LEURS CONTENUS

Il s'agit ici de déclarer les éléments autorisés à apparaître dans le document, ainsi que leurs imbrications possibles. La forme générale est la suivante :

<!ELEMENT nom_element modèle_de_contenu>

Les noms des éléments (comme ceux des attributs) doivent être desnoms XML :

•  le premier caractère est une lettre quelconque ou un _(underscore ou tiret bas) ;

•  les caractères suivants peuvent être des lettres, des chiffres, des tirets bas (_), des traits d'union (-) ou des points (.) ;

•  il n'y a pas de limitation sur la longueur d'un nom XML.

Nous passons maintenant en revue les différents modèles de contenu utilisables dans les DTD.

CONTENU PUREMENT TEXTUEL

Si l'élément peut contenir du texte brut mais pas de nouvelles balises, on utilisera le modèle de contenu PCDATA :

<!ELEMENT téléphone (#PCDATA)>

Aucune balise n'est donc tolérée dans ce type de contenu mais, par contre, il est possible d'y utiliser des entités.

SOUS-ELEMENTS

Ici, on va lister les sous-éléments pouvant apparaître dans le contenu, par exemple :

<!ELEMENT identité (prénom,nom)>

indique que l'élément identité doit contenir, dans l'ordre, un élémentprénom, un

élément nom, et rien d'autre.

Il est possible de moduler le nombre d'apparitions d'un sous-élément en utilisant des quantifieurs après les noms d'éléments. Les quantifieurs utilisables dans les DTD sont :

? ? : 0 ou 1 fois ; ? * : 0, 1 ou plus ; ? + : 1 ou plus.

L'exemple suivant indique que l'élément identité doit contenir, toujours en respectant l'ordre, un ou plusieurs éléments prénom, un élément surnom facultatif et exactement un élément nom :

<!ELEMENT identité (prénom+,surnom?,nom)>

ALTERNATIVES

Il est également possible de définir les sous-éléments qui peuvent apparaître de manière exclusive : si c'est l'un, ça n'est pas les autres. Dans l'exemple cidessous, une expérience professionnelle peut être soit unemploi, soit un stage :

<!ELEMENT expérience (stage|emploi)>

COMBINAISONS

Enfin, il est possible de combiner les syntaxes vues précédemment :

<!ELEMENT diplôme ( (intitulé,année) |

(année,compétences,stage?)+ )>

Dans ce cas, un diplôme est :

•  soit l'intitulé du diplôme et l'année d'obtention ;

•  soit une suite d'année, avec les compétences acquises cette année là, éventuellement validées par un stage.

CONTENU MIXTE

Une possibilité intéressante est de pouvoir mixer du texte brut avec des balises sans mettre plus de contraintes sur l'ordre et le nombre d'apparitions de ces balises. Cela se fait avec une alternative entre un contenu de type PCDATA et des sous-éléments, cette alternative pouvant se répéter plusieurs fois :

<!ELEMENT parcours (#PCDATA | diplôme)*>

Ici, on a un élément parcours qui a un contenu mixte : du texte pouvant contenir un nombre quelconque de sous-éléments diplôme.

CONTENU VIDE

Un élément peut également n'avoir aucun contenu, comme c'est le cas par exemple de la balise br (retour à la ligne en HTML). Cela se précise dans la DTD de la manière suivante :

<!ELEMENT br EMPTY>

Une telle balise sera donc ouverte et immédiatement refermée avec la notation suivante : <br />.

CONTENU QUELCONQUE

On termine avec la possibilité d'autoriser n'importe quel contenu à apparaître dans un élément.

<!ELEMENT mavie ANY>

Dans ce cas, l'élément mavie pourra contenir du texte brut mélangé avec toute balise définie dans la DTD, dans n'importe quel ordre, autant de fois que l'on veut.

Ce modèle de contenu est en contradiction avec l'esprit des DTD, lesquelles visent plutôt à restreindre au maximum le rédacteur. Une utilisation cependant pratique du ANY intervient lors de la rédaction d'une DTD alors que les documents XML sont déjà existants : dans ce cas, on définit les éléments de plus haut niveau en indiquant ANY pour leurs contenus, si les documents sont valides, on reprend la DTD en affinant le contenu de chacun des éléments, etc.

UN EXEMPLE SIMPLE ET COMPLET

Une DTD que l'on enregistre dans un fichier nommé :

<!ELEMENT liste_livres (livre+)>

<!ELEMENT livre (titre,auteur+,éditeur,description?,prix)>

<!ELEMENT titre (#PCDATA)>

<!ELEMENT auteur (#PCDATA)>

<!ELEMENT éditeur (#PCDATA)>

<!ELEMENT description (#PCDATA)> <!ELEMENT prix (#PCDATA)>

et un fichier XML la respectant :

<?xml version="1.0" encoding="iso-8859-1" standalone="no" ?>

<!DOCTYPE liste_livres SYSTEM "">

<liste_livres>

<livre>

<titre>Comprendre XSLT</titre>

<auteur>Bernd Amann</auteur>

<auteur>Philippe Rigaux</auteur>

<éditeur>O'Reilly</éditeur>

<description>

Le livre suit une double démarche de présentation des aspects les plus simples, puis, progressivement, les plus complexes du langage XSLT, et d'application des mécanismes de ce langage à des cas concrets d'utilisation. Il débute par un chapitre introductif en forme d'étude de cas qui propose, sur une application de type "Officiel des spectacles" adaptée au

Web, une déclinaison des différents thèmes couverts.

</description>

<prix>33 euros</prix>

</livre>

<livre>

<titre>Learning XML</titre>

<auteur>Erik T. Ray</auteur>

<éditeur>O'Reilly</éditeur>

<prix>40 dollars</prix>

</livre>

</liste_livres>

DEFINIR LES ATTRIBUTS

La syntaxe des DTD utilise cette fois le mot ATTLIST, suivi du nom de l'élément concerné, suivi de la liste de ses attributs : pour chacun, on trouvera son nom, son type et son caractère optionnel ou non.

Comme nous l'avons déjà indiqué, les noms des attributs doivent être des noms XML :

•  le premier caractère est une lettre quelconque ou un _(underscore ou tiret bas) ;

•  les caractères suivants peuvent être des lettres, des chiffres, des tirets bas (_), des traits d'union (-) ou des points (.) ; ? il n'y a pas de limitation sur la longueur d'un nom XML.

Une déclaration d'attributs typique aura la forme suivante :

<!ATTLIST identité prénom CDATA #REQUIRED                    nom    CDATA #REQUIRED                    surnom CDATA #IMPLIED>

Dans ce cas, l'élément identité possède trois attributs prénom, nom et surnom. Les deux premiers sont obligatoires (REQUIRED) et le dernier est optionnel (IMPLIED). À noter également la possibilité pour un attribut d'être FIXED, c'est-à-dire de prendre systématiquement la même valeur.

Nous passons maintenant en revue les différents types d'attributs.

CDATA

C'est le type le plus général, il permet de saisir un texte quelconque pour un attribut de ce type. Il est même possible d'utiliser ici les caractères habituellement réservés à XML : <, > et &.

NMTOKEN

Il s'agit ici un nom XML mais sans restriction sur le premier caractère (qui peut donc être un chiffre). Une contrainte essentielle est donc qu'un attribut de ce type ne contiendra pas d'espace.

Par exemple, un code postal pourra être déclaré de ce type :

<!ATTLIST ville nom  CDATA #REQUIRED                 code NMTOKEN #REQUIRED>

NMTOKENS

Une suite de NMTOKEN, séparés par des espaces.

ÉNUMERATION

Dans ce cas, l'attribut ne peut prendre qu'un nombre fini de valeurs et l'on en donne la liste exhaustive, ces valeurs étant séparées par des |.

<!ATTLIST date jour (lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche)

#REQUIRED

               num   NMTOKEN #REQUIRED                mois  NMTOKEN #REQUIRED                année NMTOKEN #REQUIRED>

ID

Il doit s'agir d'un nom XML qui identifie de manière unique l'élément. Autrement dit, une valeur qui apparaît dans un tel attribut ne peut pas apparaître une seconde fois dans le même document.

<!ATTLIST diplôme intitulé CDATA #REQUIRED                   code     ID    #REQUIRED>

Cette notion est tout à fait comparable à la clef primaire d'une table dans une base de données. Cependant, il faut garder à l'esprit qu'un ID ne peut pas être un nombre (car la valeur d'un ID doit être un nom XML).

IDREF

Un attribut de type IDREF doit contenir une valeur utilisée comme IDailleurs dans le document.

<!ATTLIST stage entreprise CDATA #REQUIRED                 diplôme    IDREF #REQUIRED>

IDREFS

Une suite de IDREF, séparées par des espaces.

ENTITY

La valeur d'un attribut de ce type doit être une entité définie dans la DTD (voir section suivante pour la définition des entités).

ENTITIES

Une suite de ENTITY, séparées par des espaces.

DEFINIR LES ENTITES

Intuitivement, il s'agit de définir des raccourcis (ou des alias) qui seront utilisables dans les documents XML liés à la DTD. Certaines entités sont déjà définies en XML : &lt; (<), &gt; (>),&amp; (&), &quot; ("), et &apos; (').

ENTITES GENERALES

Le mot ENTITY suivi du nom de l'entité, puis de sa valeur entre guillemets ou apostrophes.

<!ENTITY ac "anticonstitutionnellement">

Cette déclaration permettra d'utiliser &ac; dans le document XML associé à la DTD.

La valeur de l'entité peut contenir du texte, des balises et des entités (le code XML ainsi défini doit être bien formé). Par exemple,

<!ENTITY piedpage '<hr />

<p>

Copyright 2005, dernière mise à jour octobre 2005. </p>'>

ENTITES GENERALES EXTERNES

Si le code associé à une entité devient très important, il peut être intéressant de le détacher dans un fichier à part, ce que permet la syntaxe suivante :

<!ENTITY piedpage SYSTEM "">

Dans ce cas, le fichier doit être un fichier XML bien formé (première ligne de déclaration de la version XML et du codage utilisé, fermeture systématique des balises ouvertes, etc.).

ENTITES GENERALES EXTERNES NON PARSEES

Enfin, il y a le cas où le fichier externe représenté par l'entité ne contient pas du XML et ne doit donc pas être parcouru par les applications traitant le document.

<!NOTATION jpeg SYSTEM "image/jpeg">

<!ENTITY maphoto SYSTEM "" NDATA jpeg>

Ici, en plus du fichier externe, on trouve NDATA pour Notation Data etjpeg faisant référence à une NOTATION définie précédemment. LaNOTATION doit permettre à l'application de traiter le fichier externe : il peut s'agir d'un type MIME comme ici ou d'une commande à exécuter.

Une telle entité pourra apparaître comme valeur d'un attribut défini avec le type ENTITY.

INTEGRER LES ENTITES

Naturellement, les entités définies dans la DTD et utilisées dans le document XML devront tôt ou tard être remplacées par leurs véritables valeurs

Certains navigateurs opèrent ce remplacement lorsque l'on les utilise pour visualiser ce document XML. Ca n'est pas le cas de Firefox par exemple qui choisit de ne pas remplacer les entités et cela pour des raisons de sécurité.

Un moyen de tester les entités est d'utiliser xmllint :

xmllint --valid --noent

on charge la dtd avec --valid et on demande la substitution des entités avec -noent.

ENTITES PARAMETRES

Ce type d'entité permet d'éviter de répéter les mêmes informations. Par exemple, on donnera toujours le nom et le prénom d'une personne, quel que soit son statut dans le document :

<!ELEMENT identité (nom,prénom,naissance)>

<!ELEMENT enseignant (nom,prénom)>

L'utilisation d'une entité paramètre comme suit permet de ne pas répéter et autorise à enrichir ultérieurement la description d'une personne :

<!ENTITY % elements_personne "nom,prénom">

<!ELEMENT identité (%elements_personne;,naissance)>

<!ELEMENT enseignant (%elements_personne)>

DTD MODULAIRES

Des instructions (INCLUDE et IGNORE) permettent de prendre en compte un bloc de la DTD, ou de l'ignorer. La syntaxe est la suivante :

<![IGNORE[

<!ELEMENT personne (nom,prénom)>

<!ELEMENT nom (#PCDATA)>

<!ELEMENT prénom (#PCDATA)>

]]>

<![INCLUDE[

<!ELEMENT entreprise (dénomination,taille)>

<!ELEMENT dénomination (#PCDATA)>

<!ELEMENT taille (#PCDATA)>

]]>

Ce mécanisme devient puissant avec l'utilisation conjointe d'entitésparamètres.

<!ENTITY % bloc_personnes "INCLUDE">

<!ENTITY % bloc_entreprises "IGNORE">

<![%bloc_personnes;[

<!ELEMENT personne (nom,prénom)>

<!ELEMENT nom (#PCDATA)>

<!ELEMENT prénom (#PCDATA)>

]]>

<![%bloc_entreprises[

<!ELEMENT entreprise (dénomination,taille)>

<!ELEMENT dénomination (#PCDATA)>

<!ELEMENT taille (#PCDATA)>

]]>

Il est notable que ce choix ait été fait par le W3C pour définir laDTD duXHTML.

BILAN SUR LES DTD

Les reproches suivants sont systématiquement faits aux DTD :

•  l'élément racine n'est pas spécifié pas dans la DTD ; un document peut être valide en utilisant n'importe quelle balise de la DTD comme racine

;


le nombre d'apparitions d'un élément ne peut pas être contraint précisément, puisque l'on ne dispose que des quantifieurs ?, * et +, on aimerait pouvoir dire qu'un élément doit apparaître plus de 2 fois mais toujours moins de 5 ;

•  on ne dispose pas de types pour les contenus des attributs et des éléments (nom, date, code postal, numéro de téléphone, url, adresse mail, etc.) ;

•  on ne peut pas contraindre la forme de ces contenus (entre 5 et 20 caractères, contenant un signe @, etc. ) ;

•  enfin, le langage utilisé pour définir une DTD n'est pas un langage XML !

Pour palier à ces manques, d'autres propositions ont été faites, permettant elles aussi de spécifier un langage XML, citons les XML Schema et Relax NG.

3. COURS SUR L'ECRITURE DE XML SCHEMAS

DTD VERSUS XML SCHEMA

Les DTD :

•  types pauvres, peu de contraintes sur les contenus

•  nombre d'apparitions d'un élément à choisir entre 0 et 1

•  pas de gestion des espaces de noms

•  pas un format XML

Les schémas :

•  utilisation et définition de types, contraintes sur les contenus

•  possibilité de définir précisément le nombre d'apparitions d'un élément

•  espaces de noms supportés

•  format XML, parsable facilement

LA BASE PRATIQUE

Le fichier XML :

<racine

   xmlns:xsi="; xsi:noNamespaceSchemaLocation="">

        .

        .

        .

</racine>

Le fichier contenant le schéma (.xsd) :

<?xml version="1.0"?>

<xs:schema xmlns:xs=";>

        .

        .

        .

</xs:schema>

La validation avec xmllint par exemple :

xmllint --schema

MODELES DE CONTENU ET TYPES

On distingue deux familles de types :

•  les simples qui caractérisent le contenu d'un noeud textuel ou d'un attribut ;

•  les complexes sont utilisés pour décrire les autres formes de contenu.

Cela nous amène à distinguer différents modèles de contenu pour un élément selon la nature de ses noeuds fils autorisés :

•  vide : aucun noeud fils ;

•  simple : ne contient que des noeuds textuels ;

•  complexe : que des sous-éléments ;

•  mixte : à la fois du texte et des sous-éléments.

Dès qu'un élément possède un attribut, il est considéré comme étant de type complexe, même si son contenu est vide ou simple.

LES TYPES SIMPLES PREDEFINIS

Consulter la recommandation du W3C pour avoir laliste exhaustivedes types prédéfinis. Parmi ceux-ci, citons :

•  string

•  decimal, integer, positiveInteger, real

date, dateTime, duration

•  ID, IDREF, ENTITY, NMTOKEN, etc. (venant des DTD)

DEFINIR UN NOUVEAU TYPE SIMPLE

Liste de valeurs d'un même type simple

<xs:simpleType name="telephone">

  <xs:list itemType="xs:integer" />

</xs:simpleType>

Union de types simples

<xs:simpleType name="contact">

  <xs:union memberTypes="adresse telephone" />

</xs:simpleType>

Restriction d'un type simple consiste à ajouter des contraintes à un type de base, on distingue différents types de contraintes, appelés facettes, différents suivant le type qui subit la restriction.

•  Énumération pour les chaînes de caractères, nombres et dates

?

<xs:simpleType name="jourSemaine">

?

<xs:restriction base="xs:string">

?

<xs:enumeration value="lundi" />

?

    <xs:enumeration value="mardi" />

?

<xs:enumeration value="mercredi" />

?

<xs:enumeration value="jeudi" />

?

<xs:enumeration value="vendredi" />

?

<xs:enumeration value="samedi" />

?

<xs:enumeration value="dimanche" />

?

</xs:restriction>

?

</xs:simpleType>

•  longueur fixe, minimale ou maximale des chaînes de caractères

?

<xs:simpleType name="telephone">

?

<xs:restriction base="xs:string">

?

<xs:length value="10" />

?

</xs:restriction>

?

</xs:simpleType>

?

<xs:simpleType name="motdepasse">

?

<xs:restriction base="xs:string">

?

<xs:minLength value="8" />

?

<xs:maxLength value="20" />

?

</xs:restriction>

?

</xs:simpleType>

?

<xs:simpleType name="telephone">

?

<xs:restriction base="xs:string">

?

<xs:length value="10" />

?

</xs:restriction>

?

</xs:simpleType>


bornes sur les entiers et les dates

?

<xs:simpleType name="temperature">

?

<xs:restriction base="xs:integer">

?

    <xs:minInclusive value="-15" />

?

<xs:maxInclusive value="+35" />

?

</xs:restriction>

?

</xs:simpleType>

aussi minExclusive et maxExclusive

•  nombre de chiffres sur les nombre

?

<xs:simpleType name="codepostal">

?

  <xs:restriction base="xs:integer">

?

<xs:totalDigits value="5" />

?

</xs:restriction>

?

</xs:simpleType>

?

<xs:simpleType name="prix">

?

<xs:restriction base="xs:decimal">

?

<xs:fractionDigits value="2" />

?

  </xs:restriction>

?

</xs:simpleType>

•  expressions régulières sur tous les types simples (?)

?

<xs:simpleType name="mail">

?

<xs:restriction base="xs:string">

?

<xs:pattern value=".+@.+" />

?

</xs:restriction>

?

</xs:simpleType>

DEFINIR UN ATTRIBUT

•  utilisation de la balise <xs:attribute /> ;

•  indiquer le nom de l'attribut avec l'attribut <xs:attribute name="score" /> ;

•  définir le type du contenu de l'élément en utilisant l'attributtype ;

•  préciser son caractère obligatoire ou optionnel (required ouoptional) à l'aide de l'attribut use ;

•  éventuellement, indiquer une valeur par défaut avec l'attributdefault.

<xs:attribute name="score" type="xs:integer" use="required" default="0" />

DEFINIR UN ELEMENT DE TYPE SIMPLE

•       utilisation de la balise <xs:element /> ;

•       indiquer le nom de l'élément avec l'attribut name ;

préciser le nombre d'apparition autorisé pour cet élément à l'aide des

attributs minOccurs et maxOccurs ;

•       définir le type du contenu de l'élément en utilisant l'attributtype ; Finalement :

<xs:element name="nom"    minOccurs="1" maxOccurs="1"          type="xs:string" />

<xs:element name="prénom" minOccurs="1" maxOccurs="unbounded"  type="xs:string" />

<xs:element name="surnom" minOccurs="0" maxOccurs="1"          type="xs:string" />

DEFINIR UN ELEMENT DE TYPE COMPLEXE

on définit les sous-éléments puis les attributs

CONTENU VIDE AVEC ATTRIBUT

<xs:element name="br">

  <xs:complexType>

    <xs:attribute name="class" type="string" />

  </xs:complexType>

</xs:element>

CONTENU SIMPLE AVEC ATTRIBUT

extension ou restriction sur un type simple

<xs:element name="title">

  <xs:complexType>

    <xs:simpleContent>

      <xs:extension base="string">

        <xs:attribute name="lang" type="string" />

      </xs:extension>

    </xs:simpleContent>

  </xs:complexType>

</xs:element>

CONTENU COMPLEXE

Il s'agit à nouveau d'utiliser <xs:complexType> puis de lister les sous-éléments autorisés au sein de l'une de ces balises :

•  <xs:sequence> : les sous-éléments doivent tous apparaître, dans l'ordre ;

•  <xs:all> : les sous-éléments doivent tous apparaître, mais dans un ordre quelconque ;

•  <xs:choice> : seulement un des sous-éléments peut apparaître, au choix.

<xs:element name="auteur">

  <xs:complexType>

    <xs:sequence>

      <xs:element name="nom"    minOccurs="1" maxOccurs="1"          type="xs:string" />

      <xs:element name="prénom" minOccurs="1" maxOccurs="unbounded" type="xs:string" />

      <xs:element name="surnom" minOccurs="0" maxOccurs="1"          type="xs:string" />

    </xs:sequence>

  </xs:complexType>

</xs:element>

CONTENU MIXTE

On définit pour cela un type complexe en précisant un attribut mixed, celui-ci indiquant que du texte peu se glisser entre tous les sous-éléments autorisés.

<xs:element name="p">

  <xs:complexType mixed="true">

    <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="em" type="xs:string" />

      <xs:element name="strong" type="xs:string" />

    </xs:choice>

  </xs:complexType>

</xs:element>

STRATEGIES D'ECRITURE D'UN SCHEMA

En suivant l'arborescence des documents :

<?xml version="1.0"?>

<xs:schema xmlns:xs=";> 

<xs:element name="CHAMPIONNAT">

<xs:complexType>

<xs:sequence>

<xs:element name="JOURNEE" maxOccurs="38">

        <xs:complexType>

          <xs:sequence>

<xs:element name="RENCONTRE" maxOccurs="10">

              <xs:complexType>

                <xs:attribute name="DOMICILE" type="xs:string" />

                <xs:attribute name="EXTERIEUR" type="xs:string" />

                <xs:attribute name="SCORED" type="xs:string" />

                <xs:attribute name="SCOREE" type="xs:string" />

              </xs:complexType>

            </xs:element>

          </xs:sequence>

          <xs:attribute name="NUMERO" type="xs:integer" />

<xs:attribute name="DATE"   type="xs:string" />

</xs:complexType>

</xs:element>

</xs:sequence>

    <xs:attribute name="DIVISION" type="xs:integer" />

<xs:attribute name="SAISON"   type="xs:string" />


  </xs:complexType>

</xs:element>

</xs:schema>

ou à plat avec références aux éléments déjà définis :

<?xml version="1.0"?>

<xs:schema xmlns:xs=";> 

<xs:attribute name="DOMICILE"  type="xs:string"  />

<xs:attribute name="EXTERIEUR" type="xs:string"  />

<xs:attribute name="SCORED"    type="xs:string"  />

<xs:attribute name="SCOREE"    type="xs:string"  />

<xs:attribute name="NUMERO"    type="xs:integer" />

<xs:attribute name="DATE"      type="xs:string"  />

<xs:attribute name="DIVISION"  type="xs:integer" />

<xs:attribute name="SAISON"    type="xs:string"  />

<xs:element name="RENCONTRE">

  <xs:complexType>

        <xs:attribute ref="DOMICILE"  />

        <xs:attribute ref="EXTERIEUR" />

        <xs:attribute ref="SCORED"    />

        <xs:attribute ref="SCOREE"    />

  </xs:complexType>

</xs:element>

<xs:element name="JOURNEE">

  <xs:complexType>

    <xs:sequence>

      <xs:element ref="RENCONTRE" maxOccurs="10" />

    </xs:sequence>

    <xs:attribute ref="NUMERO" />

    <xs:attribute ref="DATE"   />

  </xs:complexType>

</xs:element>

<xs:element name="CHAMPIONNAT">

  <xs:complexType>

    <xs:sequence>

      <xs:element ref="JOURNEE" maxOccurs="38" />

    </xs:sequence>

    <xs:attribute ref="DIVISION" />

    <xs:attribute ref="SAISON"   />

  </xs:complexType>

</xs:element>

</xs:schema>

La première stratégie contraint l'élément racine, pas la seconde. La seconde est plus modulaire et permet de réutiliser des parties du schéma.

CONTRAINTES D'UNICITE ET DE CLEF

On peut toujours utiliser les ID et IDREF des DTD mais c'est plus pauvre que le mécanisme offert par XML-Schémas. Celui-ci utilise (un sous-ensemble) des expressions XPath.

UNICITE

<xs:element name="bibliotheque">   <xs:complexType>

  ...

  </xs:complexType>

  <xs:unique name="uniquelivre">

    <xs:selector xpath="book" />

    <xs:field xpath="isbn" />

  </xs:unique>

</xs:element>

on peut mettre plusieurs fields

CLES

<xs:element name="bibliotheque">   <xs:complexType>

  ...

  </xs:complexType>

  <xs:key name="cleflivre">

    <xs:selector xpath="livre" />

    <xs:field xpath="isbn" />

  </xs:key>

</xs:element>

pareil que unique avec présence obligatoire de la clé en plus.

REFERENCE

<xs:keyref name="refcleflivre" refer="cleflivre">

  <xs:selector xpath="citation"/>

  <xs:field xpath="ref" />

</xs:keyref>

REGROUPEMENTS

REGROUPER DES ATTRIBUTS

<xs:attributeGroup name="attrs_photo">

    <xs:attribute name="source" type="nomfichier" />

    <xs:attribute name="alt" type="xs:string" />

</xs:attributeGroup>

<xs:element name="identite">

  <xs:complexType>

    <xs:attributeGroup ref="attrs_photo" />

    <xs:attribute name="personne" type="xs:string" /> </xs:complexType>

</xs:element>

<xs:element name="paysage">

  <xs:complexType>

    <xs:attributeGroup ref="attrs_photo" />

    <xs:attribute name="lieu" type="xs:string" />

  </xs:complexType>

</xs:element>

REGROUPER DES ELEMENTS

regrouper par all, choice, ou sequence...

<xs:group name="elems_text">

  <xs:choice>

    <xs:element ref="refacteur" />

    <xs:element ref="film" />

    <xs:element ref="realisateur" />

    <xs:element ref="annee" />

  </xs:choice>

</xs:group>

<xs:element name="p">

  <xs:complexType mixed="true">

    <xs:choice minOccurs="0" maxOccurs="unbounded">

      <xs:group ref="elems_text" />

    </xs:choice>

  </xs:complexType>

</xs:element>

4. COURS SUR LES REQUETES XPATH

GENERALITES

XPath est un langage d'interrogation des documents XML. Il permet de sélectionner certaines parties d'un document XML : des sous-arbres, des noeuds, des attributs, etc.

XPath est central dans le monde XML, il intervient comme brique de base dans d'autres technologies XML :

•  XML Schémas (expression des contraintes d'unicité et de clefs),

•  les transformations XSLT,

•  XQuery

•  XLink

•  XPointer, etc.

Voir la recommandation du W3C sur XPath :

•  officiellesur le site du W3C ;

•  uneversion françaisehébergée par XMLfr.

LA SYNTAXE GENERALE

Le premier concept est celui de noeud courant : c'est l'endroit d'où l'on part. En première lecture on peut imaginer qu'il s'agit de la racine du document, mais n'importe quel noeud peut jour ce rôle. À partir de là, on considère trois éléments :

•  un axe : la direction dans laquelle on se dirige à partir du noeud courant (vers le père, vers les fils, vers les frères de gauche, etc.) ;

•  un filtre : le type de noeuds qui nous intéresse dans l'axe choisi (des noeuds quelconques, des éléments quelconques ou un élément précis, des commentaires, etc.) ;

•  un prédicat optionnel : des conditions supplémentaires pour sélectionner des noeuds parmi ceux retenus par le filtre dans l'axe.

Ils constituent à eux trois une étape et on les noteaxe::filtre[prédicat]. L'enchaînement de plusieurs étapes constitue une chemin XPath :

axe1::filtre1[prédicat1]/axe2::filtre2[prédicat2]

Exemple concret : 

 parent::*/child::node()[position()=2]

Si le chemin commence par un /, il s'agit d'un chemin absolu, c'est-à-dire prenant son origine à la racine du document et non pas au noeud courant.

Il est possible de faire une disjonction de requêtes XPath avec le signe| ; on obtient alors l'union des deux ensembles de noeuds correspondants.

axe1::filtre1[prédicat1]/axe2::filtre2[prédicat2] | axe3::filtre3[prédicat3]

Chaque étape renvoie un ensemble de noeuds et pour chacun d'entre eux, on applique les étapes suivantes.

LES AXES

•  self : le noeud courant lui-même ;

•  child : les enfants du noeud courant ;

•  descendant, descendant-or-self : tous les descendants du noeud courant ;

•  parent : le père du noeud courant ;

•  ancestor, ancestor-or-self : les ancêtres du noeud courant ;

•  attribute : les attributs du noeud courant ;

•  preceding, following : les noeuds, précédants ou suivants, du noeud courant, dans l'ordre de lecture du document ;

•  preceding-sibling, following-sibling : les frères, précédant ou suivant, le noeud courant ;

•  namespace : les espaces de noms.

LES FILTRES

•  node() : tous les noeuds ;

•  text() : les noeuds textuels ;

•  * : tous les éléments ;

•  nom : les éléments portant ce nom ;

•  comment() : les noeuds commentaires ;

•  processing-instruction('cible') : les noeuds instructions, seulement les instructions cible si cet argument est fourni.

LES PREDICATS

Ils prennent la forme de tests que les noeuds sélectionnés devront vérifier. Ces tests peuvent impliquer des fonctions ou de nouveaux chemins XPath.

child::toto[position()=2]

 child::toto[@ref='id125']

Il est possible de combiner ces tests à l'aide des opérateurs logiques classiques (and, or et not) ou de les enchaîner :

child::toto[@ref='id125' or @ref='id47']

child::toto[contains(text(),'coucou') and position()=2]

 child::toto[contains(text(),'coucou')][position()=2]

Les deux dernières requêtes ne sont pas équivalentes :

•  la première renvoie le deuxième fils toto si celui-ci contient le texte coucou ;

•  la seconde sélectionne tous les fils toto qui contiennent le texte coucou et parmi ceux-ci renvoie le deuxième.

LES FONCTIONS

Ces fonctions peuvent apparaître dans des prédicats ou être utilisées directement dans un évaluateur d'expressions XPath.

Il y a des fonctions sur les chaînes de caractères et qui vont donc porter sur les contenus textuels de noeuds :

•    concat : colle ensemble les chaînes de caractères passées en paramètres ;

•    string-length : la longueur de la chaîne fournie ;

•    contains, starts-with, ends-with : tests d'appartenance d'une chaîne dans une autre.

Des fonctions qui prennent en argument une requête XPath et vont donc porter sur des ensembles de noeuds :

•    count : le nombre de noeuds dans l'ensemble sélectionné par la requête ; ? name : le nom de l'élément courant.

Et enfin, nous disposons de fonctions sans paramètre mais liées au noeud courant :

•    position : le numéro du noeud courant dans la liste des noeuds considérés ; ? last : le nombre de noeuds sélectionnés à l'étape courante.

LA SYNTAXE ABREGEE

Cette notation est plus simple mais pas aussi expressive que la notation étendue. De plus, l'équivalent étendu de certaines notations abrégées n'est pas toujours celui que l'on pense.

SYNTAXE ABREGEE

SYNTAXE ETENDUE

.

self::node()

toto

child::toto

../toto

parent::toto

@titi

attribute::titi

//toto

/descendant-or-self::node()/child::toto

.//toto

descendant-or-self::node()/child::toto

toto[2]

child::toto[position() = 2]

Notez bien que la notation // implique de repartir depuis la racine ; si l'on veut un descendant-or-self depuis le noeud courant, on écrira .//.

Il faut prendre garde également au fait que //toto[2] n'est pas équivalent à 

/descendant-or-self::toto[position()=2]

mais à

/descendant-or-self::node()/child::toto[position()=2],

autrement dit :

•  //toto[2] fournit tous les noeuds toto qui sont deuxième fils de leur père ;

•  /descendant-or-self::toto[position()=2] désigne un unique noeud, le deuxième noeud toto du document.

5.

COURS SUR LES TRANSFORMATIONS XSLT

MOTIVATIONS ET GENERALITES

XSLT est un langage central dans le monde XML et beaucoup de qualités reconnues de XML reposent en fait sur l'utilisation de XSLT : productions de versions diffusables (HTML, PDF, etc.), pérennité des documents, ouverture des formats, interopérabilité, etc.

La première motivation est d'associer un style à un document XML, tout comme on associe une feuille de style CSS à une page HTML. Les CSS sont utilisables avec les documents XML mais présentent plusieurs défauts :

•  les CSS ne permettent pas d'extraire les valeurs des attributs pour les faire apparaître ;

•  il est possible avec les CSS de placer les blocs les uns par rapport aux autres, d'en faire disparaître certains, mais pas de tout réorganiser de fond en comble, encore moins de créer de nouvelles données ; ? le langage CSS n'est pas un langage XML.

Cela amène à la définition d'un nouveau format : XSL pour eXtensible Stylesheet Language. Cependant, les critiques des CSS ont fait apparaître deux besoins bien différents : mettre en page le document XML et, par ailleurs, lui faire subir des transformations. D'où la définition de deuxlangages XML : XSL-FO (XSL Formating Objects) et XSLT (XSL Transformations). Dans ce cours, on ne s'intéresse qu'à la partie XSLT.

Une transformation XSLT est donc d'abord un fichier XML, auquel on donne en général l'extension .xsl et qui au minimum contient :

<?xml version="1.0" ?>

<xsl:stylesheet version="1.0" xmlns:xsl=";>

  .

  ... ici des règles de transformation ...

  .

</xsl:stylesheet>

De manière générale, XSLT permet de transformer un document XML en un autre document XML. Parmi les formats utilisés comme sortie de XSLT citons : FO, XHTML, SVG, DocBook, etc.

Pour appliquer une feuille de transformation XSLT à un document XML, une première solution consiste à introduire un lien dans la transformat


241