Ant : Automatiser l'exécution de transformations XSLT · Introduction à Ant 3 1. Présentation...

Ant : Automatiser l'exécution de

transformations XSLT

Stéphane Crozat

Ingénierie Documentairehttp://doc.crzt.fr

14 septembre 2016

Table des matières

I - Introduction à Ant 3

1. Présentation d'Apache Ant ........................................................................................................ 3

2. Fonctionnement d'un script Ant .............................................................................................. 3

3. Exemple de tâches Ant ............................................................................................................. 5

4. Paramétrer un script Ant ......................................................................................................... 5

5. Gestion d'exceptions en Ant ..................................................................................................... 6

II - Ant et XSLT 7

1. La tâche "xslt'" ......................................................................................................................... 7

2. Usages Ant/XSLT ...................................................................................................................... 7

3. Passer des paramètres aux XSLT ............................................................................................ 8

III - Exercices 10

1. Travaux pratiques Ant ............................................................................................................ 11

1.1. Exercice : "Hello World !" en Ant ................................................................................................................ 111.2. Exercice : Une chaîne éditoriale avec ANT ................................................................................................. 11

Solutions des exercices 14

Introduction à Ant

3

1. Présentation d'Apache Ant

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 <project name="MyProject" default="main">2 <target name="main">3 <echo message="Hello World !"/>4 </target>5 </project>

1 ant -buildfile fichier.ant

http://ant.apache.org/manual/

2. Fonctionnement 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 , dont l'une est la cible par défaut qui sera <target>

"visée" au lancement du projet (attribut de ).default <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>

Introduction à AntI

Définition

Exemple

Syntaxe : Lancement d'un script ANT

Fondamental

Structure d'un script Ant

<project name="MyProject" default="main"> <target name="main"> <echo message="Hello World !"/> </target></project>

ant -buildfile fichier.ant

http://ant.apache.org/

http://ant.apache.org/manual/

Fonctionnement d'un script Ant

4

Une cible peut dépendre d'autres cibles (attribut de ).depends <target>

Lorsqu'une cible dépend d'autres cibles, le moteur Ant les exécute d'exécuter la cible avantinitialement visée.

Fonctionnement des targets Ant (barlatier.developpez.com/eclipse/tutorial/ant)

1 <project name="MyProject" default="main" basedir="/home/stc/nf29">2 <target name="main" depends="target1">3 <echo message="Cible initialement visée"/>4 </target>5 <target name="target1">6 <echo message="Cible préalablement exécutée"/>7 </target>8 </project>

Dans cet exemple la tâche sera exécutée avant la tâche , qui est la tâche initialement target1 mainappelée au lancement du programme.

Principe du chaînage des cibles

Exemple

<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>

Exemple de tâches Ant

5

-

-

-

-

-

1.

2.

L'attribut de permet de définir le répertoire de travail par défaut du script.basedir <project>

http://barlatier.developpez.com/eclipse/tutorial/ant/#Lb

3. Exemple de tâches Ant

<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

Il est possible d'étendre ANT avec ses propres tâches écrites en Java (qui héritent de la classe abstraite d'Ant).Task

4. Paramétrer un script Ant

Pour passer des paramètres à un script Ant :

Ajouter une au début du script : property <property name="module" value="

default"/>

Fixer la valeur de cette au moment de l'appel au script grâce à la syntaxe property -

Dproperty

1 234 = Default5 =67

1 $ ant -buildfile test.ant2 Buildfile: /home/stc/Desktop/test.ant

Remarque : basedir

Complément : Explication générale du fonctionnement d'Ant

Exemple

Remarque

Exemple

<?xml version="1.0" encoding="UTF-8"?><project> = Default<property name "p"> </property> =<echo message "${p}"/></project>

$ ant -buildfile test.antBuildfile: /home/stc/Desktop/test.ant

http://barlatier.developpez.com/eclipse/tutorial/ant/#Lb

Gestion d'exceptions en Ant

6

3 [echo] Default4

1 $ ant -buildfile test.ant -Dp Hello2 Buildfile: /home/stc/Desktop/test.ant3 [echo] Hello4

5. Gestion d'exceptions en Ant

http://ant-contrib.sourceforge.net/tasks/tasks/trycatch.html

Gestion d'exceptions en Ant

[echo] Default

$ ant -buildfile test.ant -Dp HelloBuildfile: /home/stc/Desktop/test.ant [echo] Hello

http://ant-contrib.sourceforge.net/tasks/tasks/trycatch.html

Ant et XSLT

7

1. La tâche "xslt'"

<xslt>

http://ant.apache.org/manual/Tasks/style.html

2. Usages Ant/XSLT

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.

Ant permet d'exécuter plusieurs transformations en série.

1 <xslt in="src/fic1.xml" out="tmp/fic1b.xml" style="xsl/transf1.xsl"/>2 <xslt in="tmp/fic1b.xml" out="out/result.fo" style="xsl/transf2.xsl"/>

Traiter un fichier de scénarisation XML qui pointe des fichiers de contenu (par exemple une qui mapréférence des en DITA, un qui pointe des externalisées en Scenari/Optim) pour topics paper sectionsobtenir un fichier unique par internalisation des fichiers pointés (grâce à la fonction XPath

) ; puis appliquer une seconde transformation pour obtenir un fichier FO.document

L'on pourra aussi ajouter la tâche permettant d'exécuter le rendu en PDF avec FOP typiquement.

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"/>

Ant et XSLTII

Syntaxe : Exécution d'une XSLT

Complément

Méthode

Méthode : Enchaînement de transformations

Exemple

Méthode : Transformations en lot

<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"/>

<xslt basedir="src" destdir="out" extension=".html" style="xsl/transf.xsl"/>

http://ant.apache.org/manual/Tasks/style.html

Passer des paramètres aux XSLT

8

--

Traiter un ensemble de sources XML pour produire un site Web, si chaque fichier XML donne un fichier HTML.

Ant permet d'enchaîner plusieurs XSLT sur un même fichier XML afin d'obtenir plusieurs résultats, liés entre eux.

1 <xslt in="src/xml1.xml" out="out/xml11.html" style="xsl/xsl1.xsl"/>2 <xslt in="src/xml1.xml" out="out/xml12.html" style="xsl/xsl2.xsl"/>

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.

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 <xslt in="src/xml1.xml" out="ant/xml1.ant" style="xsl/xsl1.xsl"/>2 <ant antfile="ant/xml1.ant"/>

Le fichier contenant lui même une série d'exécutions XSLT qui ont été générées par xml1.ant

.xsl1.xsl

1 <xsl:template match="topicref[@type='task']">2 <xslt in="src/{@href}" out="out/{@ref}.html" style="xsl/topic.xsl"/>3 </xsl:template>

Traiter un fichier de scénarisation XML qui pointe des fichiers de contenu pour obtenir un site Web (une DITA qui référence des , un Scenari/Optim qui pointe des map topics paper sectionsexternalisées) :

en transformant le fichier de scénarisation en index.htmlen 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

3. Passer des paramètres aux XSLT

Il est possible de passer des variables à un programme XSLT depuis un script ANT.

Exemple

Méthode : Obtenir plusieurs résultats pour une seule source

Exemple

Méthode : Exécuter plusieurs XSLT en fonction d'un fichier XML

Exemple

<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"/>

<xslt in="src/xml1.xml" out="ant/xml1.ant" style="xsl/xsl1.xsl"/><ant antfile="ant/xml1.ant"/>

<xsl:template match="topicref[@type='task']"> <xslt in="src/{@href}" out="out/{@ref}.html" style="xsl/topic.xsl"/></xsl:template>

Passer des paramètres aux XSLT

9

1.

2. 3.

1 2 = = = =3 = = =4 = =5 6 = = =7 = =8 9

1 2 = =3 =4 =56 = = =7 =8 =9 =

10 =11 =12 = =13 14 15 16 17 18 19 2021

On passe donc un paramètre à l'aide de : <param name="Position" expression="5"/>

On le récupère dans le XSLT à l'aide de : <xsl:param name="Position"/>C'est utilisé dans l'exemple pour faire un test de position avec <xsl:if test="

position()=$Position">

Exemple : Côté ANT

Exemple : Côté XSLT

<?xml version="1.0" encoding="UTF-8"?> = = = =<project xmlns:bib "http://bibtexml.sf.net/" xmlns:op "utc.fr:ics/opale3" basedir "." name "ref">

= = =<xslt in "../out.xml" xslresource "../XSL/OneBibXMLToOpaleXml.xsl" out "../out1.xml"> = =<param name "Position" expression "1"/> </xslt> = = =<xslt in "../out.xml" xslresource "../XSL/OneBibXMLToOpaleXml.xsl" out "../out5.xml"> = =<param name "Position" expression "5"/> </xslt></project>

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

=xmlns:bib "http://bibtexml.sf.net/" =xmlns:op "utc.fr:ics/opale3">

= = =<xsl:output encoding "UTF-8" method "xml" indent "yes"/> =<xsl:param name "Position"/> =<xsl:template match "bib:file"> =<xsl:for-each select "bib:entry"> =<xsl:if test "position()=$Position"> =<sc:item xmlns:sc "http://www.utc.fr/ics/scenari/v3/core"> = =<op:bib xmlns:sp "http://www.utc.fr/ics/scenari/v3/primitive" xmlns:op "utc.fr:ics/opale3"> <op:bibM> </op:bibM> </op:bib> </sc:item> </xsl:if> </xsl:for-each> </xsl:template>

</xsl:stylesheet>

Exercices

10

ExercicesIII

Exercice : "Hello World !" en Ant

11

1. Travaux pratiques Ant1.1. Exercice : "Hello World !" en Ant

Question 1

Question 2

1.2. Exercice : 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.

Question 1

Installer et tester l'environnement Ant avec un script affichant "Hello Word !" dans la console.

Créer un fichier XML contenant une unique balise racine . Créer une XSLT le <helloWorld>

transformant en un fichier HTML affichant "Hello World !".

Automatiser la transformation avec Ant.

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 pour les modules, un dossier src/modules

pour les grainssrc/grains

[ ]solution n°1 *[ ] p.14

Exercice : Une chaîne éditoriale avec ANT

12

Question 2

Question 3

Question 4

Question 5

Créer les transformations XSLT permettant de générer un site HTML pour un module.

Le site contiendra un fichier avec un sommaire pointant un fichier HTML pour index.html

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 (cf. p.)


Créer un script Ant permettant d'exécuter les transformations et copies de fichiers module1.ant

(JavaScript et CSS) nécessaires au module (énumérer toutes les copies et transformations premierune par une dans le fichier Ant).

Le fichier Ant est à déposer dans un dossier , le site résultant dans .ant result/site


1. 2. 3.

4.

Créer le script Ant prenant en paramètre un module et assurant les tâches suivantes :main.ant

Créer un dossier (ou désigne le nom module)result/site/$m $m

Transforme le module en dans son dossierindex.html

Transforme le module en script Ant permettant de lancer les transformation de tous les grains qu'il contient et exécutant ce scriptLe fichier Ant à exécuter aura été placé dans un dossier qui aura été vidé au début du tmp

script. Penser également à purger le répertoire .result

Effectue les copies de fichiers nécessaires (JavaScript et CSS typiquement)

Indice :

Paramétrer un script Ant (cf. p.5)

Usages Ant/XSLT (cf. p.7)


Créer les XSLT et compléter le script Ant avec une nouvelle pour générer les PDF targetcorrespondant aux modules. L'accès aux PDF se fera à partir de l' d'un module.index.html

Indices :

On utilisera FO.

On procédera à une transformation intermédiaire XML vers XML permettant d'internaliser les grains dans leur module.

Exercice : Une chaîne éditoriale avec ANT

13

Question 6

Question 7

Ajouter l'accès à un fichier Smil permettant de visualiser chaque division de chaque grain une par une.

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.

Solutions des exercices

14Stéphane Crozat (Contributions : les étudiants de NF29)

Exercice p. 11> Solution n°1

1 234 Module 15 ...6 g17 g28

1 234 Module 25 ...6 g37 g28

1 234 Grain 15 ...6

1 234 Grain 25 ...6

1 234 Grain 35 ...6


<?xml version="1.0" encoding="UTF-8"?><module> Module 1<titre> </titre> ... g1<grain> </grain> g2<grain> </grain></module>

<?xml version="1.0" encoding="UTF-8"?><module> Module 2<titre> </titre> ... g3<grain> </grain> g2<grain> </grain></module>

<?xml version="1.0" encoding="UTF-8"?><grain> Grain 1<titre> </titre> ...</grain>

1 2345 = 6 =7 8 =9

10 =11 12 13 =14 15 16 17 18 =19 =20 = 21 22 23 =24 = =

/></a></p>25 26 27

1 2345 = 6 =7 8 =9

10 =11 12 13 =14 15 16 17 18 =19 =20 ... 21 22 23

<?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"/> =<xsl:template match "/"> <html> <body> =<xsl:apply-templates select "module"></xsl:apply-templates> </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>

<?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"/> =<xsl:template match "/"> <html> <body> =<xsl:apply-templates select "grain"></xsl:apply-templates> </body> </html> </xsl:template> =<xsl:template match "grain"> =<h1><xsl:value-of select "titre"/></h1> ... </xsl:template> </xsl:stylesheet>

1 234 56 = =7 = = =

/xsl/module.xsl"/>8 = = =

/xsl/grain.xsl"/>9 = = =

/xsl/grain.xsl"/>10

1 234 = = =56 = =78 = =9 = = =

"${basedir}/xsl/module.xsl"/>10 = = =

/xsl/module_ant.xsl"/>11 =12 1314 =15 =16 =17 =18 =19 = 20 21 2223

1 2345 = 6 =7 8 =9

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

= =<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>

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

= = =<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>

<?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"/>



10 =11 = = 12 =13 14 15 16 =17 = ${basedir}/grains/ = .xml18 = ${basedir}/result/site/ = .html19 = ${basedir}/xsl/grain.xsl 20 = = = 21 22 23

ant.zip (cf. )ant.zip

Exemple : Un exemple partiel de solution

=<xsl:template match "/"> = = <project basedir ".." name "grains"> =<xsl:apply-templates select "module/grain"/> </project> </xsl:template> =<xsl:template match "grain"> = ${basedir}/grains/ = .xml<xsl:param name "in"> <xsl:value-of select "."/> </xsl:param> = ${basedir}/result/site/ = .html<xsl:param name "out"> <xsl:value-of select "."/> </xsl:param> = ${basedir}/xsl/grain.xsl <xsl:param name "xslt"> </xsl:param> = = = <xslt in "{$in}" out "{$out}" xslresource "{$xslt}"/> </xsl:template> </xsl:stylesheet>

Ant : Automatiser l'exécution de transformations XSLT · Introduction à Ant 3 1. Présentation...

Documents

Transcript of Ant : Automatiser l'exécution de transformations XSLT · Introduction à Ant 3 1. Présentation...