En une phrase XML (eXtensible Markup Language - ou langage de balisage extensible) est un standard qui donne les moyens de partager des donnés et de l'information entre ordinateurs et entre logiciels de la façon la moins ambiguë possible. Une fois l'information transmise, c'est le programme informatique qui reçoit qui doit interprêter les données pour les rendre utilisables et transformer ainsi ces données en information. Parfois cette information sera restituée sous forme d'une page HTML. Parfois elle sera utilisée pour interroger et/ou mettre à jour une base de données. Conçu initialement comme un outil de publication pour le web, XML s'est montré utile aussi pour des choses qu'on n'a jamais eu l'intention d'afficher sous forme de pages web.

Pensez à XML comme à quelque chose qui représenterait des fichiers textes structurés avec des tabulations. Ces derniers sont facilement lisibles par l'homme. Ils sont faciles à importer dans des traitements de texte, des bases de données, des tableurs. Une fois importés, leur structure simple rend leur contenu facile à manipuler. Les textes tabulés sont même indépendants des systèmes d'exploitation (pour autant que vous surmontiez le problème des différences entre les retour-chariots des machines Windows, Mac ou Unix). Voyez l'exemple ci-dessous:

Amanda   10  chien   marron
Bernard  12  chien   bleu
Jack     3   chat    noir
Naia     1   chat    marron
Stop     5   cochon  marron
Puce     14  chat    argent

		

Les textes structurés par des tabulations posent deux problèmes. D'abord, la signification de chacune des valeurs délimitée n'est pas explicitée. Pour savoir ce qu'est censée représenter chaque valeur on doit nécessairement avoir (ou savoir) à l'avance une sorte de carte de situation des données. Ensuite, et c'est plus important encore, les fichiers délimités par des tabulations peuvent seulement représenter une structure de données simple, une structure de données analogue à un simple canevas de lignes et de colonnes. Autrement dit, les fichiers délimités par des tabulations sont exactement comme des fichiers de base de données aplatis. Il n'y a aucun moyen simple, standardisé, de représenter les données de façon hiérarchisée.

A l'image des textes tabulés, les fichiers XML sont faciles à lire par l'homme puisqu'ils ne contiennent que des caractères Unicode -- une version trés étendue de la table d'encodage originale ASCII. Qui plus est, les fichiers XML sont indépendants du système d'exploitation et des applications, ce qui présente aussi l'avantage d'éliminer les problèmes de retour-chariot.

A la différence des textes tabulés, les fichiers XML déclarent explicitement la signification de chacune des valeurs que contient le fichier. La part de non-explicite est très faible. La valeur de chaque élément est explicitement décrite. XML transforme les données en information. Le fichier tabulé de la figure 1.1 est simplement une liste organisée de mots et de chiffres. Aucun contexte n'est explicité et mots et chiffres représentent seulement des données. Par contre dans un fichier XML les mots et les chiffres se voient attribué une valeur et un contexte, et sont ainsi transformés de données en informations. Qui plus est, il est facile de créer des structures de données hiérarchiques en utilisant XML. La figure 1.2 illustre ces concepts. Sans qu'un examen très approfondi soit nécessaire, on voit immédiatement que ces données représente une liste d'animaux (pets), en l'occurence six animaux, et que chaque animal (pet) a un nom (name), un âge (age), une espèce (type), et une couleur (color). Etait-ce aussi évident dans l'exemple précédent?

<pets>
  <pet>
   <name>Puce</name>
   <age>14</age>
   <type>chat</type>
   <color>argent</color>
  </pet>
  <pet>
   <name>Amanda</name>
   <age>10</age>
   <type>chien</type>
   <color>marron</color>
  </pet>
  <pet>
   <name>Jack</name>
   <age>3</age>
   <type>chat</type>
   <color>noir</color>
  </pet>
  <pet>
   <name>Bernard</name>
   <age>12</age>
   <type>chien</type>
   <color>bleu</color>
  </pet>
  <pet>
   <name>Naia</name>
   <age>1</age>
   <type>chat</type>
   <color>marron</color>
  </pet>
  <pet>
   <name>Stop</name>
   <age>5</age>
   <type>cochon</type>
   <color>marron</color>
  </pet>
</pets>
 
		

A mesure que les économies actuelles se consacrent de plus en plus aux services, les données et l'information deviennent de plus en plus importantes. Parrallèlement, les bibliothèques se préoccupent moins des livres et plus des idées et des concepts contenus dans les livres. Dans ces deux domaines, nous avons besoin d'un moyen de faire circuler les données et l'information efficacement. Des données XML partagées entre ordinateurs ou entre logiciels via HTTP représentent une méthode (en évolution) pour améliorer ce partage : cette méthode est appelée, de façon générique, Services Web.

Par exemple, un marquage XML nommé RSS (Rich Site Summary) est utilisé de façon croissante pour syndiquer des listes d'URL représentant des nouvelles tirées de sites web d'information. RDF (Resource Description Framework) est un marquage XML utilisé pour encapsuler des métadonnées concernant les contenus qu'on trouve à la fin des URL. TEI (Text Encoding Initiative) et TEILite sont tous les deux des marquages SGML et XML utilisés pour donner des valeurs explicites à des éléments trouvés dans des oeuvres littéraires. De même un autre marquage XML appelé DocBook est de plus en plus utilisé pour baliser des livres ou des articles d'informatique. L'Open Archives Initiative Protocol for Metadata Harvesting (OAI-PMH) utilise XML pour récupérer des métadonnées trouvées sur des sites web.

En tant que professionnels de l'information, il nous appartient d'apprendre à exploiter les possibilités d'XML, car XML rend beaucoup plus aisé de communiquer de l'information de façon non-ambigue et indépendament des plateformes dans un monde en réseau. N'est-ce pas précisément de cela qu'il s'agit quand on parle de bibliothéconomie et de sciences de l'information?

Les documents XML ont des structures syntaxiques et sémantiques. La syntaxe (pensez à orthographe et à ponctuation) est constituée de règles minimales dont (la liste n'est pas exhaustive):

Chacune de ces règles est décrite plus en détail ci-dessous.

La structure d'un document XML est une arborescence comprenant un tronc et éventuellement de nombreuses branches. Le tronc, unique, représente l'élément racine du document XML. Voyez le document HTML suivant (Figure 2.1), très simplifié:

<html>
 <head>
  <title>Bonjour, tout le monde</title>
 </head>
 <body>
  <p>Bonjour, tout le monde</p>
 </body>
</html>
 
		

La structure de ce document devrait vous être familière. C'est un document XML valide, et il contient un seul élément racine, en l'occurence html. Il y a deux branches à ce document, head et body.

Les noms des éléments, le vocabulaire élémentaire des documents XML, sont sensibles à la casse. La figure 2.1 comporte cinq éléments: html, head, title, body, et p. Puisque les noms des éléments sont sensibles à la casse, l'élément html n'est pas égal à l'élément HTML, ni à HTml ou Html. Ceci s'applique aux autres éléments.

Chaque élément est dénoté par des parenthèses ouvrante et fermante, les signes plus petit que (<) et plus grand que (>), respectivement. Les éléments XML sont rarement vides; ils sont généralement utilisés pour fournir une signification ou un contexte à une donnée, et en conséquence les éléments XML entourent le plus souvent des données. Chacun des éléments de la figure 2.1 est ouvert et fermé. Par exemple, le titre du document est dénoté par les éléments <title> et </title> et le seul paragraphe du document est dénoté par les éléments <p> et </p>. Les éléments ouvrants ne contiennent pas de slash, les éléments fermants en contiennent un.

Parfois des éléments peuvent être vides, comme la balise break en XHTML. Dans ces cas là la balise est ouverte et fermé à la fois, et elle est codée comme ceci: <br />.

Des éléments XML ne peuvent être ouverts et fermés sans que les éléments qui ont été ouverts en dernier soient fermés. Ce serait un emboîtage incorrect. Prenez par exemple le marquage incorrect du paragraphe XHTML suivant:

<p>Ceci est un test. Ceci est un test du système d'<em>
<strong>alarme</em> sonore.</strong></p>
 
		

Dans l'exemple précédent, les éléments em et strong sont ouverts, mais l'élément em est fermé avant l'élément strong. Puisque l'élément strong a été ouvert après l'élément em il doit être fermé avant l'élément em. Voici le marquage correct:

<p>Ceci est un test. Ceci est un test du système d'<strong>
<em>alarme</em> sonore.</strong></p>
 
		

Les éléments XML sont souvent qualifiés par l'utilisation d'attributs. Par exemple un nombre entier peut être désigné comme une longueur, et l'élément longueur peut être qualifié pour indiquer que l'unité de mesure est le pied. Par exemple: <length unit='feet'>5</length>. L'attribut est appelé unité, et sa valeur est toujours entre guillements. On peut utiliser indifférement des guillements simples (') ou doubles (").

En XML certains caractères ont une signification particulière, ce sont les caractères plus petit que (<), plus grand que (>), ainsi que le et commercial (&). Les deux premiers sont utilisés pour délimiter les noms d'éléments. Le et commercial est utilisé pour délimiter l'affichage de certains caractères spéciaux appelés entités; le et commercial est un caractè de "sortie" d'XML. Si vous voulez afficher ces trois caractères dans vos documents XML, vous devez les saisir sous leur forme d'entité:

Les parseurs XML, des programmes qui traitent des documents XML, devraient être capables d'interprêter ces caractères sans qu'il soit besoin de les définir a priori.

Il y a deux autres caractères qui peuvent être représentés en tant que références d'entités:

La sémantique d'un document XML (pensez grammaire) est une articulation des éléments XML qui existent dans un fichier, leurs relations, et leur signification. L'ironie, c'est que c'est là la partie délicate d'XML, qui a aboutie à une multitude de "langages" XML tels que: RSS, RDF, TEILite, DocBook, XMLMARC, EAD, XSL, etc. Dans le fichier XML suivant, qui est parfaitement valide, il y a un certain nombre d'éléments XML. Ce sont ces éléments qui donnent aux données leur valeur et leur signification:

<catalog>
 <work type='prose' date='1906'>
  <title>Les aventures du Far Ouest</title>
  <author>O Henry</author>
 </work>
 <work type='poetry' date='1845'>
  <title>Le corbeau</title>
  <author>Edgar Allen Poe</author>
 </work>
 <work type='play' date='1601'>
  <title>Hamlet</title>
  <author>William Shakespeare</author>
 </work>
</catalog>
 
		

Dans cet exercice, vous apprendrez à identifier les erreurs syntaxiques dans un fichier XML.

Les feuilles de style en cascade (Cascading Style Sheets - CSS) peuvent être utilisées pour restituer des documents XML dans une forme plus lisible pour l'homme. Les fichiers CSS permettent de séparer la présentation du contenu.

Les CSS se composent de trois parties : la mise en page, la typographie, et la couleur. En associant un fichier XML à un fichier CSS et en les affichant dans un navigateur, il est possible d'afficher le contenu du document XML sous une forme esthétiquement satisfaisante.

Les fichiers CSS sont constitués de "sélecteurs" et "déclarations". Chaque sélecteur dans un fichier CSS correspond à un élément dans un fichier XML. Chaque sélecteur est ensuite constitué de déclarations -- des paires standardisées : nom/valeur -- qui indiquent la façon dont le contenu des éléments XML doit être affiché. Ca ressemble à quelque chose comme ça : note { display: block; }.

Voici un document XML très simple décrivant une note:

<?xml-stylesheet type="text/css" href="note.css"?>
<note>
 <para>Notes are very brief documents (Les notes sont des documents courts).</para>
 <para>They do not contain very much content (qui ne contiennent pas grand chose).</para>
</note>

		

La première chose que vous remarquerez à propos de ce document, c'est la toute première ligne, qui est une instruction de traitement XML. Cette instruction particulière indique à l'application qui lit le document XML, de l'afficher en utilisant un fichier CSS intitulé note.css. La symétrie du document XML devrait vous être par ailleurs familière.

Si je voulais afficher le contenu de la note de telle façon que chaque paragraphe soit séparé par une ligne blanche, le fichier CSS devrait ressembler à quelque chose comme ça :

note { display: block; }
para { display: block; margin-bottom: 1em; }

		

Dans ce fichier CSS il y a deux sélecteurs qui correspondent aux éléments du fichier XML : note et para. Chaque sélecteur est associé à une ou plusieurs paires nom/valeur (déclarations) qui décrit la façon dont le contenu des éléments doit être affiché. Chaque nom est séparé de la valeur par le signe deux-points (:), les paires de noms/valeurs seont séparées les unes des autres par un point virgule (;), et toutes les déclarations associées à un sélecteur sont regroupées dans des accolades ({}).

Si vous ouvrez note.xml dans un navigateur web relativement moderne, ça devrait donner quelque chose comme ça :

Attention, tous les navigateurs ne gèrent pas les feuilles de style de la même façon. (Quelle surprise!) En général, vous aurez des résultats moins bon avec Netscape Navigator 4.7 et Internet Explorer 5.0. Mozilla 1.0 et Internet Explorer 6.0 gèrent beaucoup mieux les feuilles de style.

Pour pouvoir utiliser des fichiers CSS, il faut surtout savoir créer les déclarations par paires nom/valeur. Pour une liste complète de ces paires nom/valeur, voir la description de CSS par le World Wide Web Consortium. . Un certain nombre de paires sont décrites ci-dessous.

La propriété display (affichage) est utilisée pour spécifier si un élément doit ou non être affiché; et si oui, comment (mais cela de façon très générale seulement). Les principales valeurs pour display sont : inline, block, list-item, ou none. Inline est la valeur par défaut. Cela signifie que le contenu d'un élément ne comprendra pas de retour à la ligne après le contenu; le contenu sera affiché comme une simple ligne de texte. Attribuer la valeur block à la propriété display créé un retour à la ligne après le contenu de l'élément. Pensez aux blocks comme à des paragraphes. La valeur list-item est similaire à block, sauf qu'elle met légèrement le texte en retrait. L'usage de la valeur none signifie que le contenu ne sera pas affiché; le contenu est caché. Exemples:

La propriété margin (marge) est utilisée pour indiquer la taille de l'espace blanc qui entoure les blocs de texte. Les valeurs peuvent être des pourcentages (%), des pixels (px), ou des conventions typographiques traditionnelles telles que l'unité em (em). Quand on donne une valeur à la propriété margin, elle s'applique simultanément aux marges droite, gauche, haut et bas. Il est possible de spécifier différentes marges en utilisant les propriétés margin-top, margin-bottom, margin-left, et margin-right. Exemples:

Comme la propriété margin, la propriété text-indent accepte pour valeurs les pourcentages, les pixels, ou les unités typographiques. Cette propriété est utilisée pour définir la façon dont certaines lignes doivent être mises en retrait dans des blocs de texte. Par exemple:

Les valeurs courantes de text-align sont right, left, center, et justify. Elles sont utilisées pour aligner le texte à l'intérieur d'un bloc de texte. Ces valeurs fonctionnent de la même façon que votre traitement de texte. Par exemple:

Les listes à puces sont faciles à lire et d'usage courant dans la présentation typographique d'aujourd'hui. Si vous voulez créer une liste, vous utiliserez d'abord le sélecteur display: list-item pour la liste en tant que telle, puis quelque chose comme disc, circle, square, ou decimal pour la valeur list-style. Par exemple:

Associez font-family à un sélecteur si vous voulez décrire dans quelle police de caractère doit être affichée le XML. Parmi les valeurs, on trouve les noms des polices ainsi qu'un certain nombre de familles de polices génériques telles que serif ou sans-serif. Les noms de familles de polices qui contiennent plus d'un mot doivent être placés entre guillements simples. Par exemple:

Les tailles des polices peuvent être indiquées avec des dimensions exactes en points tout autant qu'avec des tailles relatives telles que small, x-small, ou large. Par exemple:

Les valeurs habituelles pour le style de police sont normal ou italic; elles indiquent la façon dont le texte s'affiche, comme par exemple dans :

Ce paramètre est utilisé pour indiquer si le texte doit être rendu en gras ou non. Les valeurs habituelles sont normal et bold:

Vous trouverez ci-dessous un fichier CSS à appliquer au fichier letter.xml que nous avons déjà vu. Notez que chaque élément du fichier XML a un sélecteur correspondant dans le fichier XML. Pour indiquer à votre navigateur web d'utiliser le fichier CSS, vous devrez ajouter l'instruction de traitement de la feuille de style (<?xml-stylesheet type="text/css" href="letter.css" ?>) au début de letter.xml.

letter {
	display: block;
	margin: 5%
}

date, addressee {
	display: block;
	margin-bottom: 1em
}

name, address_one, address_two { display: block }

greeting, list {
	display: block;
	margin-bottom: 1em;
}

paragraph {
	display: block;
	margin-bottom: 1em;
	text-indent: 1em
}

italics {
	display: inline;
	font-style: italic
}

list { display: block }

item {
	display: list-item;
	list-style: inside;
	text-indent: 2em
}

closing {
	display: block;
	margin-top: 3em;
	text-align: right
}
 
		

Le fichier XML correspondant devrait ressembler à quelque chose comme ça:

Les tableaux (tables) sont des listes à double entrée, qui se présentent sous la forme d'un canevas de lignes et de colonnes. Une liste d'ouvrages, très simple (un catalogue) se prête bien à un affichage en tables puisque dans cette liste chaque livre (oeuvre) possède un certain nombre d'attributs tels que le titre, l'auteur, le genre, la date. Chaque oeuvre représente une ligne, et le titre, l'auteur, le genre et la date représentent les colonnes.

Voici un fichier XML représentant un catalogue rudimentaire. Notez que l'instruction de traitement XML indique au logiciel de traitement qu'il doit afficher le contenu de ce fichier en utilisant un fichier CSS appelé catalog.css :

<?xml-stylesheet href='catalog.css' type='text/css'?>
<catalog>
 <caption>Ceci est mon catalogue personnel.</caption>
 <structure>
  <title>Titre</title>
  <author>Auteur</author>
  <type>Genre</type>
  <date>Date</date>
 </structure>
 <work>
  <title>Les aventures du Far Ouest</title>
  <author>O Henry</author>
  <type>prose</type>
  <date>1906</date>
 </work>
 <work>
  <title>Le corbeau</title>
  <author>Edgar Allen Poe</author>
  <type>prose</type>
  <date>1845</date>
 </work>
 <work>
  <title>Hamlet</title>
  <author>William Shakespeare</author>
  <type>prose</type>
  <date>1601</date>
 </work>
</catalog>

		

CSS permet de gérer les tableaux, mais encore une fois les navigateurs actuels ne savent pas tous traiter efficacement les tableaux. Pour créer un tableau vous devez apprendre au moins trois nouvelles valeurs qui s'attachent à l'élément display:

Si nous utilisons l'exemple du catalogue ci-dessus, display: table sera associé à l'élément catalog, display: table-row sera associé à l'élément work, et display: table-cell sera associé aux éléments title, author, type, et date.

Par ailleurs, vous pouvez vouloir rendre vos tableaux à la fois plus complets et plus lisibles:

Table-caption est utilisé pour donner un titre d'ensemble au tableau. Table-header-group est utilisé pour donner un titre aux colonnes.

Dans cet exercice, vous apprendrez à écrire un fichier CSS et à l'utiliser pour l'affichage d'un fichier XML.

En dehors des fichiers CSS, il existe une autre méthode pour transformer des documents XML en quelque chose de plus facile à lire. Il s'agit du langage de feuilles de style extensible: transformation (eXtensible Stylesheet Language: Transormation, ou XSLT). XSLT est un langage de programmation implémenté comme sémantique XML. Comme avec CSS, vous écrivez/créez d'abord un fichier XML, puis vous écrivez un fichier XSLT et vous utilisez un programme informatique pour combiner les deux afin de produire un troisième fichier. Le troisième fichier peut être un fichier plein texte contenant un autre fichier XML, un texte narratif, ou même un ensemble de commandes sophistiquées, comme des requêtes SQL (Structured Query Language) qui seront appliquées à un gestionnaire de bases de données.

A la différence de CSS ou XHTML, XSLT est un langage de programmation. Un langage complet, avec des paramètres, des processus conditionnels, et des appels de fonctions. A la différence de la plupart des langages de programmation, XSLT est déclaratif, et non procédural. Cela signifie que le programme n'est pas exécuté de la première à la dernière ligne, mais quand le programme XSLT rencontre une donnée, il l'évalue et exécute en conséquence les parties du programme XSLT requises: les programmes XSLT ne sont pas procéduraux. Cela signifie aussi qu'il n'est pas possible de changer les valeurs des variables une fois qu'elles ont été définies.

Il y a un certain nombre de processeurs XSLT disponibles pour diverses plate-formes spécifiques en Java, Perl, ou en fonction des systèmes d'exploitation:

Dans cettes section nous allons transformer une lettre, créée précédement, en un fichier XHTML. Nous créérons d'abord un fichier XSLT en utilisant diverses commandes XML, puis nous combinerons le fichier XSLT avec notre lettre en utilisant un processeur XSLT. Voici une liste des diverses commandes XSLT que nous utiliserons. Souvenez-vous que XSLT est un langage de programmation qui apparaît sous la forme d'un fichier XML. Donc, chacune des commandes est un élément XML, et les commandes sont qualifiées à l'aide d'attributs XML.

Vous trouverez ci-dessous notre premier exemple XSLT. Il est destiné à être appliqué au fichier letter.xml, pour produire un fichier valide en XHTML. Vous pouvez le voir fonctionner en utilisant un processeur nommé xsltproc. En partant du principe que tous les fichiers nécessaires se trouvent dans le même répertoire, la commande xsltproc est xsltproc -o letter.html letter2html.xsl letter.xml .

<xsl:stylesheet
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 version="1.0">
 
 <!-- letter2html.xsl; un fichier XSL -->
 
 <!-- défini le résultat comme étant un fichier XML, en l'occurence, un fichier XHTML -->
 <xsl:output 
  method="xml"
  omit-xml-declaration="no"
  indent="yes"
  doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" 
  doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" />
   
 <!-- démarre à la racine du fichier letter -->
 <xsl:template match="letter">
  
  <!-- affiche un élément racine XHTML -->
  <html>
   
   <!-- ouvre l'élément head de XHTML -->
   <head>
    
    <!-- affiche un élément titre avec le nom du destinataire -->
    <title><xsl:value-of select="addressee/name"/></title>
   
   <!-- ferme l'élément head -->
   </head>
   
   <!-- ouvre la balise body et lui attribue un style -->
   <body style="margin: 5%">
    
    <!-- trouve diverses templates dans le fichier XSLT avec les valeurs qui leur sont associées -->
    <xsl:apply-templates select="date"/>
    <xsl:apply-templates select="addressee"/>
    <xsl:apply-templates select="greeting"/>
    <xsl:apply-templates select="paragraph | list" />
    <xsl:apply-templates select="closing"/>
   
   <!-- ferme la balise body -->
   </body>
   
  <!-- ferme le document XHTML -->
  </html>
 
 </xsl:template>
 
 <!-- date -->
 <xsl:template match="date">
  
  <!-- affiche une balise de paragraphe et le contenu du noeud en cours, en l'occurence date -->
  <p><xsl:apply-templates/></p>
 
 </xsl:template>
  
 <!-- destinataire -->
 <xsl:template match="addressee">
  
  <!-- ouvre un paragraphe -->
  <p>
   
   <!-- affiche le contenu des éléments name, address_one,
        et address_two du fichier letter.xml, ainsi que deux balises br -->
   <xsl:value-of select="name"/><br />
   <xsl:value-of select="address_one"/><br />
   <xsl:value-of select="adress_two"/>
  
  <!-- ferme le paragraphe -->
  </p>
 
 </xsl:template>
  
 <!-- chacune des templates suivante fonctionne exactement de la même façon que la template date -->
 
 <!-- greeting -->
 <xsl:template match="greeting">
  <p>
   <xsl:apply-templates/>
  </p>
 </xsl:template>
  
 <!-- paragraphe -->
 <xsl:template match="paragraph">
  <p style="text-indent: 1em">
   <xsl:apply-templates/>
  </p>
 </xsl:template>

 <!-- conclusion -->
 <xsl:template match="closing">
  <p style="margin-top: 3em; text-align: right">
   <xsl:apply-templates/>
  </p>
 </xsl:template>
 
 <!-- italiques -->
 <xsl:template match="italics">
  <i>
   <xsl:apply-templates/>
  </i>
 </xsl:template>
  
 <!-- liste -->
 <xsl:template match="list">
  <ul>
   <xsl:apply-templates/>
  </ul>
 </xsl:template>
  
 <!-- item -->
 <xsl:template match="item">
  <li>
   <xsl:apply-templates/>
  </li>
 </xsl:template>
  
</xsl:stylesheet>
 
		

Le résultat final devrait ressembler à ça:

Evidemment, l'exemple ci-dessus semble compliqué et fonctionne exactement comme nos fichiers CSS. En même temps, afficher le fichier letter.xml avec CSS nécessite un navigateur web récent. Si le fichier letter2html.xsl était incorporé dans un serveur web, le navigateur web n'aurait pas besoin de comprendre CSS. Etant donné l'exemple ci-dessus rien ne nous impose d'utiliser XSLT, pour l'instant.

Voici un autre exemple de fichier XSLT utilisé pour afficher un fichier XML. Cet exemple affiche notre fichier catalog.xml. Lui aussi fonctionne largement comme un bon vieux fichier CSS. Vous pouvez le transformer en utilisant xsltproc comme ceci: xsltproc -o catalog.html catalog2html.xsl catalog.xml .

<xsl:stylesheet
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 version="1.0">
 
 <!-- catalog2html.xsl -->
 
 <xsl:output 
  method="xml"
  omit-xml-declaration="no"
  indent="yes"
  doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" 
  doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" />
  
 <!-- catalog -->
 <xsl:template match="catalog">
  <html>
   <head>
    <title><xsl:value-of select="caption"/></title>
   </head>
   <body>
    <table>
     <xsl:apply-templates select="caption"/>
     <xsl:apply-templates select="structure"/>
     <xsl:apply-templates select="work"/>
    </table>
   </body>
  </html>
 </xsl:template>
 
 <!-- en-tête -->
 <xsl:template match="caption">
  <caption style="text-align: center; margin-bottom: 1em">
   <xsl:value-of select="."/>
  </caption>
 </xsl:template>
  
 <!-- structure -->
 <xsl:template match="structure">
  <thead style="font-weight: bold">
   <tr><xsl:apply-templates/></tr>
  </thead>
 </xsl:template>
  
 <!-- oeuvre -->
 <xsl:template match="work">
  <tr><xsl:apply-templates/></tr>
 </xsl:template>
  
 <!-- titre -->
 <xsl:template match="title">
  <td style="text-align: right; padding: 3px"><xsl:value-of select="."/></td>
 </xsl:template>
  
 <!-- auteur, genre, ou date -->
 <xsl:template match="author | type | date">
  <td><xsl:value-of select="."/></td>
 </xsl:template>
   
</xsl:stylesheet>
 
		

A nouveau, le résultat final devrait ressembler à ça:

Les fichiers CSS, comme les fichiers XSLT ci-dessus, traitent les fichiers XML du début à la fin. Cette technique n'utilise pas les avantages des caractéristiques programmatiques de XSLT. Ce que fait par contre l'exemple suivant. D'abord l'exemple suivant va chercher une valeur qu'il utilise pour faire un tri (sort by). Ensuite, ce fichier XSLT utilise quelques appels de fonctions comme count, sum et sort. Et là réside une distinction importante entre CSS et XSLT. CSS ne sert qu'à l'affichage. XSLT peut être utilisé pour afficher du contenu XML. Mais il peut aussi être utilisé pour manipuler des contenus.

Dans cet exemple on fait des calculs en utilisant notre liste d'animaux. D'abord on affiche le total du nombre d'animaux, ainsi que leur âge moyen. Ensuite la liste des animaux peut être triée par le nom, l'âge, l'espèce, ou la couleur. Pour en voir la démonstration, essayez la commande suivante : xsltproc -o pets.html --stringparam sortby age pets2html.xsl pets.xml . Différents résultats peuvent être obtenus en changeant la valeur de sortby de name à color ou type. Que se passe-t-il si une valeur sortby erronée est transmise au fichier XSLT? Que se passe-t-il si aucun valeur stringparam n'est transmise? Pourquoi?

<xsl:stylesheet
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 version="1.0">
 
 <!-- pets2html.xsl -->
 
 <xsl:output 
  method="xml"
  omit-xml-declaration="no"
  indent="yes"
  doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" 
  doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" />
  
 <!-- obtient un paramètre et le sauvegarde dans une variable appelée sortby; utilise name par défaut -->
 <xsl:param name="sortby" select="'name'"/>
  
 <!-- animaux -->
 <xsl:template match="pets">

  <html>
   <head>
    <title>Pets</title>
   </head>
   <body style="margin: 5%">
    <h1>Pets</h1>
    <ul>
     
     <!-- utilise la fonction count pour déterminer le nombre d'animaux -->
     <li>Total number of pets: <xsl:value-of select="count(pet)"/></li>
     
     <!-- calcule l'âge moyen des animaux en utilisant les fonctions sum et count, ainsi que l'opérateur div -->
     <li>Average age of pets: <xsl:value-of select="sum(pet/age) div count(pet)"/></li>
    </ul>
    <p>Pet sorted by: <xsl:value-of select="$sortby"/></p>
    <table>
     <thead>
      <tr>
       <td style="text-align: right; font-weight: bold">Name</td>
       <td style="text-align: right; font-weight: bold">Age</td>
       <td style="font-weight: bold">Type</td>
       <td style="font-weight: bold">Color</td>
      </tr>
     </thead>
     <xsl:apply-templates select="pet">
      
      <!-- Tri les animaux par un sous-élément particulier ($sortby) -->
      <xsl:sort select="*[name()=$sortby]"/>
     </xsl:apply-templates>
    </table>
   </body>
  </html>
 </xsl:template>
 
 <!-- animal -->
 <xsl:template match="pet">
  <tr><xsl:apply-templates/></tr>
 </xsl:template>
  
 <!-- name -->
 <xsl:template match="name">
  <td style="text-align: right"><xsl:value-of select="."/></td>
 </xsl:template>
  
 <!-- âge -->
 <xsl:template match="age">
  <td style="text-align: right"><xsl:value-of select="."/></td>
 </xsl:template>
  
 <!-- espèce ou couleur -->
 <xsl:template match="type | color">
  <td><xsl:value-of select="."/></td>
 </xsl:template>
   
</xsl:stylesheet>
 
		

Ce qui donne:

Ce dernier exemple utilise encore le fichier pets.xml. Cette fois le fichier XSLT est utilisé pour un autre type de résultat, en l'occurence un ensemble très simple de requêtes SQL. Le but est d'illustrer la façon dont le fichier pets.xml peut recevoir un nouvel usage. Une fois pour l'affichage, une fois pour le stockage. Utilisez cette commande pour voir le résultat : xsltproc -o pets.sql pets2sql.xsl pets.xml .

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

 <!-- pets2sql.xsl -->
 
 <!-- créé un affichage plein texte -->
 <xsl:output method="text" />
 
 <!-- trouve chaque animal -->
 <xsl:template match="pets">
  
  <!-- fait une boucle pour chaque animal -->
  <xsl:for-each select="pet">
  
   <!-- affiche une requête SQL INSERT pour chaque animal -->
   INSERT INTO pets (name, age, type, color)
   WITH VALUES ('<xsl:value-of select="name" />',
   '<xsl:value-of select="age" />',
   '<xsl:value-of select="type" />',
   '<xsl:value-of select="color" />');
   
  </xsl:for-each>
 
 </xsl:template>
</xsl:stylesheet>
 
		

Voici le SQL créé par le fichier XSLT ci-dessus:

INSERT INTO pets (name, age, type, color) WITH VALUES ('Puce', '14', 'chat', 'argent');

INSERT INTO pets (name, age, type, color) WITH VALUES ('Amanda', '10', 'chien', 'marron');

INSERT INTO pets (name, age, type, color) WITH VALUES ('Jack', '3', 'chat', 'noir');

INSERT INTO pets (name, age, type, color) WITH VALUES ('Bernard', '12', 'chien', 'bleu');

INSERT INTO pets (name, age, type, color) WITH VALUES ('Naia', '1', 'chat', 'marron');

INSERT INTO pets (name, age, type, color) WITH VALUES ('Stop', '5', 'cochon', 'marron');
 
		

Ce fichier pourrait être fourni à un programme de base de données et remplir une table de données.

Cette section effleure seulement XSLT. C'est un langage de programmation en soi et les promesses d'XML résident dans l'exploitation de XSLT pour générer divers types de résultats, que ce soit pour les navigateurs web, les bases de données, ou comme données pour d'autres programmes informatiques.

C'est une chose de créer votre propre marquage XML, mais si vous voulez partager vos documents avec d'autres, vous devrez leur communiquer le vocabulaire qui est compris par vos documents XML. C'est la partie sémantique des documents XML -- Quels éléments contiennent vos documents XML, et comment ces éléments sont-ils liés les uns aux autres? Ces relations sémantiques sont créées par les Document Type Definitions (DTD) et/ou des schémas XML. Les DTD sont un héritage du monde SGML. Elles sont plus couramment utilisées que les Schémas XML, plus nouveaux, basés sur XML. Cette section propose une vue d'ensemble de la création de DTD.

Une DTD peut exister dans ou en dehors d'un document XML. Si elle est présente dans le document XML, alors elle commence par une déclaration DOCTYPE, suivie du nom de l'élément racine du document XML, et enfin par une liste de tous les éléments et de leurs relations. Voici une DTD simple, incluse dans le fichier pets.xml lui-même:

<!DOCTYPE pets [
 <!ELEMENT pets  (pet+)>
 <!ELEMENT pet   (name, age, type, color)>
 <!ELEMENT name  (#PCDATA)>
 <!ELEMENT age   (#PCDATA)>
 <!ELEMENT type  (#PCDATA)>
 <!ELEMENT color (#PCDATA)>
]>

<pets>
 <pet>
  <name>Puce</name>
  <age>14</age>
  <type>chat</type>
  <color>argent</color>
 </pet>
 <pet>
  <name>Amanda</name>
  <age>10</age>
  <type>chien</type>
  <color>marron</color>
 </pet>
 <pet>
  <name>Jack</name>
  <age>3</age>
  <type>chat</type>
  <color>marron</color>
 </pet>
 <pet>
  <name>Bernard</name>
  <age>12</age>
  <type>chien</type>
  <color>bleu</color>
 </pet>
 <pet>
  <name>Naia</name>
  <age>1</age>
  <type>chat</type>
  <color>Marron</color>
 </pet>
 <pet>
  <name>Puce</name>
  <age>5</age>
  <type>cochon</type>
  <color>marron</color>
 </pet>
</pets>
 
		

Plus couramment, une DTD est placée en dehors du document XML, dans la mesure où elle sera utilisée par plusieurs documents XML. Dans ce cas, la déclaration DOCTYPE comprend un lien vers le fichier dans lequel les éléments XML sont décrits.

<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
 "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">

		

Que la DTD soit interne ou externe, une liste des éléments XML doit être clairement définie. Chaque élément de la liste ressemblera à quelque chose comme !ELEMENT pets (pet+) où "!ELEMENT" dénote un élément, "pets" est l'élément défini, et "(pet+)" est la définition. Ce sont les définitions qui constituent la partie délicate. Les définitions peuvent inclure bien des valeurs, et seules quelques unes d'entre elles sont décrites ici.

Pour commencer, les définitions peuvent inclure les noms d'autres éléments. Dans notre exemple ci-dessus, la première déclaration définie un élément appelé pets et peut inclure un seul autre élément, pet. De la même façon, l'élément pet peut contenir quatre autres éléments : name, age, type, et color. Chaque élément est qualifié par le nombre de fois qu'il peut être utilisé dans un document XML. Ce qui se fait grâce à l'astérisque (*), le point d'interrogation (?), et le signe plus (+). Chacun de ces symboles a une signification spécifique:

Si un élément n'est qualifié par aucun de ces symboles, alors il peut appraître une fois et une seule. En conséquence, dans l'exemple ci-dessus, l'élément pets étant défini comme contenant l'élément pet, et l'élément pet étant qualifié par un signe plus, il doit y avoir au moins un élément pet dans l'élément pets.

#PCDATA est une autre valeur de définition d'élément que vous devez connaître. Cela signifie "parsed character data" (donnée de caractère parsée), et c'est utilisé pour dénoter un contenu qui ne contient que du texte, sans marquage.

Enfin, il est tout à fait possible qu'un élément contienne de multiples sous-éléments. Quand ils sont combinés, la liste des éléments est appelée une séquence; on peut les grouper comme suit:

En examinant la DTD de pets.xml on voit que:

Voici, ci-dessous, une DTD pour la lettre d'un exemple précédent.

<!ELEMENT letter (date, addressee, greeting, (paragraph+ | list+)*, closing)>
<!ELEMENT date (#PCDATA)>
<!ELEMENT addressee (name, adresse_un, adresse_deux)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT address_one (#PCDATA)>
<!ELEMENT address_two (#PCDATA)>
<!ELEMENT greeting (#PCDATA)>
<!ELEMENT paragraph (#PCDATA | italiques)*>
<!ELEMENT italics (#PCDATA)>
<!ELEMENT list (item+)>
<!ELEMENT item (#PCDATA)>
<!ELEMENT closing (#PCDATA)>
 
		

Cet exemple est un peu plus compliqué. En le parcourant, nous voyons que:

Pour inclure cette DTD dans notre fichier XML, nous devons indiquer où elle se trouve, et puisque cette DTD est dans notre environnement local, et non pas un standard, le lien devrait être inséré dans le document XML, comme suit:

<!DOCTYPE letter SYSTEM "letter.dtd">

<letter>
  <date>
   11 Décembre 2002
  </date>
  <addressee>
   <nom>
    Melvile Dewey
   </nom>
   <address_one>
    Columbia University
   </address_one>
   <address_two>
    New York, NY
   </address_two>
  </addressee>
  <greeting>
    Cher Melvile,
  </greeting>
  <paragraph>
   J'ai lu vos textes concernant la nature de la bibliothéconomie, et
   <italics>je les trouve tout à fait fascinants</italics>. J'aimerais avoir 
   l'occasion de discuter avec vous du rôle du catalogue papier dans les
   bibliothèques aujourd'hui, compte tenu du développement du World Wide Web.
   En particulier, dans quelle mesure des services comme Google ou Amazon.fr affectent-ils
   les demandes de nos lecteurs à l'égard des services de bibliothèque?
   M. Cutter et moi-même discuterons de ces sujets lors de la prochaine conférence annuelle,
   et nous serons disponibles aux dates et heures suivantes:
  </paragraph>
  <list>
 <item>
  Lundi, 2-4
 </item>
 <item>
  Mardi, 3-5
 </item>
 <item>
  Jeudi, 1-3
 </item>
  </list>
  <paragraph>
    Nous espérons que vous pourrez nous rejoindre.
  </paragraph>
  <closing>
    Cordialement, S. R. Ranganathan
  </closing>
</letter>
 
		

Un processeur XML devrait savoir que l'élément nommé letter est la racine du fichier XML, et que le fichier XML peut être validé en utilisant une DTD locale, non-standardisée, appelée letter.dtd.

Dans cet exercice vous examinerez une DTD existante puis vous rédigerez votre propre DTD.

XHTML est une implémentation XML de HTML. Dès lors les six règles de la syntaxe XML s'appliquent : il y a un élément racine, les noms des éléments sont sensibles à la casse (bas de casse), les éléments doivent être fermés, ils doivent être correctement emboîtés, les attributs doivent être entre guillemets, et les caractères spéciaux doivent être codés en tant qu'entités. Il existe quelques DTD XHTML, qui vont de DTD très strictes qui interdisent les balises de style et les tableaux, à des DTD plus souples qui, simplement, n'encouragent pas ce type de balises. Les documents XHTML requièrent une déclaration DOCTYPE au début du fichier qui annonce quelle version de XHTML est respectée dans le document. Donc, tout ce qui suit s'applique:

XHTML a quatre attributs "communs" à n'importe quel élément XHTML. Ces attributs sont:

En faisant un usage généreux de ces attributs communs, et en leur assignant des valeurs significatives, il est possible de complétement séparer le contenu de la présentation tout en créant des documents accessibles, par toutes sortes de gens tout autant que par des ordinateurs.

Les éléments stylistiques sont découragés dans le but de séparer plus encore le contenu de la présentation. Quand une certaine mise en forme est nécessaire, vous êtes invités à user avec libéralité des feuilles de style. Votre spécification CSS peut résider dans un fichier extérieur, avec un lien dans l'en-tête du document XHTML, ou être directement spécifiée à l'intérieur de chaque élément XHTML grâce à l'attribut style.

Les tableaux font partie de XHTML, et doivent être utilisés pour afficher des données tabulées. Mais l'usage des tableaux pour la mise en page est découragé. Vous devez, plutôt, utiliser les éléments div et span, combinés avec un fichier CSS, pour positionner des blocs de texte sur l'écran.

Vous trouverez ci-dessous un fichier XHTML simple et un fichier CSS représentant une page d'accueil. Le graphisme est pris en charge par le fichier CSS, et même quand le fichier CSS n'est pas utilisé, l'affichage n'est pas si mauvais.

<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
 <title>Une page d'accueil simple</title> 
 <link rel="stylesheet" href="home.css" type="text/css" />
</head>
<body>
<div class="menu">
 <h3 class="label">Liens</h3>
 <a href="http://infomotions.com/travel/" title="Notes de voyage">Notes de voyage</a><br />
 <a href="http://infomotions.com/musings/" title="Réflexions sur l'information">Réflexions sur l'information</a><br />
 <a href="http://infomotions.com/" title="Accueil Infomotions">A propos d'Infomotions</a><br />
</div>
<div class="content">
 <h1>Une page d'accueil simple </h1> 
 <p>
	 Ceci est une page d'accueil simple qui illustre l'usage de XHTML version 1.0.
 </p>
 <p>
	 <img src="water.jpg" alt="Océan Atlantique" width="120"
	 height="160" align="right" hspace="5" vspace="3" />XHTML n'est pas très différent de HTML.
	 XHTML comprend toutes les balises habituelles, telles que la balise pour les références
	  hypertextes (liens) et les images. Les tableaux existent toujours dans ce standard, mais n'ont pas vocation
	  à être utilisés pour la mise en page.
 </p>
 <p>
	La transition d'HTML à XHTML est simple tant que vous respectez quelques règles. D'abord, 
	assurez-vous de respecter les six règles de la syntaxe XML. Ensuite, méfiez-vous des balises
	de style (éléments) tels que bold, italics, et en particulier font. Enfin, utilisez largement les éléments 
	div et span. Utilisés avec les fichiers CSS, ils vous permettront de positionner et de formater
	facilement des blocs de texte à l'éran.
 </p>
 <hr />
 <p class="footer">
	 Auteur: Eric Lease Morgan &lt;<a
	 href="mailto:eric_morgan@infomotions.com">eric_morgan@
	 infomotions.com</a>&gt;
	 <br />
	 Date: 19-01-2003
	 <br />
	 URL: <a href="./home.html">./home.html</a> 
 </p>

</div>
</body>
</html>
 
		

h1, h2, h3, h4, h5, h6 {
  font-family: helvetica, sans-serif;
}

p {
 font-family: times, serif;
 font-size: large;
}

p.footer {
 font-size: small;
}

div.menu {
 position: absolute;
 margin-right: 82%;
 text-align: right;
 font-size: small;
}

div.content {
 position: absolute;
 margin-left: 22%;
 margin-right: 3%;;
}

a:hover {
 color: red;
 background-color: yellow;
}

 
		

Si vous affichez ces fichiers dans un navigateur compatible CSS, cela devrait donner quelque chose comme ça:

Dans cet exercice, vous apprendrez à créer un document en utilisant une DTD standard, en l'espèce XHTML.

TEI, ou Text Encoding Initiative, est un grand-père des langages de marquage. TEI, qui a commencé comme SGML et n'est devenu XML que relativement récement, est utilisé le plus souvent dans le communauté des sciences humaines pour baliser des oeuvres littéraires (prose et poèmes). Souvent dans ces communautés on scanne des documents originaux, qu'on converti en texte en utilisant des techniques de reconnaissance optique de caractères (OCR), on corrige les erreurs, et on balise le résultat en TEI. Dans l'idéal, on dispose d'un original du livre ou du manuscrit à côté de la version digitale en TEI. Avec les deux, un spécialiste peut analyser le texte très finement et ainsi créer un nouveau savoir.

La DTD TEI est très riche et "bavarde". Elle contient des éléments qui couvrent toutes les figures littéraires (paragraphes, strophes, chapitres, notes de bas de page, etc.). Puisque les documents TEI cherchent, la plupart du temps, à refléter le plus fidèlement possible les documents originaux, la DTD contient des balises qui peuvent indiquer des choses comme les sauts de page ou les numéros de ligne dans le texte original. Il y a des balises pour les références croisées et les liens hypertextes. Il y a même des balises pour le commentaire éditorial, l'interprétation, et l'analyse. La DTD est si prolixe que certains experts de TEI suggèrent de ne l'utiliser qu'en partie. En pratique, de nombreuses institutions qui utilisent la DTD TEI utilisent ce qu'on appele couramment TEILite, une version simplifiée de la DTD qui contient les définitions des éléments les plus courament utilisés par la plupart des gens.

Ce texte n'a pas vocation à donner plus qu'une très sommaire introduction à TEI. Cette section décrit les éléments TEI de base, et la façon dont les documents TEI peuvent être traités par les outils XML.

Le plus simple des documents TEI contient des sections en-tête (teiHeader) et texte (text). La section teiHeader contient un certain nombre de sous-éléments qui fournissent des métadonnées à propos du document. La section text est divisée en trois sous-sections (front, body, et back). Voici une liste des principaux éléments TEI avec une brève description pour chaque:

En utilisant les éléments ci-dessus il est possible de créer un document TEI valide, quoiqu'un peu limité, comme celui-ci:

<TEI.2>

 <teiHeader>
  <fileDesc>
   <titleStmt>
    <title>Getting Started with XML</title>
    <author>Eric Lease Morgan</author>
   </titleStmt>
   <publicationStmt><p>Originally published in <date>march 2003</date> for an Infopeople workshop.</p></publicationStmt>
   <sourceDesc><p>There was no original source; this document was born digital.</p></sourceDesc>
  </fileDesc>
 </teiHeader>

 <text>
 
  <front></front>
 
  <body>
 
   <p>
   Getting started with XML is a worlshop and manual providing an overview of XML and how it can be applied in libraries. This particular example illustrates how a TEI document can be created. For example, since TEI is often used to markup poetry, the following example is apropos:
   </p>
 
   <lg>
	<l>There lives a young girl in Lancaster town,</l>
	<l>Whose hair is a shiny pale green.</l>
	<l>She lives at the bottom of Morgan's farm pond,</l>
	<l>So she's really too hard to be seen.</l>
   </lg>
 
  </body>
 
  <back></back>
 
 </text>

</TEI.2>
 
		

Les fichiers TEI ont historiquement été créés puis indexés/restitués grâce à un ensemble de programmes intermédiaires tels que XPAT. La disponibilité croissante de technologies XML telles que CSS et XSLT ont fait qu'un certain nombre de feuilles de style sont désormais disponibles. Le site web officiel de la TEI propose des liens vers ces ressources, et les feuilles de style XSLT fonctionnent assez bien.

Si vous sauvegardiez le texte TEI ci-dessus sous le nom tei-getting.xml, vous pourriez créer un très beau document XHTML en utilisant les feuilles de style XSLT et xsltproc comme ceci: xsltproc tei-stylesheets/teihtml.xsl tei-getting.xml .

Voici le résultat:

Attention. La feuille de style XSL est configurée de telle façon qu'elle sauvegarde toujours les documents sous le nom index.html, même si vous spécifiez l'option -o. Vous devrez éditer le fichier nommé teixsl-html/teihtml-param.xsl pour mettre le résultat XHTML à votre sauce.

Dans cet exercice vous afficherez un fichier TEI en utilisant CSS et XSLT.

EAD signifie Encoded Archival Description (Description Archivistique Encodée), et il s'agit d'un vocabulaire SGML/XML utilisé pour baliser des outils d'aide à la recherche archivistique. Comme TEI, EAD est profondément enraciné dans SGML, et comme TEI, EAD n'est devenu compatible XML que relativement récement.

Comme vous le savez, ou pas, les outils d'aide à la recherche archivistique sont des descriptions formelles de pièces d'archives institutionnelles. Cela ne se limite pas aux manuscrits, aux notes, aux lettres, aux oeuvres publiées ou non d'individus ou de groupes : cela comprend aussi, désormais, des programmes et des données informatiques, des films, des vidéos, des enregistrements sonores, des objets. Du fait du nombre de pièces individuelles dans ces archives, les items ne sont généralement pas décrits individuellement mais en tant que collections. Qui plus est, les items ne sont généralement pas organisés par sujet mais plus probablement par date dans la mesure oû l'ordre chronologique de création des items incarne le développement des idées représentées par la collection. Du fait de ces caractéristiques, les pièces d'archive ne sont habituellement pas décrites avec un format MARC mais, de plus en plus, grâce à EAD.

Selon la DTD EAD, seuls quelques éléments sont nécessaires pour créer un document EAD valide, mais ce type de document ne sera pas une très bonne aide à la recherche. En conséquence, le guide EAD Application Guidelines suggère les éléments suivants:

Ouf!

Voici un fichier EAD. Pouvez-vous trouver de quoi il s'agit?

<ead>
 <eadheader>
  <eadid>
   ELM001 
  </eadid>
  <filedesc>
   <titlestmt>
    <titleproper>
     Collection Eric Lease Morgan
    </titleproper>
    <author>
     Créée par Eric Lease Morgan 
    </author>
   </titlestmt>
   <publicationstmt>
    <publisher>
     Infomotions, Inc. 
    </publisher>
    <date>
     20030218 
    </date>
   </publicationstmt>
   <profiledesc>
    <creation>
     Ce fichier a été créé avec un éditeur de texte simple.
    </creation>
    <langusage>
     Ce fichier ne contient qu'une langue, le
     <language>
      Français
     </language>
     . 
    </langusage>
   </profiledesc>
  </filedesc>
 </eadheader>
 <archdesc level='otherlevel'>
  <did>
   <repository>
    <corpname>
     Infomotions, Inc. 
    </corpname>
   </repository>
   <origination>
    <persname>
     Eric Lease Morgan 
    </persname>
   </origination>
   <unittitle>
    Documents 
   </unittitle>
   <unitdate>
    1980-2001 
   </unitdate>
   <physdesc>
    Un ensemble de quatre boîtes contenant pour l'essentiel des papiers A4, conservées dans mon garage.
   </physdesc>
   <unitid>
    B0001 
   </unitid>
   <abstract>
    Au fur et à mesure des années, j'ai conservé diverses choses que j'avais écris.
Cette collection regroupe l'essentiel de ces papiers. Je suis bien persuadé qu'elle contribuera à
l'avancée de la connaissance après ma mort.
   </abstract>
  </did>
  <biohist>
   <p>
    Eric est né à Lancaster, PA. Il a fait ses études à Bethany, WV. 
Il a vécu à Charlotte et Raleigh, NC pendant quinze ans. 
Il vit désormais à South Bend, IN.
   </p>
  </biohist>
  <scopecontent>
   <p>
    Cette collection consiste en travaux prépubliés, photographes, dessins, et de courriels 
importants conservés depuis des années.
   </p>
  </scopecontent>
  <controlaccess>
   <p>
	Il est peu problable qu'on trouve un vocabulaire standardisé dans d'autres systèmes 
qui conserveraient un matériel similaire.
   </p>
  </controlaccess>
  <dsc type='othertype'>
   <c level='otherlevel'>
    <did>
     <container type='box'>
      1 
     </container>
     <unittitle>
      Boîte 1 
     </unittitle>
     <unitdate>
      1980-1984 
     </unitdate>
    </did>
    <did>
     <container type='box'>
      1 
     </container>
     <unittitle>
      Boîte 2 
     </unittitle>
     <unitdate>
      1985-1995 
     </unitdate>
    </did>
    <did>
     <container type='box'>
      1 
     </container>
     <unittitle>
      Boîte 3 
     </unittitle>
     <unitdate>
      1995-1998 
     </unitdate>
    </did>
    <did>
     <container type='box'>
      1 
     </container>
     <unittitle>
      Boîte 4 
     </unittitle>
     <unitdate>
      1999-2001 
     </unitdate>
    </did>
   </c>
  </dsc>
 </archdesc>
</ead>
 
		

DTD est une DTD utilisée pour baliser des documents informatiques. La DTD a évolué depuis sa création il y a plus de dix ans par l'éditeur O'Reilly, qui publie de nombreux ouvrages informatiques. Comme XHTML et TEI, DocBook sert à baliser des textes narratifs, mais DocBook dispose aussi d'un certain nombre d'éléments spécifiques au thème de l'informatique. Parmi ces éléments, il y a des choses comme les copies d'écran (screenshot), les programmes (programlisting), et les commandes (command).

Il y a un large éventail de types de documents de base dans DocBook. Les plus courants sont book et article. Les documents book peuvent contenir des choses comme une préface, des chapitres, et des annexes. Qui peuvent être sub-divisées en sections contenant des paragraphes, des listes, des figures, des exemples, et des morceaux de programmes. (Ce manuel/atelier est balisé avec la DTD DocBook.) Les articles sont comme les livres (book), mais ne contiennent pas de chapitres.

Pour créer un fichier DocBook valide, il faut que le fichier contienne une déclaration de type de document (DTD) qui identifie la version de DocBook utilisée. La DTD DocBook évoluant, il y a des déclarations différentes. Voici une déclaration pour un article utilisant la version 4.2 de la DTD:

<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
 "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 
		

Voici une liste de quelques uns des éléments les plus courament utilisés dans un article DocBook:

En utilisant certaines des balises ci-dessus, on peut créer l'article DocBook suivant.

 <!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
	"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
<article>
  <articleinfo>
    <author>
      <firstname>
        Eric 
      </firstname>
      <surname>
        Morgan 
      </surname>
    </author>
    <title>MyLibrary: un site web en base de donnés pour les bibliothèques</title> 
    <pubdate>
      Février 2003 
    </pubdate>
    <abstract>
      <para>
        Cet article décrit un logiciel de gestion de site web en base de données appelé MyLibrary.
      </para>
    </abstract>
  </articleinfo>
  <section>
    <title>Introduction</title> 
    <para>
        Cet article décrit un logiciel de gestion de site web en base de données appelé MyLibrary.
    </para>
  </section>
  <section>
    <title>Plus qu'une belle gueule</title> 
    <para>
	MyLibrary est dérivé d'une interface personnalisable pour l'accès aux ressources de la bibliothèque.
	 A mesure que l'application murissait, c'est devenu un système pour créer et gérer un site web de 
bibliothèque en utilisant l'idée d'architecture de l'information. Spécifiquement, le système MyLibrary 
donne à une bibliothèque les moyens de créer des choses comme:
    </para>
    <itemizedlist>
      <listitem>
        <para>
          une carte du site
        </para>
      </listitem>
      <listitem>
        <para>
          un index du site
        </para>
      </listitem>
      <listitem>
        <para>
          des vocabulaires contrôlés
        </para>
      </listitem>
      <listitem>
        <para>
          un outil de recherche puissant
        </para>
      </listitem>
      <listitem>
        <para>
          des listes de ressources qu'on peut feuilleter
        </para>
      </listitem>
      <listitem>
        <para>
          des interfaces personnalisables, optionnelles
        </para>
      </listitem>
    </itemizedlist>
    <para>
      En ligne de commande, vous pouvez vérifier que votre installation MyLibrary fonctionne correctement 
en tapant la commande suivante:
      <command>
        ./mylibrary.pl 
      </command>
      . Vous devriez obtenir un résultat en HTML, à lire dans un navigateur web.
    </para>
    <para>
      Pour plus d'informations sur MyLibrary, voir: 
      <ulink url="http://dewey.library.nd.edu/mylibrary/">
        http://dewey.library.nd.edu/mylibrary/
      </ulink>
      . 
    </para>
  </section>
</article>
 
		

DocBook bénéficie, c'est un de ses avantages, d'un bon support. Plusieurs feuilles de style XSLT sont disponibles pour DocBook : elles vous permettent d'utiliser votre processeur XSLT préféré pour transformer des fichier DocBook en fichiers XHTML, HTML, PDF, en pages man Unix, en fichiers d'aide Windows, ou même en diapositives du type PowerPoint. Par exemple, vous pouvez utiliser une commmande comme celle-ci pour transformer un fichier DocBook en HTML: xsltproc -o docbook-article.html docbook-stylesheets/html/docbook.xsl docbook-article.xml . Vous obtenez un fichier HTML nommé docbook-article.html qui, dans un navigateur web, ressemble à ça.

Vous pouvez aussi créer des documents PDF à partir de fichiers DocBook en utilisant quelque chose comme le programme FOP et une feuille de style appropriée. Par exemple, cette commande créée un document PDF: fop.sh -xml docbook-article.xml -xsl /docbook/stylesheets/fo/docbook.xsl docbook-article.pdf . Vous obtenez un document PDF qui ressemble à ça:

Si l'apparence graphique des documents HTML et PDF qui en résulte ne correspond pas exactement à ce que vous voudriez, vous pouvez toujours créer vos feuilles de style XSLT en utilisant celles fournies par la communauté DocBook comme canevas de départ (template).

Resource Description Framework (RDF) est une proposition permettant d'encoder de façon consistante des métadonnés dans une syntaxe XML. L'idée grandiose derrière RDF est la création du web sémantique. Si tout le monde créait une description RDF de ses documents, alors les ordinateurs seraient capables de trouver des relations entre les documents que les humains ne découvriraient pas nécessairement. A première vue, la syntaxe semble un peu écrasante, mais en fait ça n'est pas si difficile. Juré.

RDF ressemble beaucoup à l'idée d'encoder des métadonnées dans les balises meta des documents HTML. En HTML, les balises meta définissent d'abord le nom de la balise meta, disons, title. Ensuite, l'attribut content de la balise meta HTML donne la val