Extensible Markup Language

Par -

 ====== Transformations de XML avec XSLT =====

XSL (eXtensible Stylesheet Language) possède deux composantes.

 XSLT, eXtensible Stylesheet Transformation =====

Le langage XSLT permet de modifier la structure des éléments XML.

Un document XML peut être représenté comme une structure arborescente. Ainsi XSLT permet de transformer les documents XML à l'aide de feuilles de style contenant des règles appelées template rules (ou règles de gabarit en français).

Le processeur XSLT (composant logiciel chargé de la transformation) crée une structure logique arborescente (on parle d'arbre source) à partir du document XML et lui fait subir des transformations selon les template rules contenues dans la feuille XSL pour produire un arbre résultat représentant, par exemple, la structure d'un document HTML. Les composants de l'arbre résultat sont appelés objets de flux.

Chaque template rule définit des traitements à effectuer sur un élément (noeud ou feuille) de l'arbre source. On appelle "patterns" (en français motifs, parfois "éléments cibles") les éléments de l'arbre source.

L'arbre source peut être entièrement remodelé et filtré ainsi qu'ajouter du contenu à l'arbre résultat, si bien que l'arbre résultat peut être radicalement différent de l'arbre source.

===== XSL/FO, eXtensible Stylesheet formatting =====

Le langage de formatage des données (XSL/FO), c'est-à-dire un langage permettant de définir la mise en page (affichage de texte ou de graphiques) de ce qui a été cré par XSLT.

Une fois l'arbre source créé, XSL/FO permet de formater le résultat, c'est-à-dire d'interpréter l'arbre résultat, ou plus exactement les objets de flux le composant en leur appliquant des objets de mise en forme afin d'en faire une représentation visuelle (papier, écran, ...)

 ====== Les template rules (règles de gabarit) ======

Les template rules sont des balises XSL permettant de définir des opérations à réaliser sur certains éléments du document XML utilisant la page XSL, c'est-à-dire généralement de transformer un tag XML et au moins un tag HTML (généralement plusieurs).

 Ainsi le tag XML suivant : 


<code>
<personne>
<nom>Pillou</nom>
<prenom>Jean-François</prenom>
</personne>
<personne>
<nom>VanHaute</nom>
<prenom>Nico</prenom>
</personne>
<personne>
<nom>Andrieu</nom>
<prenom>Seb</prenom>
</personne>
</code>

pourra être transformé en les tags HTML suivants : 

<code>

<ul><li>Pillou - Jean-François</li>

<li>VanHaute - Nico</li>

<li>Andrieu - Seb</li>

</ul>

</code>

L'attribut "match" de la balise <xsl:template> permet de définir (grâce à la notation XPath) le ou les éléments du document XML sur lesquels s'applique la transformation.

  <xsl:template match="conditions"/>

La notation Xpath permet de définir des patterns, c'est-à-dire des chaînes de caractères permettant de repérer un noeud dans le document XML. Les principaux patterns sont :


|Pattern|Exemple|Signification|

|Nom|toto|Sélectionne les éléments par leur nom|

|Nom[0]|toto[0]|Sélectionne le premier élément ayant un nom donné (toto[0] sélectionne le premier élément rencontré ayant le nom 'toto')|

|Nom[end()]|toto[end()]|Sélectionne le dernier élément ayant un nom donné|

|%%|%%|Gauche%%|%%Milieu|Indique une alternative (un noeud OU bien l'autre (ou les deux))|

|/ ou Arbre/Feuille|/| <WRAP>

  * utilisé seul: Définit l'élément de plus haut niveau de l'arborescence (appelé root ou racine en français) ainsi que (de façon implicite) tous ses éléments fils.

  * utilisé entre deux éléments: décrit la localisation d'un élément dans son arborescence(comme pour l'arborescence des répertoires sur un disque - /usr/bin/toto)

</WRAP> |

|*|*|Motif "joker" désignant n'importe quel élément|

|%%//%%|%%//personne%%|Indique tous les descendants d'un noeud|

|.|.|Caractérise le noeud courant|

|..|..|Désigne le noeud parent. Permet de remonter d'un niveau dans l'arborescence hiérarchique|

|@|@nom|Indique un attribut caractéristique (@nom décrit l'attribut value). La notation @* désigne tous les attributs d'un élément|

|text()|text()|Désigne le contenu d'un élément (le texte contenu entre ses balises)|

|ID()|ID('a2546')|Sélectionne l'élément dont l'identifiant (la valeur de l'attribut ID) est celui spécifié en paramètre|

 

La transformation peut être réalisée 

  * soit par ajout de texte, 

  * soit en définissant des éléments de transformation, c'est-à-dire des éléments permettant de définir des règles de transformation à appliquer aux éléments sélectionnés par l'attribut match

 

Voici un exemple de feuille XSL permettant d'effectuer la transformation XML vers HTML décrite ci-dessus :

<code>

<

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

<xsl:stylesheet

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

xmlns="http://www.w3.org/TR/REC-html40"

result-ns="">

<xsl:template match="/">

<HTML>
<HEAD>
<TITLE>Titre de la page</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">

<xsl:apply-templates/>

</BODY>
</HTML>
</xsl:template >
<xsl:template match="personne" >
<ul>
<li>
<xsl:valu-of select="nom"/>
<xsl:value-of select="prenom"/>

</li>

</ul>

</xsl:template >

</xsl:stylesheet>

</code>




Voici la signification de cette feuille XSL

* Le premier tag <xsl:template> permet d'appliquer une transformation à l'ensemble du document (la valeur "/" de l'attribut match indique l'élément racine du document XML). Ce tag contient des balises HTML qui seront transmises dans l'arbre résultat

* L'élément <xsl:apply-templates/> indique le traitement de tous les enfants directs de la racine.

* La balise <xsl:template match="personne" > permet d'aller traiter les éléments de type personne

* Enfin les deux éléments <xsl:value-of select="nom"/> et <xsl:value-of select="prenom"/> permettent de recuperer les valeurs des balises nom et prenom

====== Exemple ======
<code>
<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl">

<xsl:template match="/">

<html>

<head>

<META http-equiv="Content-Type" content="text/html;charset=utf-8" />

<style type="text/css">

body {

font:13px arial,helvetica,clean,sans-serif;

*font-size:small;

*font:x-small;

}


table {

font-size:inherit;font:100%;
border-width: 1px;
border-spacing: 5px ;

border-style: outset;
border-color: #a3c0e8;
border-collapse: collapse;

background-color: white;

text-align:center;

margin-left: 20px;

}

th {

background:#e2f0ff;
color:#283b56;
border-width: 1px;
padding: 5px;

border-style: inset;

border-color: #a3c0e8;

-moz-border-radius: ;

}

td {
border-width: 1px;
padding: 5px;
border-style: inset;
border-color: #a3c0e8;
-moz-border-radius: ;
}


h1 {

font-family:Arial, Helvetica, sans-serif;

font-size:13px;

font-weight:normal;

<!--FONT-VARIANT: small-caps;-->

color: #000000;

}

h2 {
font-family:Arial, Helvetica, sans-serif;
font-size:13px;
font-weight:normal;
<!--FONT-VARIANT: small-caps;-->
color: #000000;
}
.table_row {
background: White;
}

.table_row_alt {
background: #e2f0ff;
}

</style>
</head>
<body>

<h1>Variation des Flux Internes</h1>
<table>
<tr class="table_row_alt">
<th>ValueDate</th>
<th>BalanceJ</th>
<th>Variation</th>
</tr>
<xsl:for-each select="NewDataSet/Table">
<tr>
<xsl:attribute name="class">
<xsl:choose>
<xsl:when test="position() mod 2 = 1">table_row</xsl:when>
<xsl:when test="position() mod 2 = 0">table_row_alt</xsl:when>
</xsl:choose>
</xsl:attribute>
<td>
<xsl:value-of select='substring(ValueDate,1,10)'/>
</td>
<td>
<xsl:value-of select='format-number(BalanceJ, "### ### ##0.##")'/>
</td>

<td>

<xsl:value-of select='format-number(Variation, "### ### ##0.##")'/>

</td>

</tr>

</xsl:for-each>

</table>
<br />
<br />
<br />
<br />

<div style="color: gray; text-align: center;">

Contact : <a href="mailto:LD-ETU-ETRESO" style="color: gray">LD-ETU-ETRESO</a>

</div>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
</code>

===== For Each avec Select =====

<code>

<xsl:for-each select="NewDataSet/Table[Variation &gt; 50000000 or Variation &lt; -50000000]">

<tr>
<td>
<xsl:value-of select='substring(ValueDate,1,10)'/>
</td>
<td>
<xsl:value-of select='format-number(BalanceJ, "### ### ### ##0.##")'/>
</td>
<td>
<xsl:value-of select='format-number(Variation, "### ### ### ##0.##")'/>
</td>
</tr>
</xsl:for-each>
</code>

{{tag>XML XSLT}}

===== DTD ======

http://www.commentcamarche.net/contents/1330-presentation-des-dtd

==== Présentation =====

XML permet d'utiliser un fichier afin de vérifier qu'un document XML est conforme à une syntaxe donnée. La norme XML définit ainsi une définition de document type appelée DTD (Document Type Definition), c'est-à-dire une grammaire permettant de vérifier la conformité du document XML. La norme XML n'impose pas l'utilisation d'une DTD pour un document XML, mais elle impose par contre le respect exact des règles de base de la norme XML.

Ainsi on parlera de:

 * document valide pour un document XML comportant une DTD

 * document bien formé pour un document XML ne comportant pas de DTD mais répondant aux règles de base du XML 

Une DTD peut être définie de 2 façons :

  * sous forme interne, c'est-à-dire en incluant la grammaire au sein même du document

  * sous forme externe, soit en appelant un fichier contenant la grammaire à partir d'un fichier local ou bien en y accédant par son URL

Pour définir un élément on utilisera la syntaxe suivante :

  <! ELEMENT Nom Modèle >

Le paramètre modèle représente soit un type de donnée prédéfini, soit une règle d'utilisation de l'élément.

Les types prédéfinis utilisables sont les suivants :


|Type prédéfini|Description|

|ANY|L'élément peut contenir tout type de données|

|EMPTY|L'élément ne contient pas de données spécifiques|

|#PCDATA|L'élément doit contenir une chaîne de caractères|

Commentaires

Enregistrer un commentaire

Posts les plus consultés de ce blog

Base de Données Sybase IQ

Par -
Introduction Stockage colonnes et Sybase IQ * Sybase IQ stocke les données "en colonnes" et non "en lignes" * Sybase IQ compresse les données * Sybase IQ dispose de procédés d'indexation "bitmap" et "bitwise" * Sybase IQ dispose d'un grand nombre de méthodes d'accès et de jointures (hash join, sort merge, ...) * Sybase IQ n'utilise pas un journal de transactions pour assurer la cohérence de la base lors des mises à jour, mais conserve les différentes versions des pages de données modifies (les mises à jour ensemblistes sont alors plus rapides mais la concurrence d'accès sur une même table est très limitée) Sybase IQ a pour objectif d'exécuter très rapidement des requêtes d'interrogation sur des grosses volumétries, mais ne supporte pas des mises à jour concurrentes sur une même table. La mise à jour d'une base Sybase IQ s'effectuera donc soit périodiquement par un traitement batch, ou en continu par u...
Lire la suite

Sécurité des Applications

Par -
Introduction à la sécurité Outils pour la sécurité Les outils pour la sécurité recouvrent des notions à peu près identiques quelque soit le domaine de l'informatique que l'on considère. Les catégories développées ici sont présentes dans les trois problématiques traités dans la suite : le code, le réseau et les applications web. Les outils de contrôle d'accès et de filtrage Notions : contrôle d'accès discrétionnaire, ressources informatiques, règles d'accès, chaînage de droits, authentification forte, les trois types d'authentifications, architectures de contrôle d'accès, filtrage des flux. Le contrôle d'accès : c'est permettre à un sujet d'accéder à un système sous certaines conditions et d'effectuer un certain nombre d'opérations sur un objet défini. Ceci doit théoriquement permettre d'envisager tous les situations d'accès possibles mais la multiplication des sujets, des objets et des règles rend une vision globale difficile. Le ...
Lire la suite

Principes de la Programmation Orientée Objet

Par -
Principes Généraux : Objet et Classe Un objet est un concept de programmation qui groupe des fonctionnalités dans une entité, entité qui peut ensuite être créée à la demande. Une classe est l'implémentation d'un objet, c'est-à-dire une unité de code contenant les attributs et fonctions décrivant un objet. Encapsulation L'encapsulation consiste d'une part, à regrouper au sein d'une même entité (la classe), des propriétés et méthodes (les attributs) et d'autre part à définir la visibilité de ces attribvutes (privé, protege...) de façon à présenter une interface permettant de manipuler une classe sans en connaitre le fonctionnement interne. L’encapsulation permet de faire voir l’objet à l’extérieur comme une boîte noire ayant certaines attributs (proriétés et fonctions) et ayant un comportement spécifié. La manière dont ces propriétés ont été implémentées est alors cachée aux utilisateurs de la classe. L’implémentation peut être modifiée sans changer le comport...
Lire la suite