L'objectif de cette première boîte à outils est de parcourir l'arborescence des archives de flux RSS pour leur appliquer un filtrage. Nous voulons extraire les balises <TITLE> et <DESCRIPTION> dans deux nouveaux fichiers : un au format texte brut, un autre au format XML.
Ainsi, des flux RSS, ne nous retenons que le titre et les quelques lignes de résumé de l'article, et nous supprimons les balises superflues à notre traitement, tels que les liens, le titre de la rubrique ou la date de publication.

Nous vous présenterons les deux scripts que nous avons fait en utilisant deux méthodes différentes.

XML::RSS est une bibliothèque Perl permettant de créer et mettre à jour les flux RSS. Cependant nous n'utilisons ici qu'une partie de ses fonctionnalités dans le but de parcourir l'arborescence des fils RSS. Ce script est le même que celui utilisant des expressions régulières mis à part la façon dont sont trouvées les informations.

Voici le bout de script permettant le parcours de l'arborescence du fil RSS :

if ($file =~ /0,2-$num,1-0,0\.xml$/) {
	$i++;
	print "numéro de fichier: $i: $file\n";
	my $encodage=`file -i $file | cut -d= -f2`;
	chomp($encodage);	
	open(FILE,"<:encoding($encodage)", $file);
	$DUMPFULL1.="<FICHIER num=\"$i\">$file";
	 			
	my $rss = new XML::RSS;
	eval {$rss->parsefile($file); }; 
	
	my $date=$rss->{'channel'}->{'pubDate'};
	$date=&nettoietexte($date);
	if (uc($encodage) ne "UTF-8") {utf8($date);}
	
	foreach my $item (@{$rss->{'items'}}) {
	 		my $titre=$item->{'title'};
	 		$titre=&nettoietexte($titre);
			$titre = HTML::Entities::decode($titre);
			$titre =~ s/&/et/g; #traitement du &
			$titre =~ s/<.+>//g; #suppr des balises
		
			#Traitement du résumé
			my $resume=$item->{'description'};
			chomp($resume);
			$resume = HTML::Entities::decode($resume);
			$resume =~ s/&/et/g; #traitement du &
			$resume =~ s/<.+>//g; #suppr des balises
		
			print $titre,"\n";
			unless (exists $dico1{$titre}){
				$dico1{$titre}++;
				if (uc($encodage) ne "UTF-8") {utf8($texte);}
				$DUMPFULL1.="<article>\n<titre>".$titre."</titre>\n <resume>".$resume."</resume>\n</article>\n";
				$DUMPFULL2.="TITRE : ".$titre."\n RESUME : ". $resume."\n\n";
			}
		}            
$DUMPFULL1.="</FICHIER>"; 
close (FILE); 
$texte="";
	}
}

Dans la première boucle if de ce morceau de script l'expression $file =~ /0,2-$num,1-0,0\.xml$/ se traduirait en français: "Si la variable $file contient l'expression 0,2-$num,1-0,0\.xml, alors on continue.".
➤ La partie =~ signifie "contient", de la même manière que == signifie "égale" dans le langage Perl.
➤ L'expression 0,2-$num,1-0,0\.xml est le format général du titre des fils RSS. En effet chaque fil commence par 0,2- et se termine par,1-0,0\.xml.
➤ La variable $num ici contient le numéro identifiant la rubrique des fils que nous voulons traiter. L'utilisateur peut faire son choix parmi plusieurs rubriques lors de l'éxecution du script.



Nous avons ensuite intégré dans notre script une boucle if permettant d'attribuer le numéro d'identifiant correspondant à la rubrique choisie à la variable $num.

$rub = <STDIN>;
chomp($rub);
if ($rub eq 0) {$num="3208";}
elsif ($rub eq 1) {$num="3210";}
elsif ($rub eq 2) {$num="3214";}
elsif ($rub eq 3) {$num="3260";}
elsif ($rub eq 4) {$num="3476";}
elsif ($rub eq 5) {$num="3224";}
elsif ($rub eq 6) {$num="3236";}
elsif ($rub eq 7) {$num="3238";}
elsif ($rub eq 8) {$num="3242";}
elsif ($rub eq 9) {$num="3232";}
elsif ($rub eq 10) {$num="3244";}
elsif ($rub eq 11) {$num="3546";}
elsif ($rub eq 12) {$num="3234";}
elsif ($rub eq 13) {$num="3246";}
else { 
 print "Vous n'avez pas donné un bon choix, la rubrique sélectionnée est par défaut la rubrique Voyage"; 
 $num="3546"; 
 }

La première ligne $rub = <STDIN>; permet de stocker dans la variable $rub le choix fait par l'utilisateur. La dernière ligne est ajoutée si une erreur de frappe est faite, pour que le script utilise la rubrique Voyages par défaut.
➤ Le dernier dollar désigne la fin de ligne du motif recherché. Enfin le tout est entre deux slashs pour délimiter l'expression régulière.

Après le traitement de la rubrique, on peut passer à la manipulation du fichier en lui-même. Dans cette version du script, on utilise donc la bibliothèque XML::RSS. Plusieurs lignes du script sont indispensables au bon fonctionnement de cette bibliothèque :
➤ use XML::RSS qui signale dès le début du script qu'on va utiliser la bibliothèque XML::RSS.
➤ my $rss = new XML::RSS qui crée un nouvel objet RSS...
➤ eval {$rss->parsefile($file);} ...où est parsé et stocké le fichier en cours de traitement.
La fonction eval en Perl vérifie si la valeur de l'expression mise entre crochet est valable. Si elle est valable, cette valeur est exécutée.
On a ensuite les lignes suivantes :
➤ my $date=$rss->{'channel'}->{'pubDate'}
➤ my $titre=$item->{'title'}
➤ my $resume=$item->{'description'}
Ces lignes permettent de naviguer dans le nouvel objet RSS dont j'ai mentionné la création ci-dessus. Par exemple, dans $date sera stocké la chaîne de caractères qui est contenu dans la balise 'pubDate' de l'objet RSS. On "indique" le chemin à prendre au script avec les éléments ->.

Un des plus grand avantage et intérêt de Perl est l'intégration des expressions régulières dans sa syntaxe, ce qui permet une grande facilité de manipulation de fichiers textuels.

La version de ce script utilise des expressions régulières là où nous utilisions la bibliothèque XML::RSS. Mis à part cette différence, les deux scripts sont équivalent dans leurs déroulements.

while ($ligne<FILE>){
  $ligne =~ s/></>\n</g;
  $texte .= $ligne;
}

$texte=&nettoietexte($texte);

while ($texte=~ /<item>\<title>(.+?)<\/title>.+?<description>(.+?)<\/description>/g){
  my $titre=$1;
  my $resume=$2;
  ...
}

➤ La première boucle while a été intégrée pour que les fils RSS écrits sur une ligne soient ordonnés en balises. Entre chaque fermeture de balise et ouverture de balise, on insère un saut de ligne.
➤ La seconde boucle while contient l'expression régulière équivalente à la fonction de la bibliothèque XML::RSS vue plus haut.
➢ L'expression (.+?) représente ici le motif recherché.
‣ Le fait de mettre l'expression entre parenthèse permet de cibler la partie à stocker dans une variable.
‣ Le point . reconnaît n'importe quel caractère.
‣ Le + seul signifie que le motif peut être reconnu une ou plusieurs fois.
‣ Le ? seul signifie que le motif peut être reconnu zéro ou une fois.
‣ Cependant associé ensemble +? signifie maintenant que n'importe quel caractère peut être reconnu une ou plusieurs fois, mais au minimum une fois. C'est ce qu'on appelle un quantificateur minimal (ou gourmand). Nous l'utilisons ici pour que ne soit pas stocké dans la variable tout ce qui se trouve entre la première balise <title> ouvrante et la dernière balise </title> fermante du fichier. En effet les balises <title></title> sont présentes plusieurs fois dans un fil RSS. Avec ce quantificateur minimal, la variable s'arrêtera à la première occurence de la balise fermante </title>.
➤ Les deux variables $1 et $2 vont récolter respectivement la contenance de la première expression régulière entre parenthèses et la contenance de la seconde expression régulière entre parenthèses.