#/usr/bin/perl
<<DOC;
Votre Nom : Thomas Ragot
JANVIER 2005
 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

#-------------------------------------------------------------------------
#                      PROGRAMME PRINCIPAL
#-------------------------------------------------------------------------

# on initialise une variable contenant l'argument passé au programme
my $rep="$ARGV[0]";
# on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;
# on initialise des variables contenant les flux de sortie
my $dumpfull="";
my $tagfull="";
my $xmlfull="";
my $xmltagfull="";

# on crée une variable contenant l'entête xml pour éviter de se répêter inutilement
my $entetexml= "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>";

#on crée un tableau de variables contenant les noms des différents fichier de sortie.
my @output = ("resultats/".$rep."sortie.txt", "resultats/".$rep."sortietag.txt", "resultats/".$rep."sortie.xml", "resultats/".$rep."sortietag.xml");

# lancement du sous-programme de parcours d'arborescence.
#----------------------------------------
&parcoursarborescencefichiers($rep);  #recurse!
#----------------------------------------

# Ecriture des résultats dans les différents fichiers de sortie
ecritDansFichier ($output[0], $dumpfull);
ecritDansFichier ($output[1], $tagfull);
ecritDansFichier ($output[2], "$entetexml\n<?xml-stylesheet type=\"text/xsl\" href=\"sortie.xsl\"?><PARCOURS><NOM>Thomas Ragot</NOM>\n<FILTRAGE>$xmlfull</FILTRAGE>\n</PARCOURS>\n");
ecritDansFichier ($output[3], "$entetexml\n<?xml-stylesheet type=\"text/xsl\" href=\"sortietag.xsl\"?><PARCOURS><NOM>Thomas Ragot</NOM>\n<ETIQUETAGE>$xmltagfull</ETIQUETAGE>\n</PARCOURS>\n");

# extraction des patrons
print STDOUT "patrons à analyser (format, exemple : NOM_ADJ-ADJ_NOM ) ?";
$patrons = <STDIN>;
chomp ($patrons);
$fichier_extraction = "extractionTerminologique/$patrons";
$extraction =`perl trouve_terme2.pl $output[1] $patrons`;
ecritDansFichier ($fichier_extraction, $extraction);

#Conversion GraphML
$graphML = `perl patron2graphml2.pl $fichier_extraction`;
$fichierGraphml="pajek/$patrons.graphml";
ecritDansFichier ($fichierGraphml, $graphML);

#Conversion Pajek
$pajek = `xsltproc pajek/GraphML2Pajek.xsl $fichierGraphml `;
$fichierPajek="pajek/$patrons.net";
ecritDansFichier ($fichierPajek, $pajek);

#fin du programme
exit;

#-------------------------------------------------------------------------
#                      SOUS-PROGRAMMES
#-------------------------------------------------------------------------

sub parcoursarborescencefichiers
{
    #récupération du nom du répertoire
    my $path = shift(@_);
    #ouverture du répertoire  
    opendir(DIR, $path) or die "can't open $path: $!\n";
    #création d'un tableau contenant les noms des fichiers(et des répertoires) du répertoire.
    my @files = readdir(DIR);
    #fermeture du répertoire
    closedir(DIR);
    # boucle lisant tous les fichiers (et répertoires) du répertoire
    foreach my $file (@files)
  {
    # on ne lis pas les fichiers cachés
  next if $file =~ /^\.\.?$/;
      $file = $path."/".$file;

    # si on tombe sur un répertoire on relance le sous-programme
  if (-d $file)
    {
       &parcoursarborescencefichiers($file); #recurse!
    }
    # si on tombe sur un fichier on le traite
  if (-f $file)
    {
    #TRAITEMENT à réaliser sur chaque fichier
    #on initialise les variable contenant les données à renvoyer au programme principal.
    my $dumpfile="";
    my $tagfile="";
    my $xmlfile="";
    my $xmltagfile="";

    # on ouvre le fichier d'entrée (le fichier RSS )
    open(FILEINPUT, $file );
    # on le lit ligne par ligne
    while ($line = <FILEINPUT>)
      {
      # lorsqu'on rencontre une balise description
      if ($line=~/<description>(.*)<\/description>/)
        {
        $line="$1\n";
        #  on se débarrasse des problèmes de caractères
                # (voir sous programme corrige-caracteres)
                $line=corrige_caracteres($line);
        # On etiquette la ligne
                $tagline= treetagger ($line);
                # on encapsule le résultat dans des balises XML
                $xmltagline= traitementxml($tagline);
        #on concatène les résultats obtenus au résultats obtenues pour les lignes précédentes  
                $dumpfile .= "$line\n";
        $tagfile .= "$tagline\n";
        $xmlfile .= "<file><name>$file</name><lines>$line</lines></file>\n";
        $xmltagfile .="<file><name>$file</name>$xmltagline</file>";

        }
      }
        # on ferme le fichier lu    
    close(FILEINPUT) ;
    #on concatene les resultats obtenus pour le fichier à ceux des fichiers précédents.
        $dumpfull .= "$dumpfile\n";
    $tagfull .= "$tagfile\n";
    $xmlfull .= "$xmlfile\n";
    $xmltagfull .= "$xmltagfile\n";
    # on incrémente un compteur permettant de voir où on en estdans le traitement de l'arborescence.
    print $i++,"\n";
    }
      }
}

sub traitementxml
# adaptation du programme treetagger2xml.pl, prend en entrée un texte étiqueté par tree-tagger et le balise pour la sortie en XML.
{
  my $tag = "";
  my @lines = split(/\n/,shift(@_));
  foreach $line (@lines)
  {
    if ($line!~/\ô\¯\:\\ô\¯\:\\/)
    {
    # Remplacement des guillemets par <![CDATA["]]> (évite erreur d'interprétation XML)
       $line=~s/\"/<![CDATA[\"]]>/g;
       $line=~s/([^\t]*)\t([^\t]*)\t(.*)/<element>\n <data type=\"type\">$2<\/data>\n <data type=\"lemma\">$3<\/data>\n <data type=\"string\">$1<\/data>\n<\/element>/;
    $line=~s/<(unknown)>/$1/g; 
       $tag .= $line;
    }
      }
return $tag;

}


sub corrige_caracteres
# sous-programmes remplaçant les caractères mal codés par leurs équivalents correctement codés.
{
  $line = shift;
  $line =~ s/&#38;#39;/\'/g;
  $line =~ s/&#38;#34;/\"/g;
  $line =~ s/&#233;/é/g;
  $line =~ s/&#234;/ê/g;
  $line =~ s/ê/ê/g;
  $line =~ s/è/è/g;
  $line =~ s/ç/ç/g;
  $line =~ s/é/é/g;
  $line =~ s/Ã/à/g;
  $line =~ s/à´/ô/g;
  return $line;
}
sub treetagger
# programme réalisant l'étiquetage morpho-syntaxique d'une ligne de texte donnée.
{
    # récupération de la ligne envoyée en argument au sous-programme
    my $line=shift;
    # écriture dans un fichier temporaire de la ligne à etiqueter
    open (TMP, ">ligne.txt" );
  print TMP $line;
  close  (TMP) ;
    # découpage de la ligne à l'aide d'un script externe
  $linetokenise = `perl tokenize.pl -f ligne.txt`;
  #ecriture du résultat dans un nouveau fichier temporaire
    open (TMP, ">ligne.txt" );
  print TMP $linetokenise;
  close  (TMP) ;
    #etiquetage de la ligne
  system ("TreeTagger/bin/tree-tagger.exe -token -lemma -no-unknown TreeTagger/lib/french.par ligne.txt tag.txt");
  # récupération du résultat à partir du fichier créé par le TreeTagger
    open (TMP, "tag.txt" );
  @tagline=<TMP>;
  close  (TMP) ;
    # renvoi au programme principal du résultat
    return join("",@tagline);
 
}

sub ecritDansFichier
#sous-programme prenant en entrée le nom d'un fichier et une variable et écrivant le contenu de cette variable dans ce fichier.
{
  $fichier=shift;
  $contenu=shift;
if (!open (FICHIER,">$fichier")) { die "Pb a l'ouverture du fichier $fichier"};
  print FICHIER $contenu ;
  close (FICHIER);
}