Gleichmacherei

Nur lokal

Wenn in der Referenz kein Protokoll steckt, versuchen wir, die Datei zu öffnen:

open( DATEI, $datei );

DATEI ist ein sogenanntes Handle, mithin ein Stellvertreter für die Datei, deren Name in $datei steckt. Geht das in Ordnung, haben wir nichts zu berichtigen und können die Datei wieder schließen:

close DATEI;

Geht das Öffnen hingegen schief, …

if ( ! open( DATEI, $datei ) ){}

… müssen wir versuchen, den richtigen Dateinamen rauszubekommen. Wenn der in der Linkangabe mit einem / beginnt, bezieht er sich als absolute Pfadangabe nicht auf das Wurzelverzeichnis des Dateisystems, sondern auf die entsprechende Document Root auf dem Webserver. Halten wir also erst einmal das Verzeichnis in einer Variablen fest, das als Startverzeichnis für die Dateien der Website dient:

$rootDir = "/home/pjung/LU/LU1001/answergirl";

Dieser Umstand macht unsere Aufgabe etwas schwerer: Um eine im Link angegebene Datei, die mit / beginnt, zu finden, gilt es, nicht in /, sondern in $rootdir danach zu suchen. Gibt es etwas zu korrigieren, darf jedoch nicht $rootdir/korrigierter_Name zurück in den Link geschrieben werden, sondern lediglich /korrigierter_Name.

Was liegt also näher, als den korrigierten Namen und das Präfix, das wir zum Auffinden der Datei im Dateisystem brauchen, getrennt zu speichern? Setzt man die Inhalte beider Variablen, $praefix und $korrDat mit dem Punktoperator . zusammen, erhalten wir die Dateiangabe maßgeschneidert für's Dateisystem, nehmen wir nur $korrDat, haben wir die Angabe passend für den Link.

Schreiben wir also zunächst ein / in die Variable, die den korrigierten Link enthalten soll:

$korrDat = "/";

Außerdem merken wir uns das Root-Verzeichnis als Präfix:

$praefix = $rootDir;

Mit dieser Vorbereitung für's spätere Zusammensetzen im korrigierten Dateinamen können wir auf den Schrägstrich am Anfang (^) der in $datei gespeicherten Linkangabe verzichten. Um die Bedingung zu formulieren, unter der $korrDat und $praefix wie eben beschrieben gesetzt werden sollen, benutzen wir daher nicht den Match-, sondern den Substitute-Operator s. Wir sagen dem Skript einfach: "Wenn Du am Anfang von $datei einen / durch Nichts ersetzen kannst, setze $praefix und $korrDat wie eben besprochen."

Leider ist / mal wieder ein Fall für das Escape-Zeichen. Doch glücklicherweise gibt es eine Möglichkeit, das zu suchende und das ersetzende Muster nicht nur mit /, sondern auch mit anderen Sonderzeichen voneinander abzutrennen. Nehmen wir zum Beispiel das Dollarzeichen. Damit wird aus "Suche / am String-Anfang, und ersetze es durch Nichts" keine Escape-Orgie, sondern ein einfaches s$^/$$. Um diese Ersetzung gleich in der Variablen $datei vorzunehmen, sagen wir

$datei =~ s$^/$$;

Als Bedingung formuliert, sieht das dann so aus:

if ( $datei =~ s$^/$$ ){ }

War der Link kein absoluter, bleibt $korrDat noch leer, und im Präfix wird der Punkt als Stellvertreter des aktuellen Verzeichnisses samt Trenn-Slash gespeichert:

else {
   $praefix = "./";
 }

Häppchenweise

Wenn einmal der Link kaputt ist, kann dies am Dateinamen selbst oder an einem der im Pfad angegebenen Verzeichnisse liegen. Folglich müssen wir in den sauren Apfel beißen und jeden durch / getrennten Bestandteil von der Wurzel bis zur Spitze überprüfen. Dazu teilen wir den um einen eventuellen führenden / beraubten Inhalt von $datei an den Slash-Stellen in kleine Häppchen und speichern sie im Array @teile:

@teile = split( /\//, $datei );

Die split()-Funktion benötigt zwei Argumente: den String, den sie zerhacken soll, und das Trennzeichen. Statt nun einfach einen Delimiter anzugeben, kommt hier der Match-Operator zum Einsatz. Zwischen seine beiden /-Flügel setzen wir den die Verzeichnisse trennenden Slash /, und damit der nicht mit dem rechten Flügel-/ verwechselt werden kann, kommt ein \ davor.

Sukzessive nehmen wir die Teilchen nun unter die Lupe:

foreach $teil ( @teile ){ }

Wenn der Pfadbestandteil in $teil ein Punkt für das aktuelle oder () ein Doppelpunkt für das übergeordnete Verzeichnis ist, brauchen wir keine Schreibweise prüfen und fügen den Inhalt von $teil an den String an, der bereits in $korrdat steht:

if ( $teil eq "." || $teil eq ".." ){
   $korrDat .= $teil . "/" ;
 }

Perl kennt zwei Gleichheitsoperatoren: für numerische Werte und für Zeichenketten. Letzterer heißt eq ("equal"). $korrDat .= $teil; wiederum ist eine Kurzschreibweise für

$korrDat = $korrDat . $teil;

Mit dem Anhängeoperator für Zeichenketten, dem Punkt, fügen wir zudem einen Slash als Verzeichnistrenner ein.

Haben wir hingegen einen echten Datei- oder Verzeichnisnamen in $teil stehen, gibt es mehr zu tun. Versuchen wir zunächst, das, was bislang in $korrDat steht, zu verifizieren: Mit dem $praefix davor haben wir es mit einem Verzeichnis zu tun, dass es zu öffnen gilt:

opendir (VERZ, $praefix . $korrDat );

Schließen werden wir es später mit closedir( VERZ );. Sind wir beim Öffnen allerdings nicht erfolgreich, können wir gleich aufgeben und die Bearbeitung der @teile beenden:

opendir (VERZ, $praefix . $korrDat ) || last ;

last verlässt die aktive Schleife, sodass wir mit der Bearbeitung der nächsten $datei weitermachen können.

Wenn wir das Verzeichnis $praefix . $korrDat hingegen öffnen und den Handler VERZ "installieren" konnten, lesen wir am besten mit

readdir( VERZ );

alle darin vorhandenen Dateien aus. Gibt es dort eine Datei oder ein Verzeichnis mit dem Namen, der in $teil gespeichert ist? Auf der Shell würden wir dazu den grep-Befehl benutzen – und netterweise gibt es ihn auch in Perl:

grep ( /$teil/i , readdir( VERZ ) );

Das Muster wird dabei vom Match-Operator umgeben – und natürlich darf die i-Option nicht fehlen, denn die Groß-Kleinschreibung der tatsächlichen Datei kann von $teil durchaus verschieden sein.

Eins haben wir dabei jedoch nicht bedacht: grep findet in dieser Version auch dann Übereinstimmungen, wenn der Inhalt von $teil lediglich Bestandteil eines vorhandenen Datei- oder Verzeichnisnamens ist. Hier gilt es, das Muster zu präzisieren: Wir geben es inklusive Anfang (^) und Ende ($) an und speichern das Ergebnis in einem Hilfsarray:

@auswahl = grep ( /^$teil$/i , readdir( VERZ ) );

Enthält @auswahl nun nichts, also nicht mal ein nulltes Element, können wir keine korrigierte Fassung des Links erstellen und missbrauchen $korrDat für einen HTML-Kommentar, der sagt, dass $datei nicht auffindbar war. Weiter geht's dank last am Schleifenanfang mit einem eventuellen nächsten Element von @dateien:

if ( $#auswahl < 0 ){
   $korrDat = ("<!-- " . $datei . " nicht auffindbar! -->" );
   last;
 }

Mit komischen Sonderzeichenkombinationen, die für unfreiwilliges Gedächtnistraining sorgen, ist Perl reichlich gesegnet. Klaut man einem Array das @ und ersetzt es durch ein $#, erhält man ($) eine Skalarvariable, in der (#) die Anzahl der Array-Mitglieder gespeichert ist.

War die in @auswahl gespeicherte Ausbeute etwas zu erfolgreich (wir erinnern uns, verzeichnis und Verzeichnis können auf Unixsystemen problemlos nebeneinander existieren), setzen wir $korrDat auf einen Kommentar, der besagt, dass es mehrere Möglichkeiten gibt:

elsif ( $#auswahl > 0 ){
   $korrDat = ("<!-- " . $datei . " nicht eindeutig! -->" );
   last;
 }

Nur wenn wir genau eine Variante finden, können wir das nullte Element von @auswahl an $korrDat anhängen:

else {
   $korrDat .= $auswahl[0];
 }

Bleibt ein trailing slash anzuhängen, um $korrdat bereit für neue Unterverzeichnisebenen zu machen. Zu blöd – wenn $teil nun den Dateinamen enthielt, hat auch der einen Slash am Ende, obwohl es da nicht mehr weiter geht. Doch so weit, wie wir bislang mit unserem Skript gekommen sind – immerhin ist es nur ein Skript, um schnell ein paar Groß-Kleinschreibungsfehler auszubügeln – genehmigen wir uns einen üblen Hack: Wir ersetzen den Slash am Ende von $korrDat mit nichts. Und weil's so schön ist, nehmen wir dazu das Plus als Trennzeichen für den Substitute-Operator:

$korrDat =~ s+/$++;

Achja, jetzt hätten wir beinahe vergessen, die aus der Datei ausgelesene $zeile zu korrigieren, indem wir den alten Link $datei durch die korrigierte Ausgabe $korrDat ersetzen …

$zeile =~ s+$datei+$korrDat+;

… und zu guter Letzt natürlich auszugeben:

print $zeile;

Damit naht der große Augenblick: Ab ins Testverzeichnis und das Skript ohne weitere Parameter, aber vielleicht besser durch less "gepipet" auf die dortigen Dateien loslassen. Sieht gut aus? Dann nehmen wir noch schnell das Kommentarzeichen aus der Zeile

# $^I = ".bak";

heraus, und schon legt cgks die konvertierten Dateien unter ihren alten Namen ab, während die Ursprungsversion als Backupdatei mit der Endung .bak einen Vergleich ermöglicht.

#!/usr/bin/perl -w
 $^I = ".bak";
 @ARGV = <*.html>;
 $rootDir = "/home/pjung/LU/LU1001/answergirl";
 while ( $zeile = <> ){
   $_ = $zeile;
   @dateien = m/<A HREF=\"(.*?)\">/ig;
   foreach $datei ( @dateien ){
     $korrDat = "";
     if ( ! /(ftp|http):\/\//i ){
       if ( ! open( DATEI, $datei ) ){
         if ( $datei =~ s$^/$$ ){
           $praefix = $rootDir;
           $korrDat = "/";
         } else {
           $praefix = "./";
         }
         @teile = split( /\//, $datei );
         foreach $teil ( @teile ){
           if ( $teil eq "." || $teil eq ".." ){
             $korrDat .= $teil . "/" ;
           } else {
             opendir (VERZ, $praefix . $korrDat ) || last ;
             @auswahl = grep ( /^$teil$/i , readdir( VERZ ) );
             closedir( VERZ );
             if ( $#auswahl < 0 ){
               $korrDat = ("<!-- " . $datei . " nicht auffindbar! -->" );
               last;
             } elsif ( $#auswahl > 0 ){
               $korrDat = ("<!-- " . $datei . " nicht eindeutig! -->" );
               last;
             } else {
               $korrDat .= $auswahl[0];
             }
             $korrDat .= "/";
           }
         }
         $korrDat =~ s+/$++;
         $zeile =~ s+$datei+$korrDat+;
       }
       close DATEI;
     }
   }
   print $zeile;
 }