Les transformations XSL et les Schémas XSD

Avant tout : installation 

  • Aller sur ftp://ftp.zlatkovic.com/libxml/64bit/
  • Télécharger libxml
  • Télécharger iconv
  • Télécharger libxslt
  • Télécharger mingwrt
  • Télécharger zlib
  • Extraire le tout dans un dossier et mettre à jour la variable d'environnement PATH
  • Tester en tapant "xmllint" et "xsltproc" dans votre console

Prêts à travailler !

XSLT

XSLT (eXtensible Stylesheet Language Transformations) est un langage qui permet de transformer des documents XML en d'autres documents au format XML, texte plein, HTML, ou autres.

Issu d'XML

Une feuille de style XSL est un document XML dont les éléments font partie de l'espace de nom XSL Transform

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <xsl:output method="xml" indent="yes"/>

  <xsl:template match="element">
    <name username="{@attribute}">
      <xsl:value-of select="name" />
    </name>
  </xsl:template>

</xsl:stylesheet>

Fonctionnement global

  • L'interpréteur parse le document XML source
  • Il connait en parallèle le traitement contenu dans le document XSL
  • Il applique les gabarits programmés dans la feuille XSL à chaque fois qu'il tombe sur un élément concerné
  • A chaque fois qu'il passe sur un élément, il vérifie si il existe un gabarit correspondant à ce type d'éléments
  • Si c'est le cas, il applique le gabarit (la transformation)
  • A la fin du traitement, l'interpréteur imprime le résultat final

XSL : Un vrai langage de programmation

Les éléments de l'espace de noms XSL Transformations rappellent la programmation événementielle et procédurale. Il existe donc des boucles, des structures de contrôle, la possibilité de stocker des variables, etc.

<xsl:for-each select="input[@name=$name]">...</xsl:for-each>

<xsl:if test="...">...</xsl:if>

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

<xsl:apply-templates />

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

Ecriture littérale de l'arbre de résultat

Avec XSL(T) on peut créer des éléments et des attributs afin de façonner un nouvel arbre !

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

    <xsl:template match="/">
      <html>
      <body>
        <h2>My CD Collection</h2>
        <table border="1">
          <tr bgcolor="#9acd32">
            <th>Title</th>
            <th>Artist</th>
          </tr>
          <xsl:for-each select="catalog/cd">
            <tr>
              <td><xsl:value-of select="title"/></td>
              <td><xsl:value-of select="artist"/></td>
            </tr>
          </xsl:for-each>
        </table>
      </body>
      </html>
    </xsl:template>

</xsl:stylesheet>

Déclaration XSL d'éléments et attributs

Avec XSL(T) on peut créer des éléments et des attributs afin de façonner un nouvel arbre !

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

<xsl:template match="/">
  <xsl:for-each select="catalog/cd">
    <xsl:element name="singer">
      <xsl:value-of select="artist" />
      <xsl:attribute name="length">
        <xsl:value-of select="count(song)" />
      </xsl:attribute>
    </xsl:element>
  </xsl:for-each>
</xsl:template>

</xsl:stylesheet>

XPath : un language de requêtes

Afin de repérer et d'exploiter des données ou des portions du document XML.

 

Il permet donc de repérer un ou plusieurs éléments ou attributs au sein du document XML.

Une expression XPath est un chemin de localisation, constitué de pas de localisation.

Les pas de localisation ont chacun trois composants :

  • un axe (parent, descendant…)
  • un test de nœud (nom ou fonction désignant les nœuds)
  • des prédicats (entre crochets)

Exemple XPath (Wikipedia)

 <?xml version="1.0"?>
 <racine>
  <encyclopedie nom="Wikipedia" site="http://fr.wikipedia.org/">
   <article nom="XPath">   
    <auteurs>
     <auteur>
      <nom>Dupont</nom>
     </auteur>
     <auteur>
      <nom>Dubois</nom>
     </auteur>
    </auteurs>
   </article>
  </encyclopedie>
 </racine>
/	                 # sélectionne un nœud "fictif", dit root element, qui englobe tout le document, 
                         # y compris le doctype <?xml version="1.0"?>2
/root	                 # sélectionne le nœud vide, puisqu'il n'y a pas d'élément "root" (mais "racine")
//article	         # sélectionne tous les éléments "article" du document où qu'ils soient
/racine/encyclopedie	 # sélectionne l'unique élément "encyclopedie" puisqu'il est ici le seul fils de 
                         # "racine" portant ce nom
//article[@nom='XPath']	 # sélectionne tous les éléments "article" du document où qu'ils soient, ayant un 
                         # attribut "nom" dont la valeur est "XPath"

Les schémas XSD

Une DTD++ en XML !

La validation par schémas XSD

Un schéma XSD est un document XML qui permet de spécifier la façon dont un autre document XML doit se composer et les règles qu'il doit respecter.

Les Schémas XSD (XML Schema Definition) sont aussi écrit en XML via l'espace de noms XML Schemas alors que les DTD venaient du format SGML

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="personne">
      <xs:complexType>
        <xs:sequence>
          <xs:element name="nom" type="xs:string" />
          <xs:element name="prenom" type="xs:string" />
          <xs:element name="date_naissance" type="xs:date" />
        </xs:sequence>
      </xs:complexType>
    </xs:element>
</xs:schema>

Fonctionnement du schema

  • Déclaration d'élément : <xs:element name="..." type="..." />
  • Déclaration d'attribut : <xs:attribute name="..." type="..." />
  • Déclaration de type complexe : <xs:complexType name="..."></xs:complexType>
  • Déclaration de type simple : <xs:simpleType name="..."></xs:simpleType>
  • Types de base : xs:string, xs:date, xs:decimal, xs:integer, xs:boolean ...

L'héritage de types simples

La logique du schéma XSD nous permet de créer des héritages de types simples par restriction :

<xs:element name="age">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="0"/>
      <xs:maxInclusive value="120"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>
<xs:element name="car">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:enumeration value="Audi"/>
      <xs:enumeration value="Golf"/>
      <xs:enumeration value="BMW"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>
<xs:element name="letter">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>
<xs:element name="password">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:minLength value="5"/>
      <xs:maxLength value="8"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

La création de types complexes

La logique du schéma XSD nous permet de créer des types complexes pour les éléments :

<xs:element name="person">
  <xs:complexType>
    <xs:all>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:all>
  </xs:complexType>
</xs:element>
<xs:element name="person">
  <xs:complexType>
    <xs:choice>
      <xs:element name="employee" type="employee"/>
      <xs:element name="member" type="member"/>
    </xs:choice>
  </xs:complexType>
</xs:element>
<xs:element name="person">
   <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" 
            type="xs:string"
            minOccurs="0"
            maxOccurs="1"/>
      <xs:element name="lastname" 
            type="xs:string"
            maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

A vous de creuser !

Made with Slides.com