#/usr/bin/perl
<<DOC;
Votre Nom :
JANVIER 2015
 usage : perl parcours-arborescence-fichiers repertoire-a-parcourir
 Le programme prend en entrée le nom du répertoire contenant les fichiers
 à traiter
 Le programme construit en sortie un fichier structuré contenant sur chaque
 ligne le nom du fichier et le résultat du filtrage :
<FICHIER><NOM>du fichier</NOM></FICHIER><CONTENU>du filtrage</CONTENU></FICHIER>
DOC
#-----------------------------------------------------------
my $rep="$ARGV[0]";
# on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;
# on initialise une variable contenant le flux de sortie
my $DUMPFULL1="";
my $DUMPFULL2="";
my $cptArticle=0;
my %dicoDesTitres=();
my %dicoDesDescriptions=();
#----------------------------------------
my $output1="SORTIE.txt";
if (!open (FILEOUTTXT,">$output1")) { die "Pb a l'ouverture du fichier $output1"};
my $output2="SORTIE.xml";
if (!open (FILEOUTXML,">$output2")) { die "Pb a l'ouverture du fichier $output2"};
#----------------------------------------
&parcoursarborescencefichiers($rep);    #recurse!
#----------------------------------------
print FILEOUTXML "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n";
print FILEOUTXML "<PARCOURS>\n";
print FILEOUTXML "<NOM>SF</NOM>\n";
print FILEOUTXML "<FILTRAGE>".$DUMPFULL1."</FILTRAGE>\n";
print FILEOUTXML "</PARCOURS>\n";
close(FILEOUTXML);
print FILEOUTTXT $DUMPFULL2;
close(FILEOUTTXT);
exit;
#----------------------------------------------
sub parcoursarborescencefichiers {
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    foreach my $file (@files) {
        next if $file =~ /^\.\.?$/;
        $file = $path."/".$file;
        if (-d $file) {
            &parcoursarborescencefichiers($file);    #recurse!
        }
        if (-f $file) {
            if ($file=~/\.xml$/) {
                print $i++,"\n";
                open(FILEIN,$file);
                while (my $ligne=<FILEIN>) {
                    if ($ligne=~/<\/item>/) {
                    $DUMPFULL1.="</article>\n";
                    }
                    if ($ligne=~/<item>/) {
                    $cptArticle++;
                    $DUMPFULL1.="<article numero=\"$cptArticle\">\n";
                    }
                    if ($ligne=~/<description>(.+?)<\/description>/) {
                    my $text=$1;
                    $text=&nettoieText($text);
                    if (!(exists($dicoDesDescriptions{$text}))) {
                        $DUMPFULL1.="<description>$text</description>\n";
                        $DUMPFULL2.=$text."\n";
                        $dicoDesDescriptions{$text}++;
                    }
                    else {
                        $dicoDesDescriptions{$text}++;
                        $DUMPFULL1.="<description>-</description>\n";
                    }
                    }
                    if ($ligne=~/<title>(.+?)<\/title>/)  {
                    my $text=$1;
                    $text=&nettoieText($text);
                    if (!(exists($dicoDesTitres{$text}))) {
                        $DUMPFULL1.="<abstract>$text</abstract>\n";
                        $DUMPFULL2.=$text."\n";
                        $dicoDesTitres{$text}++;
                    }
                    else {
                        $dicoDesTitres{$text}++;
                        $DUMPFULL1.="<abstract>-</abstract>\n";
                    }
                    }
                }
                close(FILEIN);
            }
        }
    }
}
#----------------------------------------------
sub nettoieText {
    my $texte=shift;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/<[^>]+>//g;
    $texte =~ s/&#233;/é/g;
    $texte =~ s/&#234;/ê/g;
    return $texte;
}

#/usr/bin/perl
<<DOC;
Votre Nom :
JANVIER 2015
 usage : perl parcours-arborescence-fichiers repertoire-a-parcourir
 Le programme prend en entrée le nom du répertoire contenant les fichiers
 à traiter
 Le programme construit en sortie un fichier structuré contenant sur chaque
 ligne le nom du fichier et le résultat du filtrage :
<FICHIER><NOM>du fichier</NOM></FICHIER><CONTENU>du filtrage</CONTENU></FICHIER>
DOC
#-----------------------------------------------------------
my $rep="$ARGV[0]";
# on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;
# on initialise une variable contenant le flux de sortie
my $DUMPFULL1="";
my $DUMPFULL2="";
my $cptArticle=0;
my %dicoDesTitres=();
my %dicoDesDescriptions=();
#----------------------------------------
my $output1="SORTIE.txt";
if (!open (FILEOUTTXT,">$output1")) { die "Pb a l'ouverture du fichier $output1"};
my $output2="SORTIE.xml";
if (!open (FILEOUTXML,">$output2")) { die "Pb a l'ouverture du fichier $output2"};
#----------------------------------------
&parcoursarborescencefichiers($rep);    #recurse!
#----------------------------------------
print FILEOUTXML "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n";
print FILEOUTXML "<PARCOURS>\n";
print FILEOUTXML "<NOM>SF</NOM>\n";
print FILEOUTXML "<FILTRAGE>".$DUMPFULL1."</FILTRAGE>\n";
print FILEOUTXML "</PARCOURS>\n";
close(FILEOUTXML);
print FILEOUTTXT $DUMPFULL2;
close(FILEOUTTXT);
exit;
#----------------------------------------------
sub parcoursarborescencefichiers {
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    foreach my $file (@files) {
        next if $file =~ /^\.\.?$/;
        $file = $path."/".$file;
        if (-d $file) {
            &parcoursarborescencefichiers($file);   #recurse!
        }
        if (-f $file) {
            if ($file=~/\.xml$/) {
                print $i++,"\n";
                open(FILEIN,$file);
                while (my $ligne=<FILEIN>) {
                    if ($ligne=~/<\/item>/) {
                    $DUMPFULL1.="</article>\n";
                    }
                    if ($ligne=~/<item>/) {
                    $cptArticle++;
                    $DUMPFULL1.="<article numero=\"$cptArticle\">\n";
                    }
                    if ($ligne=~/<description>(.+?)<\/description>/) {
                    my $text=$1;
                    $text=&nettoieText($text);
                    if (!(exists($dicoDesDescriptions{$text}))) {
                        $DUMPFULL1.="<description>$text</description>\n";
                        $DUMPFULL2.=$text."\n";
                        $dicoDesDescriptions{$text}++;
                    }
                    else {
                        $dicoDesDescriptions{$text}++;
                        $DUMPFULL1.="<description>-</description>\n";
                    }
                    }
                    if ($ligne=~/<title>(.+?)<\/title>/)  {
                    my $text=$1;
                    $text=&nettoieText($text);
                    if (!(exists($dicoDesTitres{$text}))) {
                        $DUMPFULL1.="<abstract>$text</abstract>\n";
                        $DUMPFULL2.=$text."\n";
                        $dicoDesTitres{$text}++;
                    }
                    else {
                        $dicoDesTitres{$text}++;
                        $DUMPFULL1.="<abstract>-</abstract>\n";
                    }
                    }

                }
                close(FILEIN);
            }
        }
    }
}
#----------------------------------------------
sub nettoieText {
    my $texte=shift;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/<[^>]+>//g;
    $texte =~ s/&#233;/é/g;
    $texte =~ s/&#234;/ê/g;
    return $texte;
}

#!/usr/bin/perl
use XML::RSS;
use Unicode::String qw(utf8);
#----------------------------------------------------------
my $encodagesortie="utf-8";
my $encodage=`file -i $ARGV[0] | cut -d= -f2`;
open(OUT1,">:encoding($encodagesortie)","sortie-textebrut-avec-xmlrss.txt");
open(OUT2,">:encoding($encodagesortie)","sortie-textexml-avec-xmlrss.xml");
print OUT2 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
print OUT2 "<file>\n";
print OUT2 "<name>$ARGV[0]</name>\n";
#-----------------------------------------------------------
my $file="$ARGV[0]";
my $rss=new XML::RSS;
#-----------------------------------------------------------
eval {$rss->parsefile($file); };
if( $@ ) {
    $@ =~ s/at \/.*?$//s;               # remove module line number
    print STDERR "\nERROR in '$file':\n$@\n";
} else {
    my $date=$rss->{'channel'}->{'pubDate'};
    print OUT2 "<date>$date</date>\n";
    print OUT2 "<items>\n";
    foreach my $item (@{$rss->{'items'}}) {
       my $titre=$item->{'title'};
       my $resume=$item->{'description'};
       $titre=&nettoietexte($titre);
       $resume=&nettoietexte($resume);
       if (uc($encodage) ne "UTF-8") {utf8($titre);utf8($resume);}
       print OUT1 "Titre : $titre \n";
       print OUT1 "Resume : $resume \n";;
       print OUT2
"<item><title>$titre</title><abstract>$resume</abstract></item>\n";
    }
}
#----------------------------------------------------------
print OUT2 "</items>\n</file>\n";
close(OUT1);
close(OUT2);
close(FILE);
exit;
#----------------------------------------------------------
#----------------------------------------------------------
sub nettoietexte {
    my $texte=shift;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/<[^>]+>//g;
    return $texte;
}

#!/usr/bin/perl
use XML::RSS;
use Unicode::String qw(utf8);
#----------------------------------------------------------
my $encodagesortie="utf-8";
my $encodage=`file -i $ARGV[0] | cut -d= -f2`;
open(OUT1,">:encoding($encodagesortie)","sortie-textebrut-avec-xmlrss.txt");
open(OUT2,">:encoding($encodagesortie)","sortie-textexml-avec-xmlrss.xml");
print OUT2 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
print OUT2 "<file>\n";
print OUT2 "<name>$ARGV[0]</name>\n";
#-----------------------------------------------------------
my $file="$ARGV[0]";
my $rss=new XML::RSS;
#-----------------------------------------------------------
eval {$rss->parsefile($file); };
if( $@ ) {
    $@ =~ s/at \/.*?$//s;               # remove module line number
    print STDERR "\nERROR in '$file':\n$@\n";
} else {
    my $date=$rss->{'channel'}->{'pubDate'};
    print OUT2 "<date>$date</date>\n";
    print OUT2 "<items>\n";
    foreach my $item (@{$rss->{'items'}}) {
       my $titre=$item->{'title'};
       my $resume=$item->{'description'};
       $titre=&nettoietexte($titre);
       $resume=&nettoietexte($resume);
       if (uc($encodage) ne "UTF-8") {utf8($titre);utf8($resume);}
       print OUT1 "Titre : $titre \n";
       print OUT1 "Resume : $resume \n";;
       print OUT2
"<item><title>$titre</title><abstract>$resume</abstract></item>\n";
    }
}
#----------------------------------------------------------
print OUT2 "</items>\n</file>\n";
close(OUT1);
close(OUT2);
close(FILE);
exit;
#----------------------------------------------------------
#----------------------------------------------------------
sub nettoietexte {
    my $texte=shift;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/<[^>]+>//g;
    return $texte;
}

#/usr/bin/perl
use XML::XPath;
# On vérifie le nombre d'arguments de l'appel au script ($0 : le nom du script)
if($#ARGV!=0){
       print "usage : perl $0 fichier_tag fichier_motif";
exit; }
#----------------------------------------------------------------------------------
-----------------------------------------------------------------
my $encodagesortie="utf-8";
open(OUT1,">:encoding($encodagesortie)","sortie-textebrut-avec-xmlxpath.txt");
open(OUT2,">:encoding($encodagesortie)","sortie-textexml-avec-xmlxpath.xml");
print OUT2 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
print OUT2 "<file>\n";
print OUT2 "<name>$ARGV[0]</name>\n";
my $input_file= shift @ARGV;
my $xp = XML::XPath->new( filename => $input_file ) or die "big trouble";
my $search_path.="//item";
# boucle sur les nœuds reconnus du chemin xpath
foreach my $noeud ( $xp->find($search_path)->get_nodelist ) {
       my $titre=$noeud->find('title')->string_value;
       my $resume=$noeud->find('description')->string_value;
       $titre=&nettoietexte($titre);
       $resume=&nettoietexte($resume);
       print OUT1 "Titre : $titre \n";
       print OUT1 "Resume : $resume \n";;
       print OUT2
"<item><title>$titre</title><abstract>$resume</abstract></item>\n";
}
#----------------------------------------------------------
print OUT2 "</items>\n</file>\n";
close(OUT1);
close(OUT2);
close(FILE);
exit;
sub nettoietexte {
    my $texte=shift;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/<[^>]+>//g;
    return $texte;
}

#/usr/bin/perl
use XML::XPath;
# On vérifie le nombre d'arguments de l'appel au script ($0 : le nom du script)
if($#ARGV!=0){
       print "usage : perl $0 fichier_tag fichier_motif";
exit; }
#----------------------------------------------------------------------------------
-----------------------------------------------------------------
my $encodagesortie="utf-8";
open(OUT1,">:encoding($encodagesortie)","sortie-textebrut-avec-xmlxpath.txt");
open(OUT2,">:encoding($encodagesortie)","sortie-textexml-avec-xmlxpath.xml");
print OUT2 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
print OUT2 "<file>\n";
print OUT2 "<name>$ARGV[0]</name>\n";
my $input_file= shift @ARGV;
my $xp = XML::XPath->new( filename => $input_file ) or die "big trouble";
my $search_path.="//item";
# boucle sur les nœuds reconnus du chemin xpath
foreach my $noeud ( $xp->find($search_path)->get_nodelist ) {
       my $titre=$noeud->find('title')->string_value;
       my $resume=$noeud->find('description')->string_value;
       $titre=&nettoietexte($titre);
       $resume=&nettoietexte($resume);
       print OUT1 "Titre : $titre \n";
       print OUT1 "Resume : $resume \n";;
       print OUT2
"<item><title>$titre</title><abstract>$resume</abstract></item>\n";
}
#----------------------------------------------------------
print OUT2 "</items>\n</file>\n";
close(OUT1);
close(OUT2);
close(FILE);
exit;
sub nettoietexte {
    my $texte=shift;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/<[^>]+>//g;
    return $texte;
}

#/usr/bin/perl
use Unicode::String qw(utf8);
#lire l'entrée standard
my $rep="$ARGV[0]";
# éliminier les possibles "/" à la fin du nom du dossier
$rep=~ s/[\/]$//;
# liste pour stocker les items déjà traités
my %dictionnairedesitems = ();
# liste pour stocker les rubriques déjà traités
my %dictionnairesdesrubriques = ();
# appeler la fonction extraire_rubrique() pour lire les dossiers et extraire les rubriques des fichiers
&extraire_rubrique($rep);
my @liste_rubriques = keys(%dictionnairesdesrubriques);
# pour chaque rubrique, créer un fichier de sortie .xml et un fichier .txt
foreach my $rub (@liste_rubriques) {
    my $output1= "SORTIE-extract-txt-".$rub.".xml";
    my $output2= "SORTIE-extract-txt-".$rub.".txt";
    # créer fichier .xml de sortie
    open (FILEOUTXML, ">:encoding(utf-8)", $output1) or die "Could not open file @output1!"; # open file for writing
       # créer fichier .txt de sortie
       open (FILEOUTTXT, ">:encoding(utf-8)", $output2) or die "Could not open file $output2!"; # open file for writing)
    # écrier déclaration d'en-tête du fichier xml
    print FILEOUTXML "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUTXML "<PARCOURS>\n";
    #fermer les deux fichiers
    close(FILEOUTXML);
    close(FILEOUTTXT);
    print $output1;
}
# appeler lire_et_ecrire_xml() pour lire tous les fichiers xml et créer les sorties
&lire_et_ecrire_xml($rep);
foreach my $rub (@liste_rubriques)
{
    my $output1="SORTIE-extract-txt-".$rub.".xml";
    if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1))
    {
        die "Pb a l'ouverture du fichier $output1";
    }
    print FILEOUTXML "</PARCOURS>\n";
    close(FILEOUTXML);
}
exit;
#########################################################################################################
#                                                                                                        #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier       #
# Pour chaque fichier lu, la fonction extrait les texte des balise <title> et <description>, ainsi que  #
# les dates présente en <pubDate> et <rubrique>                                                            #
# Ce contenu insère dans des fichiers .xml et .txt de sortie de la rubrique correspondante               #
#                                                                                                        #
#########################################################################################################
sub lire_et_ecrire_xml {
    # lire nom de dossier passé comme argument
    my $path = shift(@_);
    # ouvrir dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";
    # lire itens dans le dossier
    my @files = readdir(DIR);
    closedir(DIR);
    # fermer dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;
        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;
        # vérifier si l'item traité est dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &lire_et_ecrire_xml($file);
        }
        # vérifier si l'item traité un fichier IF1
        if (-f $file)
        {
            # vérifier s'il s'agit d'un fichier .xml qui ne contient pas fil dans le nom iF2
            if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                # ouvrir fichier
                open(FILE, $file);
                # variable pour stocker le contenu du fichier
                my $texte="";
                #lire le contenu du fichier ligne à line
                while (my $ligne=<FILE>)
                {
                    chomp $ligne;
                    $texte .= $ligne;
                }
                # fermer fichier
                close(FILE);
                # regex pour capturer l'encodage du fichier
                $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
                # stocker l'encogade du fichier
                my $encodage=$1;
                # vérifier si l'encodage n'est pas vide pour traiter le contenu IF3
                if ($encodage ne "")
                {
                    # la variable temptexteXML stocke les contenus prêts à être écrits dans fichier .xml de sortie
                    my $tmptexteXML="<file>\n";
                    # créer balise avec le nom du fichier
                    $tmptexteXML.="<name>$file</name>\n";
                    # éliminier les balises avec des espaces en blanc
                    $texte =~ s/> *</></g;
                    # regex pour capturer date
                    $texte=~/<pubDate>([^<]+)<\/pubDate>/;
                    # stocker la valeur de date capturée par la regex
                    $tmptexteXML.="<date>$1</date>\n";
                    # insérer la balise <items>
                    $tmptexteXML.="<items>\n";
                    my $tmptexteBRUT="";
                      open(FILE,"<:encoding($encodage)", $file);
                       $texte="";
                       # lire le fichier ligne à ligne
                    while (my $ligne=<FILE>)
                    {
                        chomp  $ligne;
                        $texte .= $ligne;
                    }
                    close(FILE);
                      $texte=~s/> *</></g;
                       # on recherche la rubrique
                    $texte=~/<channel><title>([^<]+)<\/title>/;
                    # nettoyer le string rubrique
                    my $rub=$1;
                    $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                    $rub=~s/é/e/gi;
                    $rub=~s/è/e/gi;
                    $rub=~s/ê/e/gi;
                    $rub=~s/à/a/gi;
                    $rub=~ s/Le ?Monde.fr ?://;
                    $rub=~ s/ //g;
                    $rub=uc($rub);
                    my $output1="SORTIE-extract-txt-".$rub.".xml";
                    my $output2="SORTIE-extract-txt-".$rub.".txt";
                      if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
                      if (!open (FILEOUTTXT,">>:encoding(utf-8)", $output2)) { die "Pb a l'ouverture du fichier $output2"};
                       # lire texte pour extraire contenu des balises <title> et <description>
                       while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g)
                       {
                           # capturer contenu de la regex pour titre
                        my $titre=$1;
                        # capturer contenu de la regex pour description
                        my $resume=$2;
                        #
                        $titre = &nettoyer_texte($1);
                        $resume = &nettoyer_texte($2);
                        # si le fichier n'est pas en UTF-8, convertir le string $titre et $resume en UTF-8
                        if (uc($encodage) ne "UTF-8")
                        {
                            utf8($titre);
                            utf8($resume);
                        }
                        # si le contenu de $resume n'a pas encore été traite, on doit le traiter
                        if (!(exists($dictionnairedesitems{$resume})))
                        {
                            # créer contenu le fichier .txt
                            $tmptexteBRUT.="§ $titre \n";
                            $tmptexteBRUT.="$resume \n";
                            # créer contenu pour fichier .xml
                            $tmptexteXML.="<item><title>$titre</title><abstract>$resume</abstract></item>\n";
                            # inclure contenu de $resume dans liste
                            $dictionnairedesitems{$resume}++;
                        } else {
                            $tmptexteXML.="<item><title>-</title><abstract>-</abstract></item>\n";
                        }
                    } # fin while
                    # rajouter la fin des balise <items> et <file>
                    $tmptexteXML.="</items>\n</file>\n";
                    # écrire contenu dans le fichier .xml
                    print FILEOUTXML $tmptexteXML;
                    # écrire contenu dans le fichier .txt
                    print FILEOUTTXT $tmptexteBRUT;
                    # fermer fichiers
                    close FILEOUTXML;
                    close FILEOUTTXT;
                } else {
                    #si l'encaodre est vide afficher message
                       print "$file ==> $encodage \n";
                } # fin IF3
            } # fin IF 2
        } # fin IF 1
    } # fin FOR
} # fin lire_et_ecrire_xml()
sub nettoyer_texte {
    my $texte=shift;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/&#233;/é/g;
    $texte =~ s/&#234;/ê/g;
    $texte =~ s/<[^>]+>//g;
    $texte =~ s/&nbsp;/ /g;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte=~s/&amp;#39;/'/g;
    $texte=~s/&amp;#34;/"/g;
    return $texte;
}
####################################################################################################
#                                                                                                   #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier  #
# Pour chaque fichier lu, la fonction extrait les rubriques et crée des fichiers de sortie            #
# possédant le nom de la rubrique                                                                    #
#                                                                                                   #
####################################################################################################
sub extraire_rubrique {
    #lire le nom dossier passé comme argument
    my $path = shift(@_);
    #ouvrir le dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";
    #lire la liste de fichier du dossier
    my @files = readdir(DIR);
    closedir(DIR);
    # lire un à un les items du dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;
        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;
        # vérifier si l'item est un dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &extraire_rubrique($file);
        }
        # vérifier si l'item est un fichier - IF1
        if (-f $file)
        {
            # tester si fichier possède l'extension .xml et ne contient pas la substring fil dans le nom - IF2
            if (($file =~ /\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                #ouvrir fichier .xml
                open(FILE,$file);
                #variable pour stocker le contenu du fichier .xml
                my $texte="";
                #lire toutes les lignes du fichier .xml
                while (my $ligne=<FILE>)
                {
                    # effacer les retours à la ligne
                    chomp $ligne;
                    # stocker le contenu de ligne lue
                    $texte .= $ligne;
                }
                # fermer le fichier .xml
                close(FILE);
                # regex pour capture l`encodage du fichier
                $texte =~ /encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
                # stocker le contenu trouvé par la regex
                my $encodage=$1;
                # vérifier la contenu de regex n'est pas vide IF3
                if ($encodage ne "")
                {
                    # reouvrir le fichier avec l'encogade correcte
                    open(FILE,"<:encoding($encodage)", $file);
                    # variables pour stocker le contenu du fichier lu
                    $texte="";
                    # lire le fichier .xml
                    while (my $ligne=<FILE>)
                    {
                        # effacer les retours à la ligne
                        chomp $ligne;
                        # stocker le contenu de ligne lue
                        $texte .= $ligne;
                    }
                    # fermer le fichier .xml
                    close(FILE);
                    # effacer les espaces en blanc
                    $texte =~ s/> *</></g;
                    # capturer le contenu à l'intérieur des balises <title> - IF4
                    if ($texte=~ /<channel><title>([^>]+)<\/title>/)
                    {
                        print $texte;
                        # stocker la valeur de rubrique trouvée par la regex
                        my $rub=$1;
                        # nettoyer les noms des rubriques
                        $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                        $rub=~s/é/e/gi;
                        $rub=~s/è/e/gi;
                        $rub=~s/ê/e/gi;
                        $rub=~s/à/a/gi;
                        $rub=~ s/Le ?Monde.fr ?://i;
                        $rub=~ s/ //g;
                        $rub=uc($rub);
                        # stocker la rubrique dans le dictionnaire des rubriques
                        $dictionnairesdesrubriques{$rub}++;
                    } # fin IF4
                } # fin IF3
            } # fin IF2
        }    # fin IF1
    } # fin FOR
} # fin extraire_rubrique()

#/usr/bin/perl
use Unicode::String qw(utf8);

#lire l'entrée standard
my $rep="$ARGV[0]";

# éliminier les possibles "/" à la fin du nom du dossier
$rep=~ s/[\/]$//;

# liste pour stocker les items déjà traités
my %dictionnairedesitems = ();

# liste pour stocker les rubriques déjà traités
my %dictionnairesdesrubriques = ();

# appeler la fonction extraire_rubrique() pour lire les dossiers et extraire les rubriques des fichiers
&extraire_rubrique($rep);


my @liste_rubriques = keys(%dictionnairesdesrubriques);

# pour chaque rubrique, créer un fichier de sortie .xml et un fichier .txt
foreach my $rub (@liste_rubriques) {

    my $output1= "SORTIE-extract-txt-".$rub.".xml";
    my $output2= "SORTIE-extract-txt-".$rub.".txt";

    # créer fichier .xml de sortie
    open (FILEOUTXML, ">:encoding(utf-8)", $output1) or die "Could not open file @output1!"; # open file for writing
    # créer fichier .txt de sortie
    open (FILEOUTTXT, ">:encoding(utf-8)", $output2) or die "Could not open file $output2!"; # open file for writing)

    # écrier déclaration d'en-tête du fichier xml
    print FILEOUTXML "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUTXML "<PARCOURS>\n";

    #fermer les deux fichiers
    close(FILEOUTXML);
    close(FILEOUTTXT);
    print $output1;
}

# appeler lire_et_ecrire_xml() pour lire tous les fichiers xml et créer les sorties
&lire_et_ecrire_xml($rep);

foreach my $rub (@liste_rubriques)
{
    my $output1="SORTIE-extract-txt-".$rub.".xml";
    if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1))
    {
        die "Pb a l'ouverture du fichier $output1";
    }
    print FILEOUTXML "</PARCOURS>\n";
    close(FILEOUTXML);
}
exit;


#########################################################################################################
#                                                                                                       #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier       #
# Pour chaque fichier lu, la fonction extrait les texte des balise <title> et <description>, ainsi que  #
# les dates présente en <pubDate> et <rubrique>                                                          #
# Ce contenu insère dans des fichiers .xml et .txt de sortie de la rubrique correspondante              #
#                                                                                                       #
#########################################################################################################
sub lire_et_ecrire_xml {

    # lire nom de dossier passé comme argument
    my $path = shift(@_);

    # ouvrir dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";

    # lire itens dans le dossier
    my @files = readdir(DIR);
    closedir(DIR);

    # fermer dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;

        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;

        # vérifier si l'item traité est dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &lire_et_ecrire_xml($file);
        }

        # vérifier si l'item traité un fichier IF1
        if (-f $file)
        {
            # vérifier s'il s'agit d'un fichier .xml qui ne contient pas fil dans le nom iF2
            if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                # ouvrir fichier
                open(FILE, $file);

                # variable pour stocker le contenu du fichier
                my $texte="";

                #lire le contenu du fichier ligne à line
                while (my $ligne=<FILE>)
                {
                    chomp $ligne;
                    $texte .= $ligne;
                }

                # fermer fichier
                close(FILE);

                # regex pour capturer l'encodage du fichier
                $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;

                # stocker l'encogade du fichier
                my $encodage=$1;

                # vérifier si l'encodage n'est pas vide pour traiter le contenu IF3
                if ($encodage ne "")
                {
                    # la variable temptexteXML stocke les contenus prêts à être écrits dans fichier .xml de sortie
                    my $tmptexteXML="<file>\n";

                    # créer balise avec le nom du fichier
                    $tmptexteXML.="<name>$file</name>\n";

                    # éliminier les balises avec des espaces en blanc
                    $texte =~ s/> *</></g;

                    # regex pour capturer date
                    $texte=~/<pubDate>([^<]+)<\/pubDate>/;

                    # stocker la valeur de date capturée par la regex
                    $tmptexteXML.="<date>$1</date>\n";

                    # insérer la balise <items>
                    $tmptexteXML.="<items>\n";

                    my $tmptexteBRUT="";

                    open(FILE,"<:encoding($encodage)", $file);

                    $texte="";

                    # lire le fichier ligne à ligne
                    while (my $ligne=<FILE>)
                    {
                        chomp  $ligne;
                        $texte .= $ligne;
                    }
                    close(FILE);

                    $texte=~s/> *</></g;

                    # on recherche la rubrique
                    $texte=~/<channel><title>([^<]+)<\/title>/;

                    # nettoyer le string rubrique
                    my $rub=$1;
                    $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                    $rub=~s/é/e/gi;
                    $rub=~s/è/e/gi;
                    $rub=~s/ê/e/gi;
                    $rub=~s/à/a/gi;
                    $rub=~ s/Le ?Monde.fr ?://;
                    $rub=~ s/ //g;
                    $rub=uc($rub);

                    my $output1="SORTIE-extract-txt-".$rub.".xml";
                    my $output2="SORTIE-extract-txt-".$rub.".txt";
                    if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
                    if (!open (FILEOUTTXT,">>:encoding(utf-8)", $output2)) { die "Pb a l'ouverture du fichier $output2"};

                    # lire texte pour extraire contenu des balises <title> et <description>
                    while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g)
                    {
                        # capturer contenu de la regex pour titre
                        my $titre=$1;

                        # capturer contenu de la regex pour description
                        my $resume=$2;

                        #
                        $titre = &nettoyer_texte($1);
                        $resume = &nettoyer_texte($2);

                        # si le fichier n'est pas en UTF-8, convertir le string $titre et $resume en UTF-8
                        if (uc($encodage) ne "UTF-8")
                        {
                            utf8($titre);
                            utf8($resume);
                        }

                        # si le contenu de $resume n'a pas encore été traite, on doit le traiter
                        if (!(exists($dictionnairedesitems{$resume})))
                        {
                            # créer contenu le fichier .txt
                            $tmptexteBRUT.="§ $titre \n";
                            $tmptexteBRUT.="$resume \n";

                            # créer contenu pour fichier .xml
                            $tmptexteXML.="<item><title>$titre</title><abstract>$resume</abstract></item>\n";

                            # inclure contenu de $resume dans liste
                            $dictionnairedesitems{$resume}++;
                        } else {
                            $tmptexteXML.="<item><title>-</title><abstract>-</abstract></item>\n";
                        }
                    } # fin while

                    # rajouter la fin des balise <items> et <file>
                    $tmptexteXML.="</items>\n</file>\n";

                    # écrire contenu dans le fichier .xml
                    print FILEOUTXML $tmptexteXML;

                    # écrire contenu dans le fichier .txt
                    print FILEOUTTXT $tmptexteBRUT;

                    # fermer fichiers
                    close FILEOUTXML;
                    close FILEOUTTXT;

                } else {

                    #si l'encaodre est vide afficher message
                    print "$file ==> $encodage \n";

                } # fin IF3
            } # fin IF 2
        } # fin IF 1
    } # fin FOR
} # fin lire_et_ecrire_xml()


sub nettoyer_texte {
    my $texte=shift;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/&#233;/é/g;
    $texte =~ s/&#234;/ê/g;
    $texte =~ s/<[^>]+>//g;
    $texte =~ s/&nbsp;/ /g;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte=~s/&amp;#39;/'/g;
    $texte=~s/&amp;#34;/"/g;
    return $texte;
}


####################################################################################################
#                                                                                                  #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier  #
# Pour chaque fichier lu, la fonction extrait les rubriques et crée des fichiers de sortie         #
# possédant le nom de la rubrique                                                                  #
#                                                                                                  #
####################################################################################################
sub extraire_rubrique {

    #lire le nom dossier passé comme argument
    my $path = shift(@_);

    #ouvrir le dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";

    #lire la liste de fichier du dossier
    my @files = readdir(DIR);
    closedir(DIR);

    # lire un à un les items du dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;

        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;

        # vérifier si l'item est un dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &extraire_rubrique($file);
        }

        # vérifier si l'item est un fichier - IF1
        if (-f $file)
        {
            # tester si fichier possède l'extension .xml et ne contient pas la substring fil dans le nom - IF2
            if (($file =~ /\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                #ouvrir fichier .xml
                open(FILE,$file);

                #variable pour stocker le contenu du fichier .xml
                my $texte="";

                #lire toutes les lignes du fichier .xml
                while (my $ligne=<FILE>)
                {
                    # effacer les retours à la ligne
                    chomp $ligne;

                    # stocker le contenu de ligne lue
                    $texte .= $ligne;
                }

                # fermer le fichier .xml
                close(FILE);

                # regex pour capture l`encodage du fichier
                $texte =~ /encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;

                # stocker le contenu trouvé par la regex
                my $encodage=$1;

                # vérifier la contenu de regex n'est pas vide IF3
                if ($encodage ne "")
                {
                    # reouvrir le fichier avec l'encogade correcte
                    open(FILE,"<:encoding($encodage)", $file);

                    # variables pour stocker le contenu du fichier lu
                    $texte="";

                    # lire le fichier .xml
                    while (my $ligne=<FILE>)
                    {
                        # effacer les retours à la ligne
                        chomp $ligne;

                        # stocker le contenu de ligne lue
                        $texte .= $ligne;
                    }

                    # fermer le fichier .xml
                    close(FILE);

                    # effacer les espaces en blanc
                    $texte =~ s/> *</></g;

                    # capturer le contenu à l'intérieur des balises <title> - IF4
                    if ($texte=~ /<channel><title>([^>]+)<\/title>/)
                    {
                        print $texte;

                        # stocker la valeur de rubrique trouvée par la regex
                        my $rub=$1;

                        # nettoyer les noms des rubriques
                        $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                        $rub=~s/é/e/gi;
                        $rub=~s/è/e/gi;
                        $rub=~s/ê/e/gi;
                        $rub=~s/à/a/gi;
                        $rub=~ s/Le ?Monde.fr ?://i;
                        $rub=~ s/ //g;
                        $rub=uc($rub);

                        # stocker la rubrique dans le dictionnaire des rubriques
                        $dictionnairesdesrubriques{$rub}++;

                    } # fin IF4
                } # fin IF3
            } # fin IF2
        }   # fin IF1
    } # fin FOR
} # fin extraire_rubrique()

#/usr/bin/perl
use Unicode::String qw(utf8);
use XML::Entities;
use HTML::Entities;
use XML::RSS;
#lire l'entrée standard
my $rep="$ARGV[0]";
# éliminier les possibles "/" à la fin du nom du dossier
$rep=~ s/[\/]$//;
# liste pour stocker les items déjà traités
my %dictionnairedesitems = ();
# liste pour stocker les rubriques déjà traités
my %dictionnairesdesrubriques = ();
# appeler la fonction extraire_rubrique() pour lire les dossiers et extraire les rubriques des fichiers
&extraire_rubrique($rep);
my @liste_rubriques = keys(%dictionnairesdesrubriques);
# pour chaque rubrique, créer un fichier de sortie .xml et un fichier .txt
foreach my $rub (@liste_rubriques) {
    my $output1= "SORTIE-extract-txt-".$rub.".xml";
    my $output2= "SORTIE-extract-txt-".$rub.".txt";
    # créer fichier .xml de sortie
    open (FILEOUTXML, ">:encoding(utf-8)", $output1) or die "Could not open file @output1!"; # open file for writing
       # créer fichier .txt de sortie
       open (FILEOUTTXT, ">:encoding(utf-8)", $output2) or die "Could not open file $output2!"; # open file for writing)
    # écrier déclaration d'en-tête du fichier xml
    print FILEOUTXML "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUTXML "<PARCOURS>\n";
    #fermer les deux fichiers
    close(FILEOUTXML);
    close(FILEOUTTXT);
    print $output1;
}
# appeler lire_et_ecrire_xml() pour lire tous les fichiers xml et créer les sorties
&lire_et_ecrire_xml($rep);
foreach my $rub (@liste_rubriques)
{
    my $output1="SORTIE-extract-txt-".$rub.".xml";
    if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1))
    {
        die "Pb a l'ouverture du fichier $output1";
    }
    print FILEOUTXML "</PARCOURS>\n";
    close(FILEOUTXML);
}
exit;
#########################################################################################################
#                                                                                                        #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier       #
# Pour chaque fichier lu, la fonction extrait le texte des balises <title> et <description>, ainsi que  #
# les dates présentes entre <pubDate> et <rubrique>                                                        #
# Ce contenu insère dans des fichiers de sortie .xml et .txt la rubrique correspondante                   #
#                                                                                                        #
#########################################################################################################
sub lire_et_ecrire_xml {
    # lire nom de dossier passé comme argument
    my $path = shift(@_);
    # ouvrir dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";
    # lire items dans le dossier
    my @files = readdir(DIR);
    closedir(DIR);
    # fermer dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;
        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;
        # vérifier si l'item traité est un dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &lire_et_ecrire_xml($file);
        }
        # vérifier si l'item traité un fichier IF1
        if (-f $file)
        {
            # vérifier s'il s'agit d'un fichier .xml qui ne contient pas fil dans le nom iF2
            if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                # ouvrir fichier
                open(FILE, $file);
                # variable pour stocker le contenu du fichier
                my $texte="";
                #lire le contenu du fichier ligne à line
                while (my $ligne=<FILE>)
                {
                    chomp $ligne;
                    $texte .= $ligne;
                }
                # fermer fichier
                close(FILE);
                # regex pour capturer l'encodage du fichier
                $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
                # stocker l'encodage du fichier
                my $encodage=$1;
                # vérifier si l'encodage n'est pas vide pour traiter le contenu IF3
                if ($encodage ne "")
                {
                    # la variable tmptexteXML stocke les contenus prêts à être écrits dans fichier .xml de sortie
                    my $tmptexteXML="<file>\n";
                    # créer balise avec le nom du fichier
                    $tmptexteXML.="<name>$file</name>\n";
                    # éliminier les balises avec des espaces en blanc
                    $texte =~ s/> *</></g;
                    # regex pour capturer date
                    $texte=~/<pubDate>([^<]+)<\/pubDate>/;
                    # stocker la valeur de date capturée par la regex
                    $tmptexteXML.="<date>$1</date>\n";
                    # insérer la balise <items>
                    $tmptexteXML.="<items>\n";
                    my $tmptexteBRUT="";
                      open(FILE,"<:encoding($encodage)", $file);
                       $texte="";
                       # lire le fichier ligne à ligne
                    while (my $ligne=<FILE>)
                    {
                        chomp  $ligne;
                        $texte .= $ligne;
                    }
                    close(FILE);
                      $texte=~s/> *</></g;
                       # on recherche la rubrique
                    $texte=~/<channel><title>([^<]+)<\/title>/;
                    # on met le contenu trouvé par la regex dans $rub
                    my $rub=$1;
                    # nettoyer le string rubrique
                    $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                    $rub =~ s/é/e/gi;
                    $rub =~ s/è/e/gi;
                    $rub =~ s/ê/e/gi;
                    $rub =~ s/à/a/gi;
                    $rub =~ s/Le ?Monde.fr ?://;
                    $rub =~ s/ //g;
                    $rub=uc($rub);
                    my $output1="SORTIE-extract-txt-".$rub.".xml";
                    my $output2="SORTIE-extract-txt-".$rub.".txt";
                      if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
                      if (!open (FILEOUTTXT,">>:encoding(utf-8)", $output2)) { die "Pb a l'ouverture du fichier $output2"};
                       # lire texte pour extraire contenu des balises <title> et <description>
                       while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g)
                       {
                           # capturer contenu de la regex pour titre
                        my $titre=$1;
                        # capturer contenu de la regex pour description
                        my $resume=$2;
                        # utilisation des modules pour remplacer dans les fichiers les entités XML et HTML
                        if (!(exists ($dictionnairedesitems{$titre})) and !(exists ($dictionnairedesitems{$resume})))
                        {
                            $dictionnairedesitems{$titre}++;
                            $dictionnairedesitems{$resume}++;
                            $titre = XML::Entities::decode('all', $titre);
                            $resume = XML::Entities::decode('all', $resume);
                            $titre = HTML::Entities::decode($titre);
                            $resume = HTML::Entities::decode($resume);
                            $tmptexteBRUT.="$titre \n";
                            $tmptexteBRUT.="$resume \n";
                            $tmptexteXML.="<item><title>$titre</title><description>$resume</description></item>\n";
                            # nettoyage des balises <description> pour supprimer les balises superflues
                            $tmptexteXML =~ s/<img.*?\/><\/description>/<\/description>/g;
                            $tmptexteBRUT =~ s/<img.*?\/> \n/\n/g;
                        }
                        # si le fichier n'est pas en UTF-8, convertir le string $titre et $resume en UTF-8
                        if (uc($encodage) ne "UTF-8")
                        {
                            utf8($titre);
                            utf8($resume);
                        }
                    } # fin while
                    # rajouter la fin des balises <items> et <file>
                    $tmptexteXML.="</items>\n</file>\n";
                    # écrire contenu dans le fichier .xml
                    print FILEOUTXML $tmptexteXML;
                    # écrire contenu dans le fichier .txt
                    print FILEOUTTXT $tmptexteBRUT;
                    # fermer fichiers
                    close FILEOUTXML;
                    close FILEOUTTXT;
                } else {
                    #si l'encodage est vide afficher message
                       print "$file ==> $encodage \n";
                } # fin IF3
            } # fin IF 2
        } # fin IF 1
    } # fin FOR
} # fin lire_et_ecrire_xml()
####################################################################################################
#                                                                                                   #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier  #
# Pour chaque fichier lu, la fonction extrait les rubriques et crée des fichiers de sortie            #
# possédant le nom de la rubrique                                                                    #
#                                                                                                   #
####################################################################################################
sub extraire_rubrique {
    #lire le nom dossier passé comme argument
    my $path = shift(@_);
    #ouvrir le dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";
    #lire la liste de fichier du dossier
    my @files = readdir(DIR);
    closedir(DIR);
    # lire un à un les items du dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;
        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;
        # vérifier si l'item est un dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &extraire_rubrique($file);
        }
        # vérifier si l'item est un fichier - IF1
        if (-f $file)
        {
            # tester si fichier possède l'extension .xml et ne contient pas la substring fil dans le nom - IF2
            if (($file =~ /\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                #ouvrir fichier .xml
                open(FILE,$file);
                #variable pour stocker le contenu du fichier .xml
                my $texte="";
                #lire toutes les lignes du fichier .xml
                while (my $ligne=<FILE>)
                {
                    # effacer les retours à la ligne
                    chomp $ligne;
                    # stocker le contenu de ligne lue
                    $texte .= $ligne;
                }
                # fermer le fichier .xml
                close(FILE);
                # regex pour capture l`encodage du fichier
                $texte =~ /encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
                # stocker le contenu trouvé par la regex
                my $encodage=$1;
                # vérifier la contenu de regex n'est pas vide IF3
                if ($encodage ne "")
                {
                    # reouvrir le fichier avec l'encogade correcte
                    open(FILE,"<:encoding($encodage)", $file);
                    # variables pour stocker le contenu du fichier lu
                    $texte="";
                    # lire le fichier .xml
                    while (my $ligne=<FILE>)
                    {
                        # effacer les retours à la ligne
                        chomp $ligne;
                        # stocker le contenu de ligne lue
                        $texte .= $ligne;
                    }
                    # fermer le fichier .xml
                    close(FILE);
                    # effacer les espaces en blanc
                    $texte =~ s/> *</></g;
                    # capturer le contenu à l'intérieur des balises <title> - IF4
                    if ($texte=~ /<channel><title>([^>]+)<\/title>/)
                    {
                        print $texte;
                        # stocker la valeur de rubrique trouvée par la regex
                        my $rub=$1;
                        # nettoyer les noms des rubriques
                        $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                        $rub =~ s/é/e/gi;
                        $rub =~ s/è/e/gi;
                        $rub =~ s/ê/e/gi;
                        $rub =~ s/à/a/gi;
                        $rub =~ s/Le ?Monde.fr ?://;
                        $rub =~ s/ //g;
                        $rub=uc($rub);
                        # stocker la rubrique dans le dictionnaire des rubriques
                        $dictionnairesdesrubriques{$rub}++;
                    } # fin IF4
                } # fin IF3
            } # fin IF2
        }    # fin IF1
    } # fin FOR
} # fin extraire_rubrique()

#/usr/bin/perl
use Unicode::String qw(utf8);
use XML::Entities;
use HTML::Entities;
use XML::RSS;

#lire l'entrée standard
my $rep="$ARGV[0]";

# éliminier les possibles "/" à la fin du nom du dossier
$rep=~ s/[\/]$//;

# liste pour stocker les items déjà traités
my %dictionnairedesitems = ();

# liste pour stocker les rubriques déjà traités
my %dictionnairesdesrubriques = ();

# appeler la fonction extraire_rubrique() pour lire les dossiers et extraire les rubriques des fichiers
&extraire_rubrique($rep);


my @liste_rubriques = keys(%dictionnairesdesrubriques);

# pour chaque rubrique, créer un fichier de sortie .xml et un fichier .txt
foreach my $rub (@liste_rubriques) {

    my $output1= "SORTIE-extract-txt-".$rub.".xml";
    my $output2= "SORTIE-extract-txt-".$rub.".txt";

    # créer fichier .xml de sortie
    open (FILEOUTXML, ">:encoding(utf-8)", $output1) or die "Could not open file @output1!"; # open file for writing
    # créer fichier .txt de sortie
    open (FILEOUTTXT, ">:encoding(utf-8)", $output2) or die "Could not open file $output2!"; # open file for writing)

    # écrier déclaration d'en-tête du fichier xml
    print FILEOUTXML "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUTXML "<PARCOURS>\n";

    #fermer les deux fichiers
    close(FILEOUTXML);
    close(FILEOUTTXT);
    print $output1;
}

# appeler lire_et_ecrire_xml() pour lire tous les fichiers xml et créer les sorties
&lire_et_ecrire_xml($rep);

foreach my $rub (@liste_rubriques)
{
    my $output1="SORTIE-extract-txt-".$rub.".xml";
    if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1))
    {
        die "Pb a l'ouverture du fichier $output1";
    }
    print FILEOUTXML "</PARCOURS>\n";
    close(FILEOUTXML);
}
exit;


#########################################################################################################
#                                                                                                       #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier       #
# Pour chaque fichier lu, la fonction extrait le texte des balises <title> et <description>, ainsi que  #
# les dates présentes entre <pubDate> et <rubrique>                                                     #
# Ce contenu insère dans des fichiers de sortie .xml et .txt la rubrique correspondante                 #
#                                                                                                       #
#########################################################################################################
sub lire_et_ecrire_xml {

    # lire nom de dossier passé comme argument
    my $path = shift(@_);

    # ouvrir dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";

    # lire items dans le dossier
    my @files = readdir(DIR);
    closedir(DIR);

    # fermer dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;

        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;

        # vérifier si l'item traité est un dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &lire_et_ecrire_xml($file);
        }

        # vérifier si l'item traité un fichier IF1
        if (-f $file)
        {
            # vérifier s'il s'agit d'un fichier .xml qui ne contient pas fil dans le nom iF2
            if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                # ouvrir fichier
                open(FILE, $file);

                # variable pour stocker le contenu du fichier
                my $texte="";

                #lire le contenu du fichier ligne à line
                while (my $ligne=<FILE>)
                {
                    chomp $ligne;
                    $texte .= $ligne;
                }

                # fermer fichier
                close(FILE);

                # regex pour capturer l'encodage du fichier
                $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;

                # stocker l'encodage du fichier
                my $encodage=$1;

                # vérifier si l'encodage n'est pas vide pour traiter le contenu IF3
                if ($encodage ne "")
                {
                    # la variable tmptexteXML stocke les contenus prêts à être écrits dans fichier .xml de sortie
                    my $tmptexteXML="<file>\n";

                    # créer balise avec le nom du fichier
                    $tmptexteXML.="<name>$file</name>\n";

                    # éliminier les balises avec des espaces en blanc
                    $texte =~ s/> *</></g;

                    # regex pour capturer date
                    $texte=~/<pubDate>([^<]+)<\/pubDate>/;

                    # stocker la valeur de date capturée par la regex
                    $tmptexteXML.="<date>$1</date>\n";

                    # insérer la balise <items>
                    $tmptexteXML.="<items>\n";

                    my $tmptexteBRUT="";

                    open(FILE,"<:encoding($encodage)", $file);

                    $texte="";

                    # lire le fichier ligne à ligne
                    while (my $ligne=<FILE>)
                    {
                        chomp  $ligne;
                        $texte .= $ligne;
                    }
                    close(FILE);

                    $texte=~s/> *</></g;

                    # on recherche la rubrique
                    $texte=~/<channel><title>([^<]+)<\/title>/;

                    # on met le contenu trouvé par la regex dans $rub
                    my $rub=$1;

                    # nettoyer le string rubrique
                    $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                    $rub =~ s/é/e/gi;
                    $rub =~ s/è/e/gi;
                    $rub =~ s/ê/e/gi;
                    $rub =~ s/à/a/gi;
                    $rub =~ s/Le ?Monde.fr ?://;
                    $rub =~ s/ //g;

                    $rub=uc($rub);

                    my $output1="SORTIE-extract-txt-".$rub.".xml";
                    my $output2="SORTIE-extract-txt-".$rub.".txt";
                    if (!open (FILEOUTXML,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
                    if (!open (FILEOUTTXT,">>:encoding(utf-8)", $output2)) { die "Pb a l'ouverture du fichier $output2"};

                    # lire texte pour extraire contenu des balises <title> et <description>
                    while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g)
                    {
                        # capturer contenu de la regex pour titre
                        my $titre=$1;

                        # capturer contenu de la regex pour description
                        my $resume=$2;

                        # utilisation des modules pour remplacer dans les fichiers les entités XML et HTML
                        if (!(exists ($dictionnairedesitems{$titre})) and !(exists ($dictionnairedesitems{$resume})))
                        {
                            $dictionnairedesitems{$titre}++;
                            $dictionnairedesitems{$resume}++;
                            $titre = XML::Entities::decode('all', $titre);
                            $resume = XML::Entities::decode('all', $resume);
                            $titre = HTML::Entities::decode($titre);
                            $resume = HTML::Entities::decode($resume);
                            $tmptexteBRUT.="$titre \n";
                            $tmptexteBRUT.="$resume \n";
                            $tmptexteXML.="<item><title>$titre</title><description>$resume</description></item>\n";

                            # nettoyage des balises <description> pour supprimer les balises superflues
                            $tmptexteXML =~ s/<img.*?\/><\/description>/<\/description>/g;
                            $tmptexteBRUT =~ s/<img.*?\/> \n/\n/g;
                        }

                        # si le fichier n'est pas en UTF-8, convertir le string $titre et $resume en UTF-8
                        if (uc($encodage) ne "UTF-8")
                        {
                            utf8($titre);
                            utf8($resume);
                        }

                    } # fin while

                    # rajouter la fin des balises <items> et <file>
                    $tmptexteXML.="</items>\n</file>\n";

                    # écrire contenu dans le fichier .xml
                    print FILEOUTXML $tmptexteXML;

                    # écrire contenu dans le fichier .txt
                    print FILEOUTTXT $tmptexteBRUT;

                    # fermer fichiers
                    close FILEOUTXML;
                    close FILEOUTTXT;

                } else {

                    #si l'encodage est vide afficher message
                    print "$file ==> $encodage \n";

                } # fin IF3
            } # fin IF 2
        } # fin IF 1
    } # fin FOR
} # fin lire_et_ecrire_xml()


####################################################################################################
#                                                                                                  #
# cette fonction reçoit un nom de dossier comme argument et lit tous les fichiers .xml du dossier  #
# Pour chaque fichier lu, la fonction extrait les rubriques et crée des fichiers de sortie         #
# possédant le nom de la rubrique                                                                  #
#                                                                                                  #
####################################################################################################
sub extraire_rubrique {

    #lire le nom dossier passé comme argument
    my $path = shift(@_);

    #ouvrir le dossier
    opendir(DIR, $path) or die "can't open $path: $!\n";

    #lire la liste de fichier du dossier
    my @files = readdir(DIR);
    closedir(DIR);

    # lire un à un les items du dossier
    foreach my $file (@files)
    {
        # ignorer les items cachés
        next if $file =~ /^\.\.?$/;

        # construire le chemin complet avec le nom du dossier + item traité
        $file = $path."/".$file;

        # vérifier si l'item est un dossier
        if (-d $file)
        {
            # si l'item qu'on est en train de traiter est un dossier, on recommence la procédure
            &extraire_rubrique($file);
        }

        # vérifier si l'item est un fichier - IF1
        if (-f $file)
        {
            # tester si fichier possède l'extension .xml et ne contient pas la substring fil dans le nom - IF2
            if (($file =~ /\.xml$/) && ($file!~/\/fil.+\.xml$/))
            {
                #ouvrir fichier .xml
                open(FILE,$file);

                #variable pour stocker le contenu du fichier .xml
                my $texte="";

                #lire toutes les lignes du fichier .xml
                while (my $ligne=<FILE>)
                {
                    # effacer les retours à la ligne
                    chomp $ligne;

                    # stocker le contenu de ligne lue
                    $texte .= $ligne;
                }

                # fermer le fichier .xml
                close(FILE);

                # regex pour capture l`encodage du fichier
                $texte =~ /encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;

                # stocker le contenu trouvé par la regex
                my $encodage=$1;

                # vérifier la contenu de regex n'est pas vide IF3
                if ($encodage ne "")
                {
                    # reouvrir le fichier avec l'encogade correcte
                    open(FILE,"<:encoding($encodage)", $file);

                    # variables pour stocker le contenu du fichier lu
                    $texte="";

                    # lire le fichier .xml
                    while (my $ligne=<FILE>)
                    {
                        # effacer les retours à la ligne
                        chomp $ligne;

                        # stocker le contenu de ligne lue
                        $texte .= $ligne;
                    }

                    # fermer le fichier .xml
                    close(FILE);

                    # effacer les espaces en blanc
                    $texte =~ s/> *</></g;

                    # capturer le contenu à l'intérieur des balises <title> - IF4
                    if ($texte=~ /<channel><title>([^>]+)<\/title>/)
                    {
                        print $texte;

                        # stocker la valeur de rubrique trouvée par la regex
                        my $rub=$1;

                        # nettoyer les noms des rubriques
                        $rub =~ s/Toute l'actualité sur Le Monde.fr.//gi;
                        $rub =~ s/é/e/gi;
                        $rub =~ s/è/e/gi;
                        $rub =~ s/ê/e/gi;
                        $rub =~ s/à/a/gi;
                        $rub =~ s/Le ?Monde.fr ?://;
                        $rub =~ s/ //g;

                        $rub=uc($rub);

                        # stocker la rubrique dans le dictionnaire des rubriques
                        $dictionnairesdesrubriques{$rub}++;

                    } # fin IF4
                } # fin IF3
            } # fin IF2
        }   # fin IF1
    } # fin FOR
} # fin extraire_rubrique()

#/usr/bin/perl
use Unicode::String qw(utf8);
#-----------------------------------------------------------
my $rep="$ARGV[0]";
# on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;
# on initialise une variable contenant le flux de sortie 
my %dictionnairedesitems=();
my %dictionnairesdesrubriques=();
#----------------------------------------
&parcoursarborescencefichierspourrepererlesrubriques($rep);    # on recupere les rubriques...
#----------------------------------------
my @liste_rubriques = keys(%dictionnairesdesrubriques);
foreach my $rub (@liste_rubriques) {
    print $rub,"\n";
    #----------------------------------------
    my $output1="SORTIE/SORTIE-extract-txt-".$rub.".xml";
    my $output2="SORTIE/SORTIE-extract-txt-".$rub.".txt";
    my $output3="SORTIE/SORTIE-extract-txt-".$rub."-treetagger.xml";
    if (!open (FILEOUT1,">:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
    if (!open (FILEOUT2,">:encoding(utf-8)",$output2)) { die "Pb a l'ouverture du fichier $output2"};
    if (!open (FILEOUT3,">:encoding(utf-8)",$output3)) { die "Pb a l'ouverture du fichier $output3"};
    print FILEOUT1 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUT1 "<PARCOURS>\n";
    print FILEOUT3 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUT3 "<PARCOURS>\n";
    close(FILEOUT1);
    close(FILEOUT2);
    close(FILEOUT3);
}
#----------------------------------------
&parcoursarborescencefichiers($rep);    # on traite tous les fichiers
#----------------------------------------
foreach my $rub (@liste_rubriques) {
    my $output1="SORTIE/SORTIE-extract-txt-".$rub.".xml";
    my $output3="SORTIE/SORTIE-extract-txt-".$rub."-treetagger.xml";
    if (!open (FILEOUT1,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
    if (!open (FILEOUT3,">>:encoding(utf-8)",$output3)) { die "Pb a l'ouverture du fichier $output3"};
    print FILEOUT1 "</PARCOURS>\n";
    print FILEOUT3 "</PARCOURS>\n";
    close(FILEOUT1);
    close(FILEOUT3);
}
exit;
#----------------------------------------------
#----------------------------------------------
sub parcoursarborescencefichiers {
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    foreach my $file (@files) {
    next if $file =~ /^\.\.?$/;
    $file = $path."/".$file;
    if (-d $file) {
        &parcoursarborescencefichiers($file);    #recurse!
    }
    if (-f $file) {
        if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/)) {
        open(FILE, $file);
        #print "Traitement de :\n$file\n";
        my $texte="";
        while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
        }
        close(FILE);
        $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
        my $encodage=$1;
        #print "ENCODAGE : $encodage \n";
        if ($encodage ne "") {
            print "Extraction dans : $file \n";
            my $tmptexteXML="<file>\n";
            $tmptexteXML.="<name>$file</name>\n";
            my $tmptexteXMLtagger="<file>\n";
            $tmptexteXMLtagger.="<name>$file</name>\n";
            $texte =~ s/> *</></g;
            $texte=~/<pubDate>([^<]+)<\/pubDate>/;
            $tmptexteXML.="<date>$1</date>\n";
            $tmptexteXML.="<items>\n";
            $tmptexteXMLtagger.="<date>$1</date>\n";
            $tmptexteXMLtagger.="<items>\n";
            my $tmptexteBRUT="";
            open(FILE,"<:encoding($encodage)", $file);
            #print "Traitement de :\n$file\n";
            $texte="";
            while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
            }
            close(FILE);
            $texte=~s/> *</></g;
            # on recherche la rubrique
            $texte=~/<channel><title>([^<]+)<\/title>/;
            my $rub=$1;
            $rub=~s/é/e/gi;
            $rub=~s/è/e/gi;
            $rub=~s/ê/e/gi;
            $rub=~s/à/a/gi;
            $rub=~ s/Le *Monde *\. *fr *://gi;
            $rub=~ s/ //g;
            $rub=~ s/s$//;
            $rub=uc($rub);
            #print $rub,"\n";
            #----------------------------------------
            my $output1="SORTIE/SORTIE-extract-txt-".$rub.".xml";
            my $output2="SORTIE/SORTIE-extract-txt-".$rub.".txt";
            my $output3="SORTIE/SORTIE-extract-txt-".$rub."-treetagger.xml";
            if (!open (FILEOUT1,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
            if (!open (FILEOUT2,">>:encoding(utf-8)", $output2)) { die "Pb a l'ouverture du fichier $output2"};
            if (!open (FILEOUT3,">>:encoding(utf-8)", $output3)) { die "Pb a l'ouverture du fichier $output3"};
            #----------------------------------------
            my $compteurItem=0;
            my $compteurEtiquetage=0;
            while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g) {
            my $titre=$1;
            my $resume=$2;
            #print "T : $titre \n R : $resume \n";
            if (uc($encodage) ne "UTF-8") {utf8($titre);utf8($resume);}
            $titre = &nettoietexte($1);
            $resume = &nettoietexte($2);
            $compteurItem++;
            if (!(exists($dictionnairedesitems{$resume}))) {
                $compteurEtiquetage++;
                print "Etiquetage (num : $compteurEtiquetage)  sur item (num : $compteurItem) \n";
                            my ($titreetiquete,$texteetiquete)=&etiquetageavectreetagger($titre,$resume);
                $tmptexteBRUT.="§ $titre \n";
                $tmptexteBRUT.="$resume \n";
                $tmptexteXML.="<item><title>$titre</title><abstract>$resume</abstract></item>\n";
                $tmptexteXMLtagger.="<item>\n<title>\n$titreetiquete</title>\n<abstract>\n$texteetiquete</abstract>\n</item>\n";
                $dictionnairedesitems{$resume}++;
            }
            else {
                $tmptexteXML.="<item><title>-</title><abstract>-</abstract></item>\n";
            }
            }
            $tmptexteXML.="</items>\n</file>\n";
            $tmptexteXMLtagger.="</items>\n</file>\n";
            print FILEOUT1 $tmptexteXML;
            print FILEOUT2 $tmptexteBRUT;
            print FILEOUT3 $tmptexteXMLtagger;
            close FILEOUT1;
            close FILEOUT2;
            close FILEOUT3;
        }
        else {
            print "$file ==> $encodage \n";
        }
        }
    }
    }
}
#----------------------------------------------------
sub nettoietexte {
    my $texte=shift;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/&#233;/é/g;
    $texte =~ s/&#234;/ê/g;
    $texte =~ s/<[^>]+>//g;
    $texte =~ s/&nbsp;/ /g;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte=~s/&amp;#39;/'/g;
    $texte=~s/&amp;#34;/"/g;
    return $texte;
}
#-----------------------------------------------------------------------------------
sub parcoursarborescencefichierspourrepererlesrubriques {
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    foreach my $file (@files) {
    next if $file =~ /^\.\.?$/;
    $file = $path."/".$file;
    if (-d $file) {
        &parcoursarborescencefichierspourrepererlesrubriques($file);    #recurse!
    }
    if (-f $file) {
        if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/)) {
        open(FILE,$file);
        #print "Traitement de :\n$file\n";
        my $texte="";
        while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
        }
        close(FILE);
        $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
        my $encodage=$1;
        if ($encodage ne "") {
            open(FILE,"<:encoding($encodage)", $file);
            #print "Traitement de :\n$file\n";
            $texte="";
            while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
            }
            close(FILE);
            $texte =~ s/> *</></g;
            if ($texte=~ /<channel><title>([^>]+)<\/title>/) {
            my $rub=$1;
            $rub=~s/é/e/gi;
            $rub=~s/è/e/gi;
            $rub=~s/ê/e/gi;
            $rub=~s/à/a/gi;
            $rub=~ s/Le *Monde *\. *fr *://gi;
            $rub=~ s/ //g;
            $rub=~ s/s$//;
            $rub=uc($rub);
            $dictionnairesdesrubriques{$rub}++;
            }
        }
        else {
            #print "$file ==> $encodage \n";
        }
        }
    }
    }
}
sub etiquetageavectreetagger {
    my ($titre,$texte)=@_;
    #----- le titre
    my $codage="utf-8";
    my $tmptag="texteaetiqueter.txt";
    open (TMPFILE,">:encoding(utf-8)", $tmptag);
    print TMPFILE $titre,"\n";
    close(TMPFILE);
    system("perl ./treetagger-win32/cmd/tokenise-fr.pl $tmptag | tree-tagger.exe ./treetagger-win32/lib/french-utf8.par -lemma -token -no-unknown -sgml > treetagger.txt");
    
    system("perl ./treetagger-win32/cmd/treetagger2xml-utf8.pl treetagger.txt $codage ");
    # lecture du resultat tagge en xml :
    open(OUT,"<:encoding(utf-8)","treetagger.txt.xml");
    my $fistline=<OUT>;
    my $titreetiquete="";
    while (my $l=<OUT>) {
    $titreetiquete.=$l;
    }
    close(OUT);
    #----- le resume
    open (TMPFILE,">:encoding(utf-8)", $tmptag);
    print TMPFILE $texte,"\n";
    close(TMPFILE);
    system("perl ./treetagger-win32/cmd/tokenise-fr.pl $tmptag | tree-tagger.exe ./treetagger-win32/lib/french-utf8.par -lemma -token -no-unknown -sgml > treetagger.txt");
    system("perl ./treetagger-win32/cmd/treetagger2xml-utf8.pl treetagger.txt $codage");
    # lecture du resultat tagge en xml :
    open(OUT,"<:encoding(utf-8)","treetagger.txt.xml");
    my $fistline=<OUT>;
    my $texteetiquete="";
    while (my $l=<OUT>) {
    $texteetiquete.=$l;
    }
    close(OUT);
    # on renvoie les resultats :
    return ($titreetiquete,$texteetiquete);
}

#/usr/bin/perl
use Unicode::String qw(utf8);
#-----------------------------------------------------------
my $rep="$ARGV[0]";
# on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;
# on initialise une variable contenant le flux de sortie 
my %dictionnairedesitems=();
my %dictionnairesdesrubriques=();
#----------------------------------------
&parcoursarborescencefichierspourrepererlesrubriques($rep); # on recupere les rubriques...
#----------------------------------------
my @liste_rubriques = keys(%dictionnairesdesrubriques);
foreach my $rub (@liste_rubriques) {
    print $rub,"\n";
    #----------------------------------------
    my $output1="SORTIE/SORTIE-extract-txt-".$rub.".xml";
    my $output2="SORTIE/SORTIE-extract-txt-".$rub.".txt";
    my $output3="SORTIE/SORTIE-extract-txt-".$rub."-treetagger.xml";
    if (!open (FILEOUT1,">:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
    if (!open (FILEOUT2,">:encoding(utf-8)",$output2)) { die "Pb a l'ouverture du fichier $output2"};
    if (!open (FILEOUT3,">:encoding(utf-8)",$output3)) { die "Pb a l'ouverture du fichier $output3"};
    print FILEOUT1 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUT1 "<PARCOURS>\n";
    print FILEOUT3 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
    print FILEOUT3 "<PARCOURS>\n";
    close(FILEOUT1);
    close(FILEOUT2);
    close(FILEOUT3);
}
#----------------------------------------
&parcoursarborescencefichiers($rep);    # on traite tous les fichiers
#----------------------------------------
foreach my $rub (@liste_rubriques) {
    my $output1="SORTIE/SORTIE-extract-txt-".$rub.".xml";
    my $output3="SORTIE/SORTIE-extract-txt-".$rub."-treetagger.xml";
    if (!open (FILEOUT1,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
    if (!open (FILEOUT3,">>:encoding(utf-8)",$output3)) { die "Pb a l'ouverture du fichier $output3"};
    print FILEOUT1 "</PARCOURS>\n";
    print FILEOUT3 "</PARCOURS>\n";
    close(FILEOUT1);
    close(FILEOUT3);
}
exit;
#----------------------------------------------
#----------------------------------------------
sub parcoursarborescencefichiers {
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    foreach my $file (@files) {
    next if $file =~ /^\.\.?$/;
    $file = $path."/".$file;
    if (-d $file) {
        &parcoursarborescencefichiers($file);   #recurse!
    }
    if (-f $file) {
        if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/)) {
        open(FILE, $file);
        #print "Traitement de :\n$file\n";
        my $texte="";
        while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
        }
        close(FILE);
        $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
        my $encodage=$1;
        #print "ENCODAGE : $encodage \n";
        if ($encodage ne "") {
            print "Extraction dans : $file \n";
            my $tmptexteXML="<file>\n";
            $tmptexteXML.="<name>$file</name>\n";
            my $tmptexteXMLtagger="<file>\n";
            $tmptexteXMLtagger.="<name>$file</name>\n";
            $texte =~ s/> *</></g;
            $texte=~/<pubDate>([^<]+)<\/pubDate>/;
            $tmptexteXML.="<date>$1</date>\n";
            $tmptexteXML.="<items>\n";
            $tmptexteXMLtagger.="<date>$1</date>\n";
            $tmptexteXMLtagger.="<items>\n";
            my $tmptexteBRUT="";
            open(FILE,"<:encoding($encodage)", $file);
            #print "Traitement de :\n$file\n";
            $texte="";
            while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
            }
            close(FILE);
            $texte=~s/> *</></g;
            # on recherche la rubrique
            $texte=~/<channel><title>([^<]+)<\/title>/;
            my $rub=$1;
            $rub=~s/é/e/gi;
            $rub=~s/è/e/gi;
            $rub=~s/ê/e/gi;
            $rub=~s/à/a/gi;
            $rub=~ s/Le *Monde *\. *fr *://gi;
            $rub=~ s/ //g;
            $rub=~ s/s$//;
            $rub=uc($rub);
            #print $rub,"\n";
            #----------------------------------------
            my $output1="SORTIE/SORTIE-extract-txt-".$rub.".xml";
            my $output2="SORTIE/SORTIE-extract-txt-".$rub.".txt";
            my $output3="SORTIE/SORTIE-extract-txt-".$rub."-treetagger.xml";
            if (!open (FILEOUT1,">>:encoding(utf-8)", $output1)) { die "Pb a l'ouverture du fichier $output1"};
            if (!open (FILEOUT2,">>:encoding(utf-8)", $output2)) { die "Pb a l'ouverture du fichier $output2"};
            if (!open (FILEOUT3,">>:encoding(utf-8)", $output3)) { die "Pb a l'ouverture du fichier $output3"};
            #----------------------------------------
            my $compteurItem=0;
            my $compteurEtiquetage=0;
            while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g) {
            my $titre=$1;
            my $resume=$2;
            #print "T : $titre \n R : $resume \n";
            if (uc($encodage) ne "UTF-8") {utf8($titre);utf8($resume);}
            $titre = &nettoietexte($1);
            $resume = &nettoietexte($2);
            $compteurItem++;
            if (!(exists($dictionnairedesitems{$resume}))) {
                $compteurEtiquetage++;
                print "Etiquetage (num : $compteurEtiquetage)  sur item (num : $compteurItem) \n";
                            my ($titreetiquete,$texteetiquete)=&etiquetageavectreetagger($titre,$resume);
                $tmptexteBRUT.="§ $titre \n";
                $tmptexteBRUT.="$resume \n";
                $tmptexteXML.="<item><title>$titre</title><abstract>$resume</abstract></item>\n";
                $tmptexteXMLtagger.="<item>\n<title>\n$titreetiquete</title>\n<abstract>\n$texteetiquete</abstract>\n</item>\n";
                $dictionnairedesitems{$resume}++;
            }
            else {
                $tmptexteXML.="<item><title>-</title><abstract>-</abstract></item>\n";
            }
            }
            $tmptexteXML.="</items>\n</file>\n";
            $tmptexteXMLtagger.="</items>\n</file>\n";
            print FILEOUT1 $tmptexteXML;
            print FILEOUT2 $tmptexteBRUT;
            print FILEOUT3 $tmptexteXMLtagger;
            close FILEOUT1;
            close FILEOUT2;
            close FILEOUT3;
        }
        else {
            print "$file ==> $encodage \n";
        }
        }
    }
    }
}
#----------------------------------------------------
sub nettoietexte {
    my $texte=shift;
    $texte =~ s/&lt;/</g;
    $texte =~ s/&gt;/>/g;
    $texte =~ s/<a href[^>]+>//g;
    $texte =~ s/<img[^>]+>//g;
    $texte =~ s/<\/a>//g;
    $texte =~ s/&#38;#39;/'/g;
    $texte =~ s/&#38;#34;/"/g;
    $texte =~ s/&#233;/é/g;
    $texte =~ s/&#234;/ê/g;
    $texte =~ s/<[^>]+>//g;
    $texte =~ s/&nbsp;/ /g;
    $texte=~s/&#39;/'/g;
    $texte=~s/&#34;/"/g;
    $texte=~s/&amp;#39;/'/g;
    $texte=~s/&amp;#34;/"/g;
    return $texte;
}
#-----------------------------------------------------------------------------------
sub parcoursarborescencefichierspourrepererlesrubriques {
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    foreach my $file (@files) {
    next if $file =~ /^\.\.?$/;
    $file = $path."/".$file;
    if (-d $file) {
        &parcoursarborescencefichierspourrepererlesrubriques($file);    #recurse!
    }
    if (-f $file) {
        if (($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/)) {
        open(FILE,$file);
        #print "Traitement de :\n$file\n";
        my $texte="";
        while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
        }
        close(FILE);
        $texte=~/encoding ?= ?[\'\"]([^\'\"]+)[\'\"]/i;
        my $encodage=$1;
        if ($encodage ne "") {
            open(FILE,"<:encoding($encodage)", $file);
            #print "Traitement de :\n$file\n";
            $texte="";
            while (my $ligne=<FILE>) {
            $ligne =~ s/\n//g;
            $texte .= $ligne;
            }
            close(FILE);
            $texte =~ s/> *</></g;
            if ($texte=~ /<channel><title>([^>]+)<\/title>/) {
            my $rub=$1;
            $rub=~s/é/e/gi;
            $rub=~s/è/e/gi;
            $rub=~s/ê/e/gi;
            $rub=~s/à/a/gi;
            $rub=~ s/Le *Monde *\. *fr *://gi;
            $rub=~ s/ //g;
            $rub=~ s/s$//;
            $rub=uc($rub);
            $dictionnairesdesrubriques{$rub}++;
            }
        }
        else {
            #print "$file ==> $encodage \n";
        }
        }
    }
    }
}
sub etiquetageavectreetagger {
    my ($titre,$texte)=@_;
    #----- le titre
    my $codage="utf-8";
    my $tmptag="texteaetiqueter.txt";
    open (TMPFILE,">:encoding(utf-8)", $tmptag);
    print TMPFILE $titre,"\n";
    close(TMPFILE);
    system("perl ./treetagger-win32/cmd/tokenise-fr.pl $tmptag | tree-tagger.exe ./treetagger-win32/lib/french-utf8.par -lemma -token -no-unknown -sgml > treetagger.txt");
    
    system("perl ./treetagger-win32/cmd/treetagger2xml-utf8.pl treetagger.txt $codage ");
    # lecture du resultat tagge en xml :
    open(OUT,"<:encoding(utf-8)","treetagger.txt.xml");
    my $fistline=<OUT>;
    my $titreetiquete="";
    while (my $l=<OUT>) {
    $titreetiquete.=$l;
    }
    close(OUT);
    #----- le resume
    open (TMPFILE,">:encoding(utf-8)", $tmptag);
    print TMPFILE $texte,"\n";
    close(TMPFILE);
    system("perl ./treetagger-win32/cmd/tokenise-fr.pl $tmptag | tree-tagger.exe ./treetagger-win32/lib/french-utf8.par -lemma -token -no-unknown -sgml > treetagger.txt");
    system("perl ./treetagger-win32/cmd/treetagger2xml-utf8.pl treetagger.txt $codage");
    # lecture du resultat tagge en xml :
    open(OUT,"<:encoding(utf-8)","treetagger.txt.xml");
    my $fistline=<OUT>;
    my $texteetiquete="";
    while (my $l=<OUT>) {
    $texteetiquete.=$l;
    }
    close(OUT);
    # on renvoie les resultats :
    return ($titreetiquete,$texteetiquete);
}

#!/usr/bin/perl
<<DOC;
Votre Nom : Bienvenue, Poadey, Cavalcante
MARS 2015
 usage : perl parcours-arborescence-fichiers repertoire-a-parcourir
 Le programme prend en entrée le nom du répertoire contenant les fichiers
 à traiter
 Le programme construit en sortie des fichiers structurés : en format XML
 et en format TXT
DOC
use Unicode::String qw(utf8);
use utf8;
# pour pouvoir afficher la date
use Time::localtime;
#------------------------------------------------------------------------------
# des compteurs pour le nombre des items
my $nb_filesIN = 0;
my $nb_itemsIN = 0;
my $nb_itemsOUT = 0;
#------------------------------------------------------------------------------
# le répertoire d'entrée
my $rep = "$ARGV[0]";
# enlever le slash à la fin du répertoire
$rep =~ s/[\/]$//;
#------------------------------------------------------------------------------
# des hash tables pour vérifier qu'on n'a pas deux fois les même infos
my %dico_titre = ();
my %dico_description = ();
# cet hash nous permet de juste traiter une fois chaque texte
my %dico_files = ();
# creer l`objet date pour ecrire les dates dans le log
my $date_time = ctime();
#------------------------------------------------------------------------------
# creation des dossiers de sortie
my $res = "./Sorties/";
if (! -e $res) {
    mkdir($res) or die ("Problème avec la création du répertoire de $rep : $!");
}
$res = "./Sorties/Sorties_PurePerl/";
if (! -e $res) {
    mkdir($res) or die ("Problème avec la création du répertoire de $rep : $!\n");
}
#------------------------------------------------------------------------------
# sorties etiquetées
my $resBAO2 = "./Sorties/Sorties_Tagged/";
if (! -e $resBAO2) {
    mkdir($resBAO2) or die ("Problème avec la création du répertoire de $rep : $!\n");
}
#------------------------------------------------------------------------------
# sortie globale txt
open(FILEGLOBALTXT,">:encoding(UTF-8)", $res."SortieGlobale1.txt");
#------------------------------------------------------------------------------
&parcoursarborescencefichiers($rep);    #recurse!
#------------------------------------------------------------------------------
close FILEGLOBALTXT;
#------------------------------------------------------------------------------
# création de la sortie globale xml
open(FILEGLOBALXML, ">:encoding(UTF-8)", $res."SortieGlobale1.xml");
print FILEGLOBALXML "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
print FILEGLOBALXML "<PARCOURS>\n";
print FILEGLOBALXML "<NOM>Bienvenue, Poadey, Cavalcante</NOM>\n";
print FILEGLOBALXML "<FILTRAGE>";
#------------------------------------------------------------------------------
# écrire contenu de la sortie globale xml
opendir(DIR, $res) or die "Erreur d'ouverture du repertoire: $!\n";
my @sorties = readdir(DIR);
closedir(DIR);
foreach my $sortie (@sorties) {
    if ($sortie=~/(.+?)\.xml$/ && $1 != "SortieGlobale1") {
        my $rub=$1;
        open(FILE,">>:encoding(UTF-8)", $res.$sortie);
        print FILE "</".$rub.">\n";;
        print FILE "</PARCOURS>\n";
        close(FILE);
        print FILEGLOBALXML "<$rub>\n";
        print FILEGLOBALXML ${"DumpXML".$rub};
        print FILEGLOBALXML "</$rub>";
    }
}
print FILEGLOBALXML "</FILTRAGE>\n";
print FILEGLOBALXML "</PARCOURS>\n";
close(FILEGLOBALXML);
#------------------------------------------------------------------------------
open(FILEGLOBALXML, ">:encoding(UTF-8)", $resBAO2."SortieGlobale2.xml");
print FILEGLOBALXML "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
print FILEGLOBALXML "<PARCOURS>\n";
print FILEGLOBALXML "<NOM>Bienvenue, Poadey, Cavalcante</NOM>\n";
print FILEGLOBALXML "<FILTRAGE>";
#------------------------------------------------------------------------------
opendir(DIR, $resBAO2) or die "Erreur d'ouverture de repertoire: $!\n";
@sorties = readdir(DIR);
closedir(DIR);
foreach my $sortie (@sorties) {
    # se fait sur chaque sortie xml dans chaque rubrique
    if ($sortie=~/(.+?)\.xml$/ && $1 != "SortieGlobale2") {
        my $rub = $1;
        open(FILE,">>:encoding(UTF-8)", $resBAO2.$sortie);
        print FILE "</".$rub.">\n";;
        print FILE "</PARCOURS>\n";
        close FILE;
        print FILEGLOBALXML "<$rub>\n";
        print FILEGLOBALXML ${"DumpXML2_Tagged".$rub};
        print FILEGLOBALXML "</$rub>";
    }
}
#------------------------------------------------------------------------------
print FILEGLOBALXML "</FILTRAGE>\n";
print FILEGLOBALXML "</PARCOURS>\n";
close(FILEGLOBALXML);
#------------------------------------------------------------------------------
# imprime le nombre des infos à la fin du programme
print "\n" . "files IN = $nb_filesIN\n";
print "items IN = $nb_itemsIN\n";
print "items OUT = $nb_itemsOUT\n";
print "fin.\n";
exit;
# fin du main programme
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# commencement des subroutines
#------------------------------------------------------------------------------
# subroutine pour parcourir l'aborescence
sub parcoursarborescencefichiers {
    my $path = shift(@_); # chemin vers le dossier en entrée
    opendir(DIR, $path) or die "Probleme d'ouverture du dossier: $!\n";
    my @files = readdir(DIR);
    closedir(DIR);
    #--------------------------------------------
    foreach my $file (@files) {
        next if $file =~ /^\.\.?$/; #si . ou ..
        $file = $path."/".$file;
        #si $file est un dossier
        if (-d $file) {
            &parcoursarborescencefichiers($file);    #recurse!
        }
        # faire le traitement si $file est un fichier
        if (-f $file) {
            # traiter les fichiers xml seulement
            if ($file=~/^[^(fil)]+?\.xml$/) {
                $nb_filesIN++;
                print $file,"\n";
                #lire le fichier xml
                open(FILE,$file);
                my $firstLine = <FILE>;
                my $encodage = "";
                #vérifier encodage du fichier xml
                if($firstLine =~ /encoding= ?['"]([^\'"]+)['"]/) {
                    $encodage = $1; #extraire l'encodage
                }
                close(FILE);
                # si on trouve l'encodage, le fichier est reouvert avec l'encodage correcte
                if (!($encodage eq "")) {
                    open(FILE,"<:encoding($encodage)",$file);
                    my $texte = "";
                    #éliminer les retours à ligne dans le fichier [ \n et \r ]
                    while (my $ligne = <FILE>) {
                        $ligne =~ s/\n//g;
                        $ligne =~ s/\r//g;
                        $texte .= $ligne;
                    }
                    close FILE;
                    $texte =~ s/> *?</></g; # coller les balises
                    #-----------------------------------------
                    # extraire rubrique, date et nom
                    $texte =~ /<channel>.*?<title>(.*?)<\/title>.*?<pubDate>(.+?)<\/pubDate>.*?<\/channel>/;
                    # nettoyer les rubriques
                    my $rubrique = &nettoyerRubriques($1);
                    print "RUBRIQUE : $rubrique\n";
                    # extraire la date
                    my $date = &nettoyerRubriques($2);
                    # nom du fichier
                    my $name = $file;
                    # uniquement les fichiers XML contenant les mises à jour
                    $name =~ s/.*?(20.*)/$1/;
                    #------------------------------------------
                    # ouvre des balises et écrire dans des fichiers de sortie
                    my $cheminXML=$res.$rubrique.".xml";
                    # si on n'a pas encore vu le rubrique on doit le créer
                    if (! -e $cheminXML) {
                        # créer un fichier
                        if (!open (FILEOUT,">:encoding(UTF-8)",$cheminXML)) {
                            die "Probleme a la creation du fichier $cheminXML : $!";
                        }
                        # ouverture des balises XML du début du fichier
                        print FILEOUT "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
                        print FILEOUT "<PARCOURS>\n";
                        print FILEOUT "<NOM>Bienvenue, Poadey, Cavalcante</NOM>\n";
                        print FILEOUT "<$rubrique>\n";
                        print FILEOUT "<file>";
                        print FILEOUT "<name>$name</name>";
                        print FILEOUT "<date>$date</date>";
                        print FILEOUT "<items>";
                        close(FILEOUT);
                        ${"DumpXML"."$rubrique"}="";
                    }
                    # si le fichier existe déjà
                    else {
                        if (!open (FILEOUT,">>:encoding(UTF-8)",$cheminXML)) {
                            die "Problème a l'ouverture du fichier $cheminXML : $!\n";
                        }
                        print FILEOUT "<file>";
                        print FILEOUT "<name>$name</name>";
                        print FILEOUT "<date>$date</date>";
                        print FILEOUT "<items>";
                        close(FILEOUT);
                    }
                    #-------------------------------------------
                    my $cheminXML_BAO2=$resBAO2.$rubrique.".xml";
                    # si on n'a pas encore vu le rubrique
                    if (! -e $cheminXML_BAO2) {
                        # créer un fichier
                        if (!open (FILEOUT,">:encoding(UTF-8)",$cheminXML_BAO2)) {
                            die "Probleme a la creation du fichier $cheminXML_BAO2 : $!\n";
                        }
                        # ouverture des balises XML du début du fichier
                        print FILEOUT "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
                        print FILEOUT "<PARCOURS>\n";
                        print FILEOUT "<NOM>Bienvenue, Poadey, Cavalcante</NOM>\n";
                        print FILEOUT "<$rubrique>\n";
                        print FILEOUT "<file>";
                        print FILEOUT "<name>$name</name>";
                        print FILEOUT "<date>$date</date>";
                        print FILEOUT "<items>";
                        close(FILEOUT);
                        ${"DumpXML_tagged"."$rubrique"}="";
                    }
                    # si le fichier existe déjà
                    else {
                        if (!open (FILEOUT,">>:encoding(UTF-8)",$cheminXML_BAO2)) {
                            die "Problème a l'ouverture du fichier $cheminXML_BAO2 : $!\n";
                        }
                        print FILEOUT "<file>";
                        print FILEOUT "<name>$file</name>";
                        print FILEOUT "<date>$date</date>";
                        print FILEOUT "<items>";
                        close(FILEOUT);
                    }
                    #---------------------------------------------
                    # extractions des titres et descriptions
                    while ($texte =~ /<item>.*?<title>(.*?)<\/title>.*?<description>(.*?)<\/description>/g)
                    {
                        my $titre = $1;
                        my $description = $2;
                        $nb_itemsIN++;
                        #-----------------------------------------
                        # nettoyer le texte
                        $titre = &nettoyerTexte($titre);
                        $description = &nettoyerTexte($description);
                        if (!(($titre eq "") or ($description eq ""))) {
                            #-----------------------------------------
                            # convertir si besoin en utf-8
                            if (uc($encodage) ne "UTF-8") {
                                utf8($titre);
                                utf8($description);
                            }
                            #----------------------------------------------
                            # regarde si on a déjà vu le texte
                            if (!((exists $dico_titre{$rubrique . $titre}) && (exists $dico_description{$rubrique . $description})))
                            {
                                $dico_titre{$rubrique . $titre} = "1";
                                $dico_description{$rubrique . $description} = "1";
                                $nb_itemsOUT++;
                                #------------------------------------------
                                # faire l'etiquetage
                                my $titre_tagged = &treetagger($titre);
                                my $description_tagged = &treetagger($description);
                                open(LOG, ">>", "log_bao2.txt");
                                if(exists $dico_files{$file}){
                                    $count_file = int($dico_files{$file});
                                    $count_file++;
                                    %dico_files = ($file => $count_file);
                                } else {
                                    %dico_files = ($file => 1);
                                }
                                #creer l`objet date pour ecrire les dates dans le log
                                my $date_time = ctime();
                                #ecrire le fichier de log avec le nom du fichier et l`heure de lecture
                                print LOG $file." ".$dico_files{$file}."\t\t read on ".$date_time."\n";
                                # mettre dans les sorties xml
                                if (!open (FILEOUT,">>:encoding(UTF-8)",$cheminXML)) {
                                    die "Problème a l'ouverture du fichier $cheminXML : $!\n";
                                }
                                print FILEOUT "<item>\n";
                                print FILEOUT "<titre>" . $titre . "</titre>\n<description>" . $description . "</description>\n";
                                print FILEOUT "</item>\n";
                                close(FILEOUT);
                                #----------------------------------------------
                                # créer un dump pour chaque rubrique
                                ${"DumpXML" . $rubrique} .= "<item>\n<titre>" . $titre . "</titre>\n<description>" . $description . "</description>\n</item>\n";
                                #----------------------------------------------
                                # partie de sorties txt
                                my $cheminTXT = $res . $rubrique . ".txt";
                                # si on n'a pas encore vu la rubrique
                                if (! -e $cheminTXT) {
                                    if (!open (FILEGLOBALTXT,">>:encoding(iso-8859-15)",$cheminTXT)) {
                                        die "Problème a l'ouverture du fichier $cheminTXT : $!\n";
                                    }
                                    # écrire dans le sortie txt
                                    print FILEGLOBALTXT "$titre." . " $description.\n";
                                    close(FILEGLOBALTXT);
                                }
                                # si on a déjà vu la rubrique
                                else {
                                    if (!open (FILEGLOBALTXT,">>:encoding(iso-8859-15)",$cheminTXT)) {
                                        die "Problème a l'ouverture du fichier $cheminTXT : $!\n";
                                    }
                                    # écrire dans le sortie txt
                                    print FILEGLOBALTXT "$titre." . " $description.";
                                    close(FILEGLOBALTXT);
                                }
                                if (!open (FILEOUT,">>:encoding(UTF-8)",$cheminXML_BAO2)) {
                                    die "Problème a l'ouverture du fichier $cheminXML_BAO2 : $!\n";
                                }
                                print FILEOUT "<item>\n";
                                print FILEOUT "<titre>".$titre_tagged."</titre>\n<description>".$description_tagged."</description>\n";
                                print FILEOUT "</item>\n";
                                close(FILEOUT);
                                # créer un dump pour chaque rubrique
                                ${"DumpXML2_Tagged".$rubrique}.="<item>\n<titre>".$titre_tagged."</titre>\n<description>".$description_tagged."</description>\n</item>\n";
                            }
                        }
                    }
                    # fermer la balise file pour chaque fichier xml
                    if (!open (FILEOUT,">>:encoding(UTF-8)",$cheminXML))
                    {
                        die "Problème a l'ouverture du fichier .$cheminXML : $!\n";
                    }
                    print FILEOUT "</items>";
                    print FILEOUT "</file>";
                    close(FILEOUT);
                    # fermer la balise les fichier xml etiqutée
                    if (!open (FILEOUT,">>:encoding(UTF-8)",$cheminXML_BAO2)) {
                        die "Problème a l'ouverture du fichier .$cheminXML_BAO2 : $!\n";
                    }
                    print FILEOUT "</items>";
                    print FILEOUT "</file>";
                    close(FILEOUT);
                }
            }
        }
    }
}
#------------------------------------------------------------------------------
# subroutine pour nettoyer le texte
#------------------------------------------------------------------------------
sub nettoyerTexte {
    my $tx = $_[0];
    $tx =~ s/&#38;/&/g;
    $tx =~ s/&amp;/&/g;
    $tx =~ s/&#34;/"/g;
    $tx =~ s/&quot;/"/g;
    $tx =~ s/&#39;/'/g;
    $tx =~ s/&apos;/'/g;
    $tx =~ s/&#60;/</g;
    $tx =~ s/&lt;/</g;
    $tx =~ s/&#62;/>/g;
    $tx =~ s/&gt;/>/g;
    $tx =~ s/&#160;//g;
    $tx =~ s/&nbsp;//g;
    $tx =~ s/&#163;/£/g;
    $tx =~ s/&pound;/£/g;
    $tx =~ s/&#169;/©/g;
    $tx =~ s/&#171;/«/g;
    $tx =~ s/&laquo;/«/g;
    $tx =~ s/&#187;/»/g;
    $tx =~ s/&raquo;//g;
    $tx =~ s/&#201;/É/g;
    $tx =~ s/&Eacute;/É/g;
    $tx =~ s/&#237;/î/g;
    $tx =~ s/&icirc;/î/g;
    $tx =~ s/&#239;/ï/g;
    $tx =~ s/&iuml;/ï/g;
    $tx =~ s/&#224;/à/g;
    $tx =~ s/&agrave;/à/g;
    $tx =~ s/&#226;/â/g;
    $tx =~ s/&acirc;/â/g;
    $tx =~ s/&#231;/ç/g;
    $tx =~ s/&ccedil;/ç/g;
    $tx =~ s/&#232;/è/g;
    $tx =~ s/&egrave;/è/g;
    $tx =~ s/&#233;/é/g;
    $tx =~ s/&eacute;/é/g;
    $tx =~ s/&#234;/ê/g;
    $tx =~ s/&ecirc;/ê/g;
    $tx =~ s/&#244;/ô/g;
    $tx =~ s/&ocirc;/ô/g;
    $tx =~ s/&#251;/û/g;
    $tx =~ s/&ucirc;/û/g;
    $tx =~ s/&#252;/ü/g;
    $tx =~ s/&uuml;/ü/g;
    $tx =~ s/\x9c/œ/g;
    $tx =~ s/<br\/\>//g;
    $tx =~ s/<img.*?\/>//g;
    $tx =~ s/<.+?>//sg;
    $tx =~ s/<a.*?>.*?<\/a>//g;
    $tx =~ s/<![CDATA[(.*?)]]>/$1/g;
    $tx =~ s/<[^>]>//g;
    $tx =~ s/\.$//;
    $tx =~ s/&/et/g;
    return $tx;
}
#------------------------------------------------------------------------------
# subroutine pour nettoyer des rubriques
#------------------------------------------------------------------------------
sub nettoyerRubriques {
    my $rubrique = shift;
    $rubrique =~ s/Le Monde.fr//g;
    $rubrique =~ s/LeMonde.fr//g;
    $rubrique =~ s/: Toute l'actualité sur//g;
    $rubrique =~ s/É/e/g;
    $rubrique =~ s/é/e/g;
    $rubrique =~ s/è/e/g;
    $rubrique =~ s/ê/a/g;
    $rubrique =~ s/ë/e/g;
    $rubrique =~ s/ï/i/g;
    $rubrique =~ s/î/i/g;
    $rubrique =~ s/à/a/g;
    $rubrique =~ s/ô/o/g;
    $rubrique =~ s/,/_/g;
    $rubrique = uc($rubrique);
    $rubrique =~ s/ //g;
    $rubrique =~ s/[\.\:;\'\"\-]+//g;
    return $rubrique;
}
#------------------------------------------------------------------------------
# subroutine pour le tokenisation et etiquetage
#------------------------------------------------------------------------------
sub treetagger {
    my $texte = shift;
    my $temptag;
    # créer un fichier temporaire pour tagger des morceaux de texte
    open($temptag, ">:encoding(UTF-8)", "./temptag.txt");
    print $temptag $texte;
    close($temptag);
    system("perl tokenise-utf8.pl ./temptag.txt | /home/alexandre/tree-tagger/bin/tree-tagger -lemma -token -no-unknown -sgml /home/alexandre/tree-tagger/models/french.par > treetagger.txt");
    system("perl ./treetagger2xml-utf8.pl treetagger.txt utf-8");
    open(TaggedOUT,"<:encoding(utf-8)","treetagger.txt.xml");
    my $tagged_text = "";
    #lire la ligne d'en tête du fichier xml étiqueté, pour éviter que cette
    # ligne soit inclue dans le nouveau fichier xml
    my $line_den_tete = <TaggedOUT>;
    while (my $l = <TaggedOUT>) {
        $tagged_text .= $l;
    }
    close(TaggedOUT);
    return $tagged_text;
}
# fin des subroutines
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------