Ant : Automatiser l`exécution de transformations XSLT

Transcription

Ingénierie Documentaire
Ant : Automatiser
l'exécution de
transformations
XSLT
http://doc.crzt.fr
STÉPHANE CROZAT
16 octobre 2014
Table des
matières
I - Introduction à Ant
5
A. Présentation d'Apache Ant..............................................................................5
B. Fonctionnement d'un script Ant.......................................................................6
C. Exemple de tâches Ant..................................................................................7
D. Paramétrer un script Ant................................................................................7
II - Ant et XSLT
9
A. La tâche "xslt'".............................................................................................9
B. Usages Ant/XSLT...........................................................................................9
III - Exercices
11
A. Travaux pratiques Ant..................................................................................11
1. "Hello World !" en Ant......................................................................................................11
2. Une chaîne éditoriale avec ANT.........................................................................................11
Solution des exercices
15
Contenus annexes
19
3
Introduction à
Ant
I-
I
Présentation d'Apache Ant
5
Fonctionnement d'un script Ant
6
Exemple de tâches Ant
7
Paramétrer un script Ant
7
A. Présentation d'Apache Ant
Définition
ANT est un langage XML permettant d'automatiser des tâches, telles que
l'exécution de programmes XSLT, la copie de fichiers, l'archivage, ... C'est un
langage comparable à make.
ANT est distribué par Apache sous licence libre.
http://ant.apache.org/1
Exemple
1
2
3
4
5
<project name="MyProject" default="main">
<target name="main">
<echo message="Hello World !"/>
</target>
</project>
Syntaxe : Lancement d'un script ANT
1
ant -buildfile fichier.ant
Fondamental
http://ant.apache.org/manual/2
1 - http://ant.apache.org/
2 - http://ant.apache.org/manual/
5
Introduction à Ant
Introduction à Ant
B. Fonctionnement d'un script Ant
Structure d'un script Ant
Un script - ou projet - Ant correspond à un fichier XML dont l'élément racine est
<project>.
Un projet contient une ou plusieurs cibles <target>, dont l'une est la cible par
défaut qui sera "visée" au lancement du projet (attribut default de <project>).
Chaque cible contient un ensemble de tâches qui doit être exécuté lorsque la cible
est visée. Le nom de l'élément identifie la tâche : <echo>, <xslt>, <copy>,
<zip>...
Principe du chaînage des cibles
Une cible peut dépendre d'autres cibles (attribut depends de <target>).
Lorsqu'une cible dépend d'autres cibles, le moteur Ant les exécute avant d'exécuter
la cible initialement visée.
Fonctionnement des targets Ant (barlatier.developpez.com/eclipse/tutorial/ant)
6
6
Introduction à Ant
Exemple
1
2
3
4
5
6
7
8
<project name="MyProject" default="main" basedir="/home/stc/nf29">
<target name="main" depends="target1">
<echo message="Cible initialement visée"/>
</target>
<target name="target1">
<echo message="Cible préalablement exécutée"/>
</target>
</project>
Dans cet exemple la tâche target1 sera exécutée avant la tâche main, qui est la
tâche initialement appelée au lancement du programme.
Remarque : basedir
L'attribut basedir de <project> permet de définir le répertoire de travail par
défaut du script.
Complément
: Explication générale du fonctionnement d'Ant
http://barlatier.developpez.com/eclipse/tutorial/ant/#Lb3
C. Exemple de tâches Ant
Exemple

<ant>

Exécution de sous-scripts Ant
<delete> <mkdir> <copy> <move>...

Gestion de fichiers
<echo> <splash>

Affichage d'information
<zip> <unzip>

Compression, décompression de fichiers
<property>
Définition de constante
Remarque
Il est possible d'étendre ANT avec ses propres tâches écrites en Java (qui héritent
de la classe abstraite Task d'Ant).
D. Paramétrer un script Ant
Pour passer des paramètres à un script Ant :
1. Ajouter une property au début du script : <property name="module"
value="default"/>
2. Fixer la valeur de cette property au moment de l'appel au script grâce à la
syntaxe -Dproperty
3 - http://barlatier.developpez.com/eclipse/tutorial/ant/#Lb
7
Introduction à Ant
Introduction à Ant
Exemple
1
2
3
4
5
6
7
<?xml version="1.0" encoding="UTF-8"?>

<project>
<property name="p">Default</property>
<echo message="${p}"/>
</project>
1
2
3
4
$ ant -buildfile test.ant
Buildfile: /home/stc/Desktop/test.ant
[echo] Default
1
2
3
4
$ ant -buildfile test.ant -Dp Hello
Buildfile: /home/stc/Desktop/test.ant
[echo] Hello
8
8
II -
Ant et XSLT
II
La tâche "xslt'"
Usages Ant/XSLT
9
11
A. La tâche "xslt'"
Syntaxe : Exécution d'une XSLT
<xslt>
Complément
http://ant.apache.org/manual/Tasks/style.html4
B. Usages Ant/XSLT
Méthode
Ant est un complément simple à XSLT pour créer des chaînes de transformation
complètes sans recourir ni à une IHM, ni à un langage de programmation.
Méthode
: Enchaînement de transformations
Ant permet d'exécuter plusieurs transformations en série.
1
2
<xslt in="src/fic1.xml" out="tmp/fic1b.xml" style="xsl/transf1.xsl"/>
<xslt in="tmp/fic1b.xml" out="out/result.fo"
style="xsl/transf2.xsl"/>
Exemple
Traiter un fichier de scénarisation XML qui pointe des fichiers de contenu (par
exemple une map qui référence des topics en DITA, un paper qui pointe des
sections externalisées en Scenari/Optim) pour obtenir un fichier unique par
internalisation des fichiers pointés (grâce à la fonction XPath document) ; puis
appliquer une seconde transformation pour obtenir un fichier FO.
L'on pourra aussi ajouter la tâche permettant d'exécuter le rendu en PDF avec FOP
typiquement.
4 - http://ant.apache.org/manual/Tasks/style.html
9
Ant et XSLT
Ant et XSLT
Méthode
: Transformations en lot
Ant permet d'exécuter plusieurs transformations en lot, pour tous les fichiers d'un
répertoire par exemple.
1
<xslt basedir="src" destdir="out" extension=".html"
style="xsl/transf.xsl"/>
Exemple
Traiter un ensemble de sources XML pour produire un site Web, si chaque fichier
XML donne un fichier HTML.
Méthode
: Obtenir plusieurs résultats pour une seule source
Ant permet d'enchaîner plusieurs XSLT sur un même fichier XML afin d'obtenir
plusieurs résultats, liés entre eux.
1
2
<xslt in="src/xml1.xml" out="out/xml11.html" style="xsl/xsl1.xsl"/>
<xslt in="src/xml1.xml" out="out/xml12.html" style="xsl/xsl2.xsl"/>
Exemple
Pour produire une publication comprenant plusieurs fichiers résultant liés (une
publication temporalisée HTML5+Timesheet ou une publication paginée
XHTML+CSS3 par exemple), il est nécessaire d'appliquer plusieurs XSLT à un même
fichier XML.
Méthode
: Exécuter plusieurs XSLT en fonction d'un fichier XML
Ant permet d'appliquer une XSLT à un fichier XML source, afin d'obtenir un nouveau
fichier Ant qui contient plusieurs ordres de transformation, typiquement pour
chacun des fils pointés par le fichier XML source.
1
2
<xslt in="src/xml1.xml" out="ant/xml1.ant" style="xsl/xsl1.xsl"/>
<ant antfile="ant/xml1.ant"/>
Le fichier xml1.ant contenant lui même une série d'exécutions XSLT qui ont été
générées par xsl1.xsl.
1
2
3
<xsl:template match="topicref[@type='task']">
<xslt in="src/{@href}" out="out/{@ref}.html"
style="xsl/topic.xsl"/>
</xsl:template>
Exemple
Traiter un fichier de scénarisation XML qui pointe des fichiers de contenu pour
obtenir un site Web (une map DITA qui référence des topics, un paper
Scenari/Optim qui pointe des sections externalisées) :

en transformant le fichier de scénarisation en index.html

en générant un script Ant qui va transformer chacun des fils du fichier de
scénarisation en fichier HTML (pointé par le index.html)
10
10
III -
Exercices
III
Travaux pratiques Ant
21
A. Travaux pratiques Ant
1. "Hello World !" en Ant
Question 1
Installer et tester l'environnement Ant avec un script affichant "Hello Word !" dans
la console.
Question 2
Créer un fichier XML contenant une unique balise racine <helloWorld>. Créer une
XSLT le transformant en un fichier HTML affichant "Hello World !".
Automatiser la transformation avec Ant.
2. Une chaîne éditoriale avec ANT
[3h]
Soit le modèle UML représentant des modules d'UV (scénario) pouvant contenir des
grains de contenu (unité de contenu).
Modèle UML Module/Grain
Les modules possèdent un code, titre et un responsable. Les grains contiennent des
divisions qui contiennent un titre et du texte. Un texte est un ensemble de
paragraphes, avec éventuellement des mots en exergue et des mots étrangers.
11
Exercices
Exercices
Question 1
[Solution n°1 p 15]
Compléter le modèle UML. Écrire les schémas correspondant.
Produire des fichiers XML exemples valides : au minimum deux modules et trois
grains, avec un grain commun aux deux modules et un grain original par module.
Organiser les fichiers comme suit : un dossier src/modules pour les modules, un
dossier src/grains pour les grains
Question 2
Créer les transformations XSLT permettant de générer un site HTML pour un
module.
Le site contiendra un fichier index.html avec un sommaire pointant un fichier
HTML pour chaque grain.
Pour les grains on affichera les divisions sous la forme de blocs escamotables (en
cliquant sur le titre on affiche ou masque son contenu), et on posera une CSS
basique.
Indice :
Utiliser la fonction document() dans XSLT pour récupérer le titre des grains.
Principales instructions XSLT - p.19
Question 3
Créer un script Ant module1.ant permettant d'exécuter les transformations et
copies de fichiers (JavaScript et CSS) nécessaires au premier module (énumérer
toutes les copies et transformations une par une dans le fichier Ant).
Le fichier Ant est à déposer dans un dossier ant, le site résultant dans
result/site.
Question 4
Créer le script Ant main.ant prenant en paramètre un module et assurant les
tâches suivantes :
1. Créer un dossier result/site/$m (ou $m désigne le nom module)
2. Transforme le module en index.html dans son dossier
3. Transforme le module en script Ant permettant de lancer les transformation
de tous les grains qu'il contient et exécutant ce script
Le fichier Ant à exécuter aura été placé dans un dossier tmp qui aura été
vidé au début du script. Penser également à purger le répertoire result.
4. Effectue les copies de fichiers nécessaires (JavaScript et CSS typiquement)
Indice :
Paramétrer un script Ant
Usages Ant/XSLT
Question 5
Créer les XSLT et compléter le script Ant avec une nouvelle target pour générer les
PDF correspondant aux modules. L'accès aux PDF se fera à partir de l'index.html
d'un module.
Indices :
On utilisera FO.
12
12
Exercices
On procédera à une transformation intermédiaire XML vers XML permettant
d'internaliser les grains dans leur module.
Question 6
Ajouter l'accès à un fichier Smil permettant de visualiser chaque division de chaque
grain une par une.
Question 7
Créer un éditeur Scenari permettant de produire un module et ses grains. Créer la
transformation XML vers XML permettant de retrouver le schéma d'origine à partir
des fichiers créés par Scenari.
Finir d'automatiser avec Ant la chaîne permettant de générer l'ensemble des
supports à partir d'une saisie dans Scenari.
13
Solution des
exercices
> Solution n°1 (exercice p. 12)
1
2
3
4
5
6
7
8

<module>
<titre>Module 1</titre>
...
<grain>g1</grain>
<grain>g2</grain>
</module>
1
2
3
4
5
6
7
8

<module>
<titre>Module 2</titre>
...
<grain>g3</grain>
<grain>g2</grain>
</module>
1
2
3
4
5
6

<grain>
<titre>Grain 1</titre>
...
</grain>
1
2
3
4
5
6

<grain>
...
</grain>
1
2
3
4
5
6

<grain>
...
</grain>
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:output method="xml"/>
<xsl:template match="/">
<html>
<body>
<xsl:apply-templates select="module"></xsl:applytemplates>
</body>
</html>
</xsl:template>
<xsl:template match="module">
<h1><xsl:value-of select="titre"/></h1>
<xsl:apply-templates select="grain"/>
</xsl:template>
<xsl:template match="grain">
<p><a href="{.}.html"><xsl:value-of
select="document(concat('../grains/',.,'.xml'))/grain/titre"/></a></p
>
</xsl:template>
</xsl:stylesheet>


version="1.0">
<html>
<body>
<xsl:apply-templates select="grain"></xsl:applytemplates>
</body>
</html>
</xsl:template>
<h1><xsl:value-of select="titre"/></h1>
...
</xsl:template>
</xsl:stylesheet>
1
2

16
16
3
4
5
6
7
8
9
10

<project basedir=".." name="module1">
<xslt in="${basedir}/modules/m1.xml" out="$
{basedir}/result/site/index.html" xslresource="$
{basedir}/xsl/module.xsl"/>
<xslt in="${basedir}/grains/g1.xml" out="$
{basedir}/result/site/g1.html" xslresource="$
{basedir}/xsl/grain.xsl"/>
<xslt in="${basedir}/grains/g1.xml" out="$
{basedir}/result/site/g2.html" xslresource="$
{basedir}/xsl/grain.xsl"/>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<project basedir=".." name="main" default="default">
<property name="module" value="default"/>
<target name="default" depends="preparation">
<xslt in="${basedir}/modules/${module}.xml" out="$
{basedir}/result/site/index.html" xslresource="$
{basedir}/xsl/module.xsl"/>
<xslt in="${basedir}/modules/${module}.xml" out="$
{basedir}/tmp/tmp.ant" xslresource="${basedir}/xsl/module_ant.xsl"/>
<ant antfile="${basedir}/tmp/tmp.ant"/>
</target>
<target name="preparation">
<delete dir="${basedir}/tmp"></delete>
<delete dir="${basedir}/result"></delete>
<mkdir dir="${basedir}/tmp"/>
<mkdir dir="${basedir}/result"/>
<mkdir dir="${basedir}/result/site"/>
</target>
</project>


version="1.0">
<project basedir=".." name="grains">
<xsl:apply-templates select="module/grain"/>
</project>
</xsl:template>
<xsl:param name="in">${basedir}/grains/<xsl:value-of
select="."/>.xml</xsl:param>
17
18
19
20
21
22
23
<xsl:param name="out">${basedir}/result/site/<xsl:value-of
select="."/>.html</xsl:param>
<xsl:param name="xslt">${basedir}/xsl/grain.xsl</xsl:param>
<xslt in="{$in}" out="{$out}" xslresource="{$xslt}"/>
</xsl:template>
</xsl:stylesheet>
18
18
Contenus annexes
- Principales instructions XSLT
Fondamental : Les deux instructions de base


<xsl:apply-templates
select="XPATH"/> : Relance les règles du
programme sur le sous-arbre pointé par le select (fondement de la
récursivité)
<xsl:value-of select="XPATH"/> : Génère le texte contenu dans le nœud
ou attribut pointé par le select
{XPATH} : Génère le texte contenu dans le nœud ou attribut pointé par le
XPath entre accolades (alternative à xsl:value-of à utiliser dans la
génération
d'attributs
exclusivement,
par
exemple
:
<img
src="{@URIsrc}">
Autres instructions courantes

<xsl:copy-of select="XPATH"/> : Génère le sous-arbre pointé par le
select

<xsl:if test="XPATH">...</xsl:if> : Ne s'exécute que si test est vrai

<xsl:for-each
select="XPATH">...</xsl:for-each> :
chaque sous-arbre renvoyé par le select
Complément
Exécute
pour
: Extension XPath "document()"
document(chemin-accès) où chemin d'accès permet d'accéder à un fichier sur le
disque.
Par exemple :

document("c:\monfichier.xml")//x : Tous les éléments x présents dans le
fichier monfichier.xml.

document(child::source)/* : La racine du document XML pointé par
l'expression XPath child::source.
Complément
: Déclaration explicite sur la cible

<xsl:element name="">contenu</xsl:element>

<xsl:attribute name="">valeur</xsl:attribute>

<xsl:text>chaîne de caractère</xsl:text
Complément
: Référence
http://fr.selfhtml.org/xml/representation/elementsxslt.htm5
5 - http://fr.selfhtml.org/xml/representation/elementsxslt.htm
19
Contenus annexes
Complément
Contenus annexes
: Références synthétiques
https://developer.mozilla.org/fr/XSLT/Éléments 6
http://www.daniel-lemire.com/inf6450/mod3/xsltenbref.xhtml 7
http://personnel.univ-reunion.fr/fred/Enseignement/XML/intro-xslt.html 8
6 - https://developer.mozilla.org/fr/XSLT/%C3%89l%C3%A9ments
7 - http://www.daniel-lemire.com/inf6450/mod3/xsltenbref.xhtml
8 - http://personnel.univ-reunion.fr/fred/Enseignement/XML/intro-xslt.html
20
20

Ant : Automatiser l`exécution de transformations XSLT

Transcription

Documents pareils

document

Cote Titre Auteur Blues Gospel Jazz

BLUES GOSPEL JAZZ SOUL, FUNK, R`n`B

CSI 3525, Automne 2003, Devoir 4 Par equipe de deux

Comment puis-je identifier les transactions Ã

XML par la pratique

XML (eXtensivble Markup Language)

Programmation Web II