Perl et les fichiers XML

C'est une spécification de la norme W3C (World Wide Web Consortium) afin de structurer un document XML sous forme d'arbre afin de simplifier l'accès aux éléments, au contenu…

La méthode SAX est basée sur un modèle événementiel, qui transforme un document XML en un flux d'évènements déclenchés par la lecture d'éléments syntaxiques XML (balise ouvrante, balise fermante…). Elle permet de manipuler un nœud du document XML à la fois, ce qui facilite le traitement de gros fichiers XML.

Les méthodes SAX et DOM adoptent chacune une stratégie d'analyse différente. La méthode DOM charge l'intégralité d'un document XML dans une structure de données qui peut alors être manipulée facilement. L'inconvénient ? Le fichier entier doit être stocké en mémoire, ce qui peut poser des problèmes si celui-ci est volumineux. La méthode SAX apporte alors une alternative dans les cas de figure où les documents XML sont de taille très importante. Elle nous permet de traiter uniquement ce qui est nécessaire. Notez que la méthode SAX peut avoir aussi un inconvénient ! En fait, il se peut qu'on ait besoin d'informations liées mais ne se trouvant pas dans les mêmes nœuds. La mise en place du parseur peut donc devenir très compliquée.

N.B. Notez qu'en Perl, il existe un module très intelligent qui est capable de gérer très facilement les deux .

Voici une liste non exhaustive des modules Perl nous permettant d'analyser et modifier des fichiers XML.
Nous ne les citerons pas tous car il en existe des centaines , mais voici les plus utilisés !

• XML::Simple

Il a été conçu par Grant McLean, son but premier était de lire et mettre à jour des fichiers de configuration écrits en XML. Mais il peut être utilisé pour parser des fichiers XML simples. Tout est chargé en mémoire dans un hash. Notez bien que le mot "Simple" (de XML::Simple) signifie des fichiers avec une architecture simple. Il ne supporte pas des contenus mixés, exemple :

<document>
    <para>This is <em>mixed</em> content.</para>
</document>

Pour en savoir plus, veuillez vous referer à la FAQ XML::SimpleFAQ du module XML::Simple

• XML::XPath

Il a été conçu par Matt Sergeant et est le premier module Perl implémentant la méthode DOM et supportant XPath. Nous ne le vous recommandons pas car il n'est plus maintenu et est à ce jour moins efficace que d'autres modules comme XML::LibXML utilisant DOM et XPath.

• XML::DOM

Il a été conçu par Enno Derksen et est le premier module Perl implémentant DOM. Il est à peine maintenu par T.J. Mather. XML::LibXML devrait être utilisé à sa place.

• XML::SAX

Il est maintenu par Grant McLean. Il comprend un certain nombre de méthodes dont vous pouvez avoir besoin si vous travaillez avec SAX.
Les auteurs de la spécification SAX Perl et des modules qui l'implémentent sont Ken MacLeod, Matt Sergeant, Kip Hampton et Robin Berjon.

• XML::Parser

Il a été conçu par Larry Wall et est maintenu actuellement par Clark Cooper, Matt Sergeant. Il est rapide, et de bas niveau. Il est basé sur la librairie Expat. Néanmoins, il est vraiment très difficile à prendre en main et à ce jour, il est préférable d'utiliser l'un des deux modules suivant :

• XML::LibXML plus rapide ;
• XML::Twig facilement utilisable.

Il est maintenu par Jan Krynicky. Ce module est basé sur XML::Parser. Il vous permet de spécifier des actions à exécuter une fois qu'une balise est entièrement analysée (y compris les sous-balises) et transmet les données produites par les actions à ceux qui sont attachés aux balises mères.

• XML::LibXML (recommandé)

Il a été conçu par Matt Sergeant et Christian Glahn et est activement maintenu par Petr Pajas. Il est rapide, complet et stable. Depuis la version 1.70 datant de 2009, Petr Pajas ne maintenait plus le module. Il a été repris par Shlomi Fish qui le maintient activement. À ce jour (25/05/2013), nous sommes à la version « 2.0018 » et le module a beaucoup évolué.

Il peut être utilisé dans un contexte validant ou non validant et utilise DOM sous le support XPath. Sa méthode DOM et la gestion de la mémoire ont été écrites en C (il utilise libxml2 écrit en C) offrant ainsi des performances intéressantes. Il permet également de faire très facilement des transformations XSL en la combinant au module XML::LibXSLT (qui utilise la librairie écrite en C libxslt).

• XML::Twig (recommandé)

Il a été conçu par Michel Rodriguez. Il est stable, performant, simple d'utilisation et activement maintenu. Il fait partie des modules intelligents en ce sens que l'on peut faire du DOM en chargeant tout en mémoire, ou même parser uniquement des portions d'un fichier en ne chargeant en mémoire que ces dernières ! Il est également recommandé pour tous les fichiers XML, surtout les très gros ! Il comprend énormément de méthodes (une centaine !) permettant de jouer avec le fichier XML. Il peut également parser facilement des fichiers xhtml. Il est basé sur XML::Parser, lui-même basé sur Expat. C'est un parseur non validant.

Ce module permet de charger entièrement le fichier en mémoire sous forme d'arbre. En fait, il est stocké dans un hash. Les quelques lignes suivantes suffisent pour charger le fichier XML

my $parser = XML::Simple->new( KeepRoot => 1 );
my $doc = $parser->XMLin('ExempleXML.xml');

Si vous souhaitez voir l'architecture du hash, vous pouvez utiliser le module Data::DumperData::Dumper. C'est important, car en fonction du fichier XML, l'architecture n'est pas la même.

use Data::Dumper;
print Dumper $doc;

Voici le script complet

#!/usr/bin/perl
use strict;
use warnings;
use XML::Simple;
my $parser = XML::Simple->new( KeepRoot => 1 );
            
# Création du fichier résultat
my $FichierResulat = 'resultat.txt';
open( my $FhResultat, '>', $FichierResulat )
  or die("Impossible d'ouvrir le fichier $FichierResulat\n$!");
my $doc = $parser->XMLin('ExempleXML.xml');
            
# Tout le fichier XML est dans $doc sous forme d'arbre
foreach my $personne ( @{ $doc->{annuaire}->{personne} } ) {
 print {$FhResultat} 'Personne : ';
 print {$FhResultat} $personne->{prenom};
 print {$FhResultat} "\t";
 print {$FhResultat} $personne->{miseajour};
 print {$FhResultat} "\nRole : ";
 print {$FhResultat} $personne->{'role'};
 print {$FhResultat} "\nEmail : ";
 print {$FhResultat} $personne->{email};
 print {$FhResultat} "\nTelephone : ";
 print {$FhResultat} str_if( $personne->{'telephone'}, '' );
 if ( $personne->{langage} ) {
  print {$FhResultat} "\nlangage preferes : ";
  langage_process( $personne->{langage} );
 }
 print {$FhResultat} "\nCommentaire : ";
 print {$FhResultat} $personne->{commentaire};
 print {$FhResultat} "\n", "=" x 10, "\n\n";
}
            
# Fermeture du fichier
close($FhResultat);
            
#==============
# Procédures
#==============
sub is_array {
 my ($var) = @_;
 return ( ref($var) eq 'ARRAY' );
}
            
sub str_if {
 my ( $str, $default ) = @_;
 return $default unless $str;
 return $str;
}
            
sub langage_process {
 my ($langage) = @_;
 print {$FhResultat} str_if( $langage->{name}, '' );
 return unless $langage->{ModulePreferes};
 if ( is_array( $langage->{ModulePreferes} ) ) {
  foreach my $module ( @{ $langage->{ModulePreferes} } ) {
   module_process($module);
  }
 }
 else {
  module_process( $langage->{ModulePreferes} );
 }
}
            
sub module_process {
 my ($module) = @_;
 print {$FhResultat} "\n\t- $module";
}

En lisant ce script, vous pouvez remarquer qu'il suffit de parcourir le hash pour lire les informations. C'est tout ! Nous vous recommandons ce module pour les fichiers XML très simples, sans attribut.

<balise nom="attribut">text</balise>

Dans le cas contraire, vous pourrez avoir de mauvaises surprises dans l'architecture du hash. Par exemple, supposons le fichier suivant :

<data>
  <toto name="att1">data1</toto>
  <toto name="att2">data2</toto>
</data>

XML::Simple aura pour contenu de hash ceci :

$VAR1 = {
          'toto' => {
                    'att1' => {
                              'content' => 'data1'
                            },
                    'att2' => {
                              'content' => 'data2'
                            }
                  }
        };

Si votre fichier ressemble à ceci

<data>
  <toto name="att1">data1</toto>
</data>

Vous obtiendrez

$VAR1 = {
          'toto' => {
                    'content' => 'data1',
                    'name' => 'att1'
                  }
        };

Vous constatez que le rendu est différent. Donc faites attention.

Si pour une raison quelconque vous souhaitez créer un fichier XML, vous pouvez utiliser la méthode XMLout du module. Voici un exemple de code

#! /usr/bin/perl
use strict;
use warnings;
use XML::Simple;
my $parser = XML::Simple->new( NoAttr=>1, RootName=>'data' );
my $doc = $parser->XMLout( 
  { 
  toto => {
    tutu => 1
  },
  'country'=>'Angleterre',
  'capital'=>'Londres',
  } 
);
print $doc;

<data>
  <capital>Londres</capital>
  <country>Angleterre</country>
  <toto>
    <tutu>1</tutu>
  </toto>
</data>

Voilà, pour en savoir plus sur ce module, CPAN est votre ami !

N.B. Ce module à ma connaissance est incapable de faire une vérification DTD ou XSD Donc, il ne se préoccupe pas de l'information fournie dans le fichier XML.

Ce module XML::LibXMLXML::LibXML est vraiment le plus puissant, le plus rapide et le plus complet. Il vous permet de vérifier votre fichier XML en fonction de la DTD renseignée. Il est également possible de faire une vérification en fonction d'un fichier XSD. Vous le remarquerez dans le script d'exemple. Voici le script d'exemple

#!/usr/bin/perl
use strict;
use warnings;
use XML::LibXML;
            
my $FichierXML = 'ExempleXML.xml';
my $parser     = XML::LibXML->new();
            
# Activation validation DTD du fichier XML avant le parsing
$parser->validation(1);
my $tree = $parser->parse_file($FichierXML);
            
# Création du fichier résultat
my $FichierResulat = 'resultat.txt';
open( my $FhResultat, '>', $FichierResulat )
  or die("Impossible d'ouvrir le fichier $FichierResulat\n$!");
            
# Racine du document XML
my $root = $tree->getDocumentElement;
            
# Validation XSD du fichier XML
# Récupérons le fichier XSD dans la balise annuaire
my $FichierXSD = $root->getAttribute('xsi:noNamespaceSchemaLocation');
my $schema = XML::LibXML::Schema->new( location => $FichierXSD );
eval { $schema->validate($tree) };
die "[XSD] Le fichier $FichierXML est non valide.\n$@" if $@;
            
# Balise personne
my @personne = $root->getElementsByTagName('personne');
foreach my $childid (@personne) {
 print {$FhResultat} "Personne : ",
   $childid->getElementsByTagName('prenom')->[0]->getFirstChild->getData, " ",
   $childid->getAttribute('miseajour'), "\n";
 print {$FhResultat} "Role : ",  $childid->getElementsByTagName('role')->[0]->getFirstChild->getData,  "\n";
 print {$FhResultat} "Email : ", $childid->getElementsByTagName('email')->[0]->getFirstChild->getData, "\n";
 foreach my $telephone ( $childid->getElementsByTagName('telephone') ) {
  print {$FhResultat} "Telephone : ", $telephone->getFirstChild->getData, "\n";
 }
 foreach my $langage ( $childid->getElementsByTagName('langage') ) {
  print {$FhResultat} "Langage prefere : ", $langage->getAttribute('name'), "\n";
 }
 foreach my $modules ( $childid->getElementsByTagName('ModulePreferes') ) {
  print {$FhResultat} "\t- ", $modules->getFirstChild->getData, "\n";
 }
            
 # commentaire
 print {$FhResultat} "Commentaire : ",
   $childid->getElementsByTagName('commentaire')->[0]->getFirstChild->getData,
   "\n";
 print {$FhResultat} "\n", "=" x 10, "\n\n";
}
close($FhResultat);

Le code est assez commenté pour être compris ! Vous remarquerez juste qu'on a activé la validation du fichier DTD en une ligne.

$parser->validation(1);

Il est important de mettre cette ligne avant le parsing du XML

my $tree = $parser->parse_file($FichierXML);

Si vous la mettez après, la vérification ne sera pas faite !

En ce qui concerne la vérification XSD de notre fichier XML, le module le fait très bien également. Il nous suffit de récupérer le nom du fichier XSD dans le fichier XML, puis de faire une vérification. C'est très simple :

# Validation XSD du fichier XML
# Récupérons le fichier XSD dans la balise annuaire
my $FichierXSD = $root->getAttribute('xsi:noNamespaceSchemaLocation');
my $schema = XML::LibXML::Schema->new( location => $FichierXSD );
eval { $schema->validate($tree) };
die "[XSD] Le fichier $FichierXML est non valide.\n$@" if $@;

Comme cela a été dit, ce module peut même vous permettre de convertir rapidement votre fichier XML en un fichier XSL. Il vous suffit de voir la documentation du module XML::LibXSLTXML::LibXSLT.

C'est un module vraiment simple à utiliser. Il est très riche et permet de jouer avec le XML. Le seul inconvénient (qui n'en est pas un), c'est qu'il est non validant, c'est-à-dire qu'il est impossible via XML::Twig de valider votre fichier XML via un fichier DTD ou XSD. De toute façon, il vaut mieux le valider avant en utilisant un autre module avant même de commencer à le parser.

Voici les scripts complets utilisant XML::Twig en simulant DOM ou non.

#!/usr/bin/perl
use strict;
use warnings;
use XML::Twig;
my $FichierXML = 'ExempleXML.xml';
            
# Parsing façon DOM, tout en mémoire
my $twig = new XML::Twig;
            
# Création du fichier résultat
my $FichierResulat = 'resultat.txt';
open( my $FhResultat, '>', $FichierResulat )
  or die("Impossible d'ouvrir le fichier $FichierResulat\n$!");
            
# Création d'un objet twig
$twig->parsefile($FichierXML);
            
# racine du XML
my $root = $twig->root;
            
# Chaque personne
foreach my $TwigPersonne ( $root->children ) {
            
 # prenom et mise à jour
 print {$FhResultat} "Personne : ", $TwigPersonne->field('prenom'), ' ', $TwigPersonne->att('miseajour'), "\n";
            
 # role, email, téléphone, etc.
 print {$FhResultat} "Role : ",  $TwigPersonne->field('role'),  "\n";
 print {$FhResultat} "Email : ", $TwigPersonne->field('email'), "\n";
 if ( my $Telephone = $TwigPersonne->field('telephone') ) {
  print {$FhResultat} "Telephone : $Telephone\n";
 }
 if ( my $TwigLangage = $TwigPersonne->first_child('langage') ) {
  print {$FhResultat} "Langage prefere : ", $TwigLangage->att('name'), "\n";
            
  # Module preferes
  foreach my $TwigModule ( $TwigLangage->children('ModulePreferes') ) {
   print {$FhResultat} "\t- ", $TwigModule->text, "\n";
  }
 }
            
 # commentaire
 print {$FhResultat} "Commentaire : ", $TwigPersonne->field('commentaire'), "\n";
 print {$FhResultat} "\n", "=" x 10, "\n\n";
}
close($FhResultat);

#!/usr/bin/perl
use strict;
use warnings;
use XML::Twig;
my $FichierXML = 'ExempleXML.xml';
            
# Parsing façon intelligente en ne chargeant que le strict nécessaire en mémoire
# Utilisation des handlers
my $twig = new XML::Twig(
 Twig_handlers => {
  'personne' => \&personne,
 },
);
            
# Création du fichier résultat
my $FichierResulat = 'resultat.txt';
open( my $FhResultat, '>', $FichierResulat )
  or die("Impossible d'ouvrir le fichier $FichierResulat\n$!");
            
# Création d'un objet twig
$twig->parsefile($FichierXML);
            
# Fermeture du fichier
close($FhResultat);
            
sub personne {
 my ( $twig, $TwigPersonne ) = @_;
            
 # prenom et mise à jour
 print {$FhResultat} "Personne : ", $TwigPersonne->field('prenom'), ' ', $TwigPersonne->att('miseajour'), "\n";
            
 # role, email, telephone, etc.
 print {$FhResultat} "Role : ",  $TwigPersonne->field('role'),  "\n";
 print {$FhResultat} "Email : ", $TwigPersonne->field('email'), "\n";
 if ( my $Telephone = $TwigPersonne->field('telephone') ) {
  print {$FhResultat} "Telephone : $Telephone\n";
 }
 foreach my $TwigLangage ( $TwigPersonne->children('langage') ) {
  print {$FhResultat} "Langage prefere : ", $TwigLangage->att('name'), "\n";
            
  # Module preferes
  foreach my $TwigModule ( $TwigLangage->children('ModulePreferes') ) {
   print {$FhResultat} "\t- ", $TwigModule->text, "\n";
  }
 }
            
 # commentaire
 print {$FhResultat} "Commentaire : ", $TwigPersonne->field('commentaire'), "\n";
 print {$FhResultat} "\n", "=" x 10, "\n\n";
            
 # vide de la mémoire le contenu de la balise personne
 $twig->purge;
 return;
}

Comme vous pouvez le constater, nous avons fait deux scripts différents. Le premier charge tout le fichier en mémoire. Vous n'avez ensuite plus qu'à travailler sur l'objet twig (mais de façon beaucoup plus propre qu'avec XML::Simple ). Tout est correctement mis à votre disposition de façon simple et logique.

Dans le script 2 (ParseurXMLTwig.pl), nous utilisons une petite merveille de Twig, Twig_handlers. Avec les Twig_handlers, il est possible de dire à Twig, d'effectuer certaines tâches lorsqu'il se trouve dans certaines balises. C'est le cas dans notre exemple. Il parse le contenu des balises "personne" que l'on supprime de la mémoire grâce à la méthode purge. Il y a une multitude de méthodes pour indenter du code, stopper le parsing, etc. Consultez la documentation du CPAN et surtout le site du créateur du module. Vous y trouverez des exemples de scripts et des explications.