I. Introduction

Le but de ce tutorial est de créer un fichier HTML sur base des fichiers XML et XSL qu'on lui donne. Il existe beaucoup de Processeur XML dans différents langages. En java, on retrouve Xalan-J et Xalan-C++ existe pour le C++. Mais le langage Python est très simple à apprendre et très puissant. Il est orienté objet et nous allons voir qu'en quelques lignes il est possible de réaliser notre exercice. Nous allons découvrir tout cela à notre aise et point par point.

Vous devez impérativement avoir des notions de python et il est préférable que vous connaissiez le XML et le XSL de manière à mieux comprendre cet exercice mais ce n'est pas indispensable.

Vous devez également avoir l'environnement Python ainsi que 4suite qui contient la bibliothèque PyXml.

II. Le fichier python.

 
Sélectionnez
from Ft.Lib.Uri import OsPathToUri
from Ft.Xml import InputSource
from Ft.Xml.Xslt import Processor
import os.path

"""
    Classe permettant la conversion en HTML d'un fichier XML grâce à
    son XSL
"""

class HtmlConverter:
    
    def __init__(self, xml, xsl):
        """
            Constructeur de HtmlConcerter.
            Prend deux noms de fichiers. Le premier est le
            fichier xml et le second est le fichier xsl
            qui ont permettre la creation du fichier html.
        """
        self.xmlFile = xml
        self.xslFile = xsl

    def toHtml(self, htmlFile):
        """
            Ecris dans un fichier HTML la transformation
            du fichier XML.
            Si True est retourné, c'est que tout c'est bien passé.
            Si False est retourné, des erreurs se sont produites.
        """
        if (os.path.exists(self.xslFile) == False):
            print ('Le fichier XSL n\'existe pas')
            return False
        if (os.path.exists(self.xmlFile) == False):
            print ('Le fichier XML n\'existe pas')
            return False
        styuri = OsPathToUri(self.xslFile)
        srcuri = OsPathToUri(self.xmlFile)
        STY = InputSource.DefaultFactory.fromUri(styuri)
        SRC = InputSource.DefaultFactory.fromUri(srcuri)
        proc = Processor.Processor()
        proc.appendStylesheet(STY)
        result = proc.run(SRC)
        try:
            fileResult = open(htmlFile,"w")
            fileResult.write(result)
            fileResult.close()
        except IOError:
            return False
        return True

if __name__ == "__main__":
    directory = "C:/Documents and Settings/jle/My Documents/SiteS/javascript/withxml/"
    xml = directory + "tutorial-xml-xsl-javascript.xml"
    xsl = directory + "tutorial-xml-xsl-javascript.xsl"
    html = directory + "tutorial-xml-xsl-javascript.html"
    htmlC = HtmlConverter(xml,xsl)
    print htmlC.toHtml(html)

Ci-dessus, le fichier python complet que vous pouvez appeler HtmlConverter. Nous allons découvrir pas à pas les différentes fonctions qu'apportent ce script. Il sera possible par la suite d'ajouter de nouvelles méthodes permettant de traiter plusieurs fichiers XML avec un XSL, mais je vous laisse cela en exercice.

 
Sélectionnez
  from Ft.Lib.Uri import OsPathToUri
  from Ft.Xml import InputSource
  from Ft.Xml.Xslt import Processor
  import os.path

Les 4 premières lignes importent les différents modules et classes nous avons besoin. « OsPathToUri » permet de transformer un String en un chemin de fichier. « InputSource » nous servira à construire un fichier sur base des strings passé. Le « Processor » est la classe qui va procéder à la transformation du XML.

 
Sélectionnez
  class HtmlConverter:
    
      def __init__(self, xml, xsl):
          self.xmlFile = xml
          self.xslFile = xsl

On va ensuite créer une classe avec un constructeur qui va prendre en paramètres le nom du fichier XML et le nom du fichier XSL. Il doit s'agir du chemin complet pour ces fichiers.

 
Sélectionnez
    def toHtml(self, htmlFile):
        if (os.path.exists(self.xslFile) == False):
            print ('Le fichier XSL n\'existe pas')
            return False
        if (os.path.exists(self.xmlFile) == False):
            print ('Le fichier XML n\'existe pas')
            return False
        styuri = OsPathToUri(self.xslFile)
        srcuri = OsPathToUri(self.xmlFile)
        STY = InputSource.DefaultFactory.fromUri(styuri)
        SRC = InputSource.DefaultFactory.fromUri(srcuri)
        proc = Processor.Processor()
        proc.appendStylesheet(STY)
        result = proc.run(SRC)
        try:
            fileResult = open(htmlFile,"w")
            fileResult.write(result)
            fileResult.close()
        except IOError:
            return False
        return True

Cette méthode, à qui on passe le nom du fichier HTML à créer, va réaliser la transformation du fichier XML. On commence par vérifier que les fichiers (XML et XSL) existent grâce à :

 
Sélectionnez
        if (os.path.exists(self.xslFile) == False):
            print ('Le fichier XSL n\'existe pas')
            return False
        if (os.path.exists(self.xmlFile) == False):
            print ('Le fichier XML n\'existe pas')
            return False

Ensuite, on crée les fichiers sur base de leur noms :

 
Sélectionnez
                styuri = OsPathToUri(self.xslFile)
        srcuri = OsPathToUri(self.xmlFile)
        STY = InputSource.DefaultFactory.fromUri(styuri)
        SRC = InputSource.DefaultFactory.fromUri(srcuri)

On crée le processeur XSLT, on lui passe le fichier XSL qui servira à la transformation et on récupère le résultat dans une variable « result ».

 
Sélectionnez
                proc = Processor.Processor()
        proc.appendStylesheet(STY)
        result = proc.run(SRC)

Ce résultat est ensuite écrit dans le fichier HTML.

La code suivant est juste le main qui va permettre de lancer la classe. Je crée ici les noms de fichiers, je crée la classe et j'appel la méthode de transformation.

 
Sélectionnez
if __name__ == "__main__":
    directory = "vers/mon/repertoire/"
    xml = directory + "tutorial-xml-xsl-javascript.xml"
    xsl = directory + "tutorial-xml-xsl-javascript.xsl"
    html = directory + "tutorial-xml-xsl-javascript.html"
    htmlC = HtmlConverter(xml,xsl)
    print htmlC.toHtml(html)

III. Conclusion

Utiliser le mode XSLT de python est assez simple à mettre en œuvre. Le résultat est plus que satisfaisant et la rapidité d'exécution est au rendez-vous. Python est un langage formidable auquel il faut s'attarder. Les sites web gagnent en maintenance et en temps de création grâce à XML-XSL et Python.

Vous pouvez récupérer le fichier python ainsi que les fichiers xml, xsl et javascript en faisant un clic droit et « Sauvegarder sous ».