1. <<DOC;
  2. Uyên-To DOAN-RABIER
  3. Ruixin HE
  4. Mohamed Sofiane KERROUA
  5.  
  6. BàO - Expression régulière
  7.  
  8. En utilisant uniquement des expressions régulières, produit en sortie des fichiers contenant les résumés de fils rss
  9. contenus dans des fichiers xml dans une arborescence donnée.
  10.  
  11. usage : bao1_regexp.pl nom_du_répertoire
  12.  
  13. DOC
  14.  
  15. #/usr/bin/perl
  16. #use strict;
  17. #use warnings;
  18. use Unicode::String qw(utf8);
  19.  
  20. #-----------------------------------------------------------
  21. # Procédure principale
  22. #-----------------------------------------------------------
  23. #Les fichiers sont créés dans un répertoire "resultat"
  24. mkdir(resultat);
  25.  
  26. #-----------------------------------------------------------
  27. # on initialise une variable $rep contenant le flux de sortie
  28. my $rep="$ARGV[0]";
  29. # on s'assure que le nom du répertoire ne se termine pas par un "/"
  30. $rep=~ s/[\/]$//;
  31.  
  32. #-----------------------------------------------------------
  33. # Initialisation d'un tableau de hash évitant la répétition du contenu des fils rss
  34. my %tabcontenu = ();
  35. &parcoursarborescencefichiers($rep);    #recurse!
  36.  
  37. #-----------------------------------------------------------
  38. $cheminrep ="./resultat";
  39. # On ouvre le répertoire "résultat" contenant les fichiers de sortie xml et txt
  40. # On ajoute à chaque fichier xml la balise fermante </file>
  41. # On convertit chaque fichier txt en iso-8859-1 et on le place dans le dossier cordial
  42. opendir(DIRS,$cheminrep) or die "can't open $cheminrep: $!\n";
  43. my @files = readdir(DIRS);
  44. closedir(DIRS);
  45. foreach my $fichier(@files){
  46.     next if $fichier =~ /^\.\.?$/;
  47.             # A chaque fichier xml crée en sortie on ajoute la balise fermante </file>
  48.             if($fichier =~/\.xml$/){
  49.                 open(OUT,">>:encoding(utf-8)","./resultat/$fichier");
  50.                 print OUT "</file>\n";
  51.                 close(OUT);
  52.             }
  53. }
  54.  
  55. exit; # Fin du programme
  56.  
  57. #-----------------------------------------------------------
  58. # Procédure "parcoursarborescencefichiers"
  59. # Parcours une arborescence et traite chaque fichier xml contenant des fils rss
  60. # Donnée : un répértoire passé en paramétre par valeur
  61. # Résultats : - le résultat du traitement au format txt
  62. #             - le résultat du traitement au format xml
  63. #             - le résultat du traitement au format xml avec un étiquetage réalisé tree-tagger
  64. sub parcoursarborescencefichiers {
  65. #-----------------------------------------------------------
  66. # Récupération du répertoire et ouverture du répertoire
  67.     my $path = shift(@_);
  68.     opendir(DIR, $path) or die "can't open $path: $!\n";
  69.     my @files = readdir(DIR);
  70.     closedir(DIR);
  71.  
  72. #-----------------------------------------------------------
  73. # Traitement de chaque fichier contenu dans le répertoire
  74.     foreach my $file (@files) {
  75.         next if $file =~ /^\.\.?$/;
  76.         $file = $path."/".$file;
  77. # Si on tombe sur un répertoire on relance la procédure
  78.         if (-d $file) {
  79.             &parcoursarborescencefichiers($file);   #recurse!
  80.         }
  81.        
  82. #-----------------------------------------------------------       
  83. # Traitement du fichier    
  84.         if (-f $file) {
  85. # Si le fichier est un fichier xml et si ce fichier xml n'est pas un fichier ne contenant pas fils rss on le traite
  86.             if(($file=~/\.xml$/) && ($file!~/\/fil.+\.xml$/) && ($file !~/0,2-3404,1-0,0\.xml$/)) {
  87.  
  88. # Initialisation des différentes variables         
  89.             my $rubrique="";
  90.             my $encodage = "";
  91.             my $encodagesortie="utf-8";
  92.             my $texte="";
  93.  
  94. #-----------------------------------------------------------
  95. # Si le fichier est vide pas de traitement
  96.             if (-z $file) {
  97.                 print "$file est vide: pas de traitement\n";
  98.             }else{
  99.  
  100. #-----------------------------------------------------------
  101. # Détection de l'encodage du fichier
  102.                     open(FIC,$file);
  103.                     while (my $ligne=<FIC>) {
  104.                     $ligne =~ s/\n//g;
  105.                     if($ligne =~/(iso-8859-1|utf-8)/ig){
  106.                         $encodage = $1;
  107.                     }
  108.                     }          
  109.                     close(FIC);
  110.  
  111. #-----------------------------------------------------------
  112. # Détection de la rubrique en mettant le texte sur une ligne, dans le cas ou il n'y a pas de rubrique ou classe le fichier dans les non-classés            
  113.                     open(FILE,"<:encoding($encodage)",$file);
  114.                     while (my $ligne=<FILE>){
  115.                     $ligne =~ s/\n//g;
  116.                     $texte .= $ligne;
  117.                     }
  118.                     close(FILE);
  119.                    
  120.                     if ($texte=~/<channel><title>([^<]+)<\/title>/){
  121.                         $rubrique = $1;  
  122.                         $rubrique=~s/é/e/gi;
  123.                         $rubrique=~s/è/e/gi;
  124.                         $rubrique=~s/ê/e/gi;
  125.                         $rubrique=~s/à/a/gi;
  126.                         $rubrique=~s/es /e/i;
  127.                         $rubrique=~ s/Le ?Monde.fr ?://;
  128.                         $rubrique=~ s/ ?- ?Le ?Monde.fr//;
  129.                         $rubrique=~ s/es$/e/i;
  130.                         $rubrique=~ s/ //g;
  131.                         $rubrique=uc($rubrique);
  132.                     }
  133.                                        
  134.                     if($rubrique eq ""){
  135.                     $rubrique = "non-classe";
  136.                     }  
  137.  
  138. #-----------------------------------------------------------
  139. # Création des fichiers de sortie                  
  140.                     open(OUT1,">>:encoding(utf-8)","./resultat/$rubrique.txt");
  141.                     open(OUT2,">>:encoding(utf-8)","./resultat/$rubrique.xml");
  142.  
  143. #-----------------------------------------------------------
  144. # Ajout des entêtes dans le fichier de sortie xml  
  145.                     if(-z OUT2){   
  146.                         print OUT2 "<?xml version=\"1.0\" encoding=\"$encodagesortie\" ?>\n";
  147.                         print OUT2 "<file>\n";
  148.                         print OUT2 "<name>$ARGV[0]</name>\n";
  149.                     }
  150.  
  151. #-----------------------------------------------------------
  152. # Suppression des espaces inutiles, détection de la date du fichier                    
  153.                     $texte =~ s/> *</></g;
  154.                     $texte=~/<pubDate>([^<]+)<\/pubDate>/;
  155.                     my $date=$1;
  156.  
  157. #-----------------------------------------------------------
  158. # Conversion de la date en utf-8 si l'encodage du fichier en entrée ne l'est pas
  159.                     if (uc($encodage) ne "UTF-8") {utf8($date);}
  160.                    
  161. #-----------------------------------------------------------
  162. # Ajoute de la date et de la balise ouvrante items dans le fichier de sortie xml
  163.                     print OUT2 "<date>".$date."</date>\n";
  164.                     print OUT2 "<items>\n";
  165.                    
  166. #-----------------------------------------------------------
  167. # Détection du titre et du résumé du fils rss
  168.                     while ($texte =~ /<item><title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g) {
  169.                     my $titre=$1;
  170.                     my $resume=$2;
  171.  
  172. #-----------------------------------------------------------
  173. # Test sur le titre du fil rss, si il est déjà contenu dans le tableau de hash on ne le traite pas
  174.                     my $test = $titre;
  175.                     if(!exists $tabcontenu{$test}){
  176.    
  177. #-----------------------------------------------------------
  178. # Conversion du titre et du résumé en utf-8 si l'encodage du fichier en entrée ne l'est pas
  179.                         if (uc($encodage) ne "UTF-8") {utf8($titre);utf8($resume);}
  180.  
  181. #-----------------------------------------------------------
  182. # Appel de la fonction "nettoietexte" avec comme paramétres le titre et le résumé
  183.                             $titre = &nettoietexte($titre);
  184.                             $resume = &nettoietexte($resume);
  185.  
  186. #-----------------------------------------------------------
  187. # On ajoute dans les différents fichiers le titre et le résumé
  188.                             print OUT1 "Titre : $titre \n";
  189.                             print OUT1 "Resume : $resume \n";
  190.                             print OUT2 "<item><title>$titre</title><abstract>$resume</abstract></item>\n";
  191.                            
  192. #-----------------------------------------------------------
  193. # On ajoute dans le tableau de hash le titre du fil rss
  194.                             $tabcontenu{$test}++;
  195.                         }
  196.                     }
  197.  
  198. #-----------------------------------------------------------
  199. # Fermeture de la balise items dans les fichiers xml, fermeture des fichiers
  200.                     print OUT2 "</items>\n";
  201.                     close(OUT1);
  202.                     close(OUT2);
  203.                 }
  204.             }
  205.         }
  206.     }
  207. } # Fin "parcoursarborescencefichiers"
  208.  
  209.  
  210. #-----------------------------------------------------------
  211. # Fonction "nettoietexte"
  212. # Nettoie un texte de ses entités xml
  213. # Donnée : une chaîne de caractère contenant des entités xml
  214. # Résultat : la chaîne de caractères nettoyée de ses entités xml
  215. sub nettoietexte {
  216.     my $texte=shift;
  217.     $texte =~ s/&lt;/</g;
  218.     $texte =~ s/&gt;/>/g;
  219.     $texte =~ s/<a href[^>]+>//g;
  220.     $texte =~ s/<img[^>]+>//g;
  221.     $texte =~ s/<\/a>//g;
  222.     $texte =~ s/&#38;#39;/'/g;
  223.     $texte =~ s/&#38;#34;/"/g;
  224.     $texte =~ s/&#233;/é/g;
  225.     $texte =~ s/&#234;/ê/g;
  226.     $texte =~ s/<[^>]+>//g;
  227.     $texte =~ s/&nbsp;/ /g;
  228.     $texte=~s/&#39;/'/g;
  229.     $texte=~s/&#34;/"/g;
  230.     $texte=~s/&amp;#39;/'/g;
  231.     $texte=~s/&amp;#34;/"/g;
  232.     return $texte;
  233. } # Fin "nettoietexte"
  234.  
  235.