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

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

<?xml version="1.0" encoding="UTF-8"?>
<!--m1.xml-->
<module>
    <titre>Module 1</titre>
    ...
    <grain>g1</grain>
    <grain>g2</grain>
</module>
<?xml version="1.0" encoding="UTF-8"?>
<!--m2.xml-->
<module>
    <titre>Module 2</titre>
    ...
    <grain>g3</grain>
    <grain>g2</grain>
</module>
<?xml version="1.0" encoding="UTF-8"?>
<!--g1.xml-->
<grain>
    <titre>Grain 1</titre>
    ...
</grain>
<?xml version="1.0" encoding="UTF-8"?>
<!--g2.xml-->
<grain>
    <titre>Grain 2</titre>
    ...
</grain>
<?xml version="1.0" encoding="UTF-8"?>
<!--g3.xml-->
<grain>
    <titre>Grain 3</titre>
    ...
</grain>

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.

Utiliser la fonction document() dans XSLT pour récupérer le titre des grains.

Principales instructions XSLT

<?xml version="1.0" encoding="UTF-8"?>
<!--module.xsl-->
<!-- Feuille XSLT permettant de transformer un module en index.html pointant sur ses grains -->
<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"?>
<!--grain.xsl-->
<!-- Feuille XSLT permettant de transformer un grain en fichier HTML -->
<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>
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.
<?xml version="1.0" encoding="UTF-8"?>
<!--module1.ant-->
<!-- Script Ant ne sachant transformer que le module 1, en énumérant explicitement toutes les transformation 
  si un grain est ajouté au module m1.xml, ce fichier Ant doit également être modifié -->
<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>
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)
Paramétrer un script Ant
Usages Ant/XSLT
<?xml version="1.0" encoding="UTF-8"?>
<!--main.ant-->
<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"?>
<!--module_ant.xsl-->
<!-- Feuille XSLT permettant de transformer un module en index.html pointant sur ses grains -->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"    
    version="1.0">
    
    <xsl:output method="xml"/>
    
    <xsl:template match="/">
        <project basedir=".." name="grains">            
            <xsl:apply-templates select="module/grain"/>
        </project>      
    </xsl:template>
    
    <xsl:template match="grain">
        <xsl:param name="in">${basedir}/grains/<xsl:value-of select="."/>.xml</xsl:param>
        <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>
Un exemple partiel de solution
ant.zip
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.
On utilisera FO.
 On procédera à une transformation intermédiaire XML vers XML permettant d'internaliser les grains dans leur module.
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.
AccueilExercices > Travaux pratiques Ant > Exercice : Une chaîne éditoriale avec ANT< PrécédentSuivant >