Durch und durch objektorientiert mit einfacher, reichhaltiger Syntax: Ruby stellt sich dem Programmierer nicht in den Weg. Ein praktisches Beispiel demonstriert die Möglichkeiten.

Die Web-Seite [1] von Ruby klassifiziert die Sprache als objektorientierte Skriptsprache. Mit diesen Merkmalen eignet sich die Sprache gut, um schnell das ein oder andere Helferlein für die tägliche Arbeit mit Linux zu schreiben. Dies demonstriert das hier beschriebene, kleine Skript: Es liest zwei Verzeichnisbäume ein, vergleicht diese miteinander und gibt die Unterschiede aus. Um die einzelnen Schritte nachzuvollziehen, benötigen Sie eine funktionierende Ruby-Umgebung. Diesen findet sich unter Debian oder Suse im Paket ruby.

Dieser Artikel beschreibt nicht Grundlagen des Programmierens. Hier hilft der Einführungsartikel im Schwerpunkt dieser Ausgabe weiter. Zu Ruby selbst gibt es exzellente, frei erhältliche Bücher ([2], [3], [4], [5]). Eine Dokumentation im HTML-Format enthalten etwa das Suse-Paket ruby-doc-html sowie die Debian-Archive ruby-manual und rubybook. Bei letzterem handelt es sich um das Buch “Programming Ruby” [3].

Für das schnelle Nachschlagen in der Ruby-Referenz eignet sich der Befehl ri. Er findet sich bei Suse in ruby-doc-ri, unter Debian im Paket ri. Die Referenz ist auch online verfügbar [6]. Auch eine Schnell-Referenz existiert als freies Dokument [7].

Abbildung 1: Das RubyGarden-Wiki ist eine Fundgrube zu Informationen rund um Ruby.

Für das einfache Ausprobieren empfiehlt sich die Installation von Interactive Ruby. Suse integriert das interaktive Ruby bereits im Paket ruby, bei Debian installieren Sie das Paket irb. Das Programm erlaubt es, interaktiv Befehle auszuprobieren. Mit der Eingabe von exit beendet sich das Testprogramm.

Verzeichnisbäume vergleichen

Das Beispiel in diesem Artikel implementiert einen einfachen Vergleich zweier Verzeichnisbäume (siehe Listing 1). Es nutzt die High-Level-Funktionen von Ruby und dessen Bibliotheken getreu dem Motto: Was andere schon programmiert haben, brauche ich nicht selbst zu machen.

Dabei verhält sich dirdiff.rb wie ein waschechter Shell-Befehl, wenn es mit chmod u+x dirdiff.rb das Ausführungs-Recht erhält. So vergleicht ./dirdiff.rb -i ~/.kde ~/backup/.kde das Verzeichnis ~/.kde mit dem Verzeichnis ~/backup.kde. Es zeigt an, welche Dateien in ersterem vorhanden sind, jedoch im Backup-Verzeichnis fehlen und umgekehrt. Aufgrund der Option -i ignoriert das Skript beim Sortieren die Groß- und Kleinschreibung der Pfadnamen.

Abbildung 2: Ein Durchlauf des Skriptes bringt es ans Tageslicht: Der Editor Kate kam beim Editieren des Ruby-Codes zum Einsatz.

Die erste Zeile des Skripts gibt an, welcher Interpreter zum Einsatz kommt. Der Befehl env findet ruby im Suchpfad. Das hilft, falls ruby nicht in /usr/bin/ruby installiert ist.

Abbildung 3: Gängige Editoren bieten Syntax-Highlighting und mehr für Ruby-Skripte.

In Zeile 3 bindet das Skript eine Klasse zum Auswerten von Befehlszeilen-Argumenten ein. Mit ri OptionParser erfahren Sie im Handumdrehen mehr über diese Klasse, für die es auch ein deutschsprachiges Tutorial [8] gibt.

Aufrufkonventionen

Im Anschluss definiert das Skript in den Zeilen 5 bis 39 zwei Funktionen, von denen später noch die Rede sein wird. Dann setzt es den Standardwert für die Option, ob es Groß- und Kleinschreibung beim Sortieren beachtet, auf false (Zeile 41). Es richtet den Optionen-Parser ein (Zeile 43), indem es die Methode new des neuen Objekts der Klasse OptionParser aufruft. Dazu wird der Methoden-Name durch einen Punkt getrennt an den Objekt-Namen angehängt.

Beim Aufruf einer Klassenmethode – ohne eine Instanz der Klasse, ein neues Objekt zu erstellen – ändert sich die Syntax: Nun trennen zwei Doppelpunkte den Methodennamen von der Klasse. So prüft File::exists?(".bashrc"), ob im aktuellen Verzeichnis eine Datei namens .bashrc existiert. Starten Sie irb, um das mal schnell auszuprobieren.

Die Tilde ~ als Synonym für den Namen des Home-Verzeichnisses versteht Ruby indes nicht. Sie wird beim Aufruf unseres Beispiels bereits von der Shell durch den entsprechenden Pfad ersetzt. Ruby selbst kann das auch: So ersetzt "~/.bashrc".gsub(/^~/, ENV['HOME']) das erste Vorkommen von ~ durch den Pfad zum Home-Verzeichnis. Bei Ruby ist also selbst eine Zeichenkette ein Objekt. Mit "~/.bashrc".class finden Sie heraus, welcher Klasse es angehört.

Das Skript verwendet einen Block, um das Einrichten zusammenzufassen und Schreibarbeit zu sparen. Die Klasse übergibt einen Verweis auf das neu eingerichtete Objekt an den Block, der mit do startet und mit end endet (Zeile 44 bis 53). Der Block übernimmt den Verweis als Variable o, die zwischen den beiden Pipe-Zeichen | angegeben ist. Warum das funktioniert, zeigt die Ausgabe von ri OptionParser::new:

OptionParser::new(banner = nil, width = 32, indent = ' ' * 4)
     {|self if block_given?| …}

Lesen Sie die Angaben in den geschweifeten Klammer laut, erkennen Sie ein schönes Feature von Ruby: Die Anweisungen erläutern fast umgangsprachlich, was passiert. Im Block setzt das Skript einen Banner, um den Einsatz des Befehls zu erklären (Zeile 45), sowie einen kurzen Erklärungstext, was der Befehl eigentlich macht (Zeile 47).

Es folgen die Option -i für das Ignorieren der Groß- und Kleinschreibung sowie die Option -h, die eine kurze Hilfe ausgibt und das Skript beendet. Was bei jeder Option geschieht, steht jeweils innerhalb eines weiteren Blocks. Alternativ verwenden Sie bei einem so kurzen Block die geschweiften Klammern { und } anstatt do und end.

Argumente auswerten

Damit ist der Parser eingerichtet, es beginnt das Auswerten der Argumente (Zeile 61). Hier kommt die Methode parse! zum Einsatz. Die auf der Kommandozeile angegebenen Argumente legt Ruby beim Start eines Skriptes von der Shell im Array ARGV ab. Ist dies nicht vorhanden, legt die Methode es an. Alternativ geben Sie ein eigenes Array an, zum Beispiel:

["-i", "~/.kde", "~/backup/.kde"]

Das Ausrufezeichen im Methoden-Namen teilt dem Objekt mit, vor dem Auswerten der Argumente alle Optionen zu entfernen. So erhalten wir nur noch die Namen der Verzeichnisse. Dokumentiert ist dies indes nur im Quelltext der Klasse, den Sie bei einer Standard-Installation von Ruby in der Datei /usr/lib/ruby/1.8/optparse.rb finden.

In Zeile 66 und 67 testet das Skript, ob beide Verzeichnisse angegeben sind. Dabei kommt eine Kurzschreibweise für die entsprechende Bedingung zum Einsatz: Statt if Ausdruck ... end testet es hier Ausdruck1 or Ausdruck2.

Wie das funktioniert, wird klar, wenn Sie die folgenden Ausdrücke in irb eingeben: false or "Hallo", nil or "Hallo", true or "Hallo", 42 or "Hallo", "Wiewahr" or "Hallo". Liefert der erste Ausdruck “wahr” zurück, verwendet Ruby diesen, ansonsten wertet es den zweiten Ausdruck aus.

Wahr (true) ist dabei für Ruby schlicht alles, was nicht false oder nil ist. Den Ausdruck nil verwendet Ruby dagegen für alles, was keinen Wert hat – so auch für einen fehlenden Eintrag im Array ARGV, wie etwa ein fehlendes Argument.

Fehler behandeln

Die Fehlerbehandlung beim Auswerten der Argumente erfolgt über Exceptions: Löst ein Befehl zwischen den Schlüsselworten begin und rescue eine Exception aus, dann ruft ruby den Block zwischen rescue und end auf. Eine Exception könnte von der Methode parse! kommen. Zudem löst das Skript mittels raise selbst eine Exception aus, wenn ihm ein Verzeichnis fehlt.

Die Exception landet in Zeile 68 in der Variable e. Das Skript gibt dann einfach nur die Meldung aus und beendet sich (Zeilen 69 und 70). Das Skript fängt hier jede Exception ab, selbst einen Syntaxfehler. Es ist aber auch möglich, nur einen bestimmten Fehlertyp abzufangen.

Funktionen

Nun geht es endlich daran, die beiden Verzeichnisse einzulesen (ab Zeile 75). Dazu dient die selbst definierte Funktion hole_verzeichnis ab Zeile 5, die das Skript für jedes Verzeichnis aufruft.

Das rekursive Einlesen eines Verzeichnisses ist in der Klasse Dir bereits fertig implementiert. Das Muster ** steht dabei für alle Unterverzeichnisse eines Verzeichnisses. Tippen in irb einfach Dir['/beliebiges/verzeichnis/**/*'] ein, um das auszuprobieren: Heraus kommt ein Array mit allen Einträgen.

Die Funktion macht daher nichts weiter, als in das angegebene Verzeichnis zu wechseln (Zeile 11), eine Liste aller Dateien und Verzeichnisse anzufordern (Zeile 14), wieder in das alte Verzeichnis zu springen, und die Liste mit den Dateien zurückzugeben (Zeile 20). Das Wechseln des Verzeichnisses ist dabei nötig, um relative Pfadnamen zu erhalten, die sich ohne weitere Vorkehrungen miteinander vergleichen lassen.

Die Funktion zeigt, das auch verschachtelte Strukturen das Behandeln der Fehler nicht behindern. Sie gibt einen entstandenen Fehler mittels raise ohne Argumente (Zeile 24) einfach an die aufrufende Ebene weiter, welche sie ab Zeile 78 entsprechend behandelt. Das Skript fängt diesmal nur den SystemCallError ab, bei Syntaxfehlern steigt Ruby an Ort und Stelle aus.

Sortieren und ausgeben

Bleibt nur noch, die Arrays mit den Listen der Verzeichnisse miteinander zu vergleichen. Nichts einfacher als das: Es genügt, das Quell-Array von dem Ziel-Array abzuziehen, um alle Einträge zu finden, die das Ziel-Array nicht enthält. Dies erledigt eine eigene Funktion ab Zeile 28. Diese sortiert das Ergebnis gleich noch. Dazu bietet die Klasse Array bereits eine passende Methode an, die Sie einfach aufrufen (Zeile 36).

Standardmäßig unterscheidet Ruby beim Sortieren zwischen Groß- und Kleinschreibung. Zeile 34 implementiert einen Vergleich ohne entsprechende Differenzierung. Dazu wandelt der Block {| a,b | a.downcase <=> b.downcase } alle Einträge vor dem Sortieren in Kleinbuchstaben um. Bei Bedarf lassen sich hier auch andere Kriterien angeben: So sortiert der Block { |a, b| File::mtime(a) <\<>=<\>> File::mtime(b) } die Ergebnisse nach dem Zeitpunkt der letzten Dateiänderung.

Am Ende ab Zeile 84 gibt das Skript das Ergebnis des Vergleichs aus. Dabei kommt eine Besonderheit von Ruby zum Einsatz: In jede Zeichenkette, die mit doppelten Anführungszeichen umgeben ist, lassen sich mit #{ und } beliebige Ausdrücke einbetten. Alternativ geben Sie bei printf die einzelnen Argumente durch Kommas getrennt an.

erweiterungsmöglichkeiten

Das kleine Beispiel enthält noch keine selbst geschriebene Klasse, da dies für ein Skript in dieser Größe noch nicht wirklich not tut. Ein häufiger Anwendungsfall beim Einlesen eines Verzeichnisses ist es, jeden Eintrag zu bearbeiten. Auch dies geht in Ruby sehr leicht:

Dir[' /*'].each { |eintrag|
        puts "Verarbeite Eintrag \"#{eintrag}\"."
}

Möchten Sie dazu Shell-Befehle aufrufen? Dann schauen Sie sich mal die Methode Kernel#system an oder probieren Sie die Backticks aus: puts `free`.

#!/usr/bin/env ruby
# Parser für Shell-Argumente einbinden
require 'optparse'
# Holt ein Verzeichnislisting
def hole_verzeichnis(verz)
    begin
            altesverz = Dir.pwd
            # Verzeichniswechsel, um Verzeichnis ausgehende, relative Pfade zu erhalten
            Dir.chdir(verz)
            # Verzeichnis rekursiv auflisten
            liste=Dir[' /*']
            # Zu altem Verzeichnis zurückwechseln
            Dir.chdir(altesverz)
            # Liste zurückgeben
            return liste
    # Fehler bei der System-Funktion?
    rescue SystemCallError
            # Fehler, so wie er ist, weitergeben
            raise
    end
end
# Vergleicht zwei Listen
# grosskleinegal:
# false = Groß- / Kleinschreibung wird beachtet
# true = Groß- / Kleinschreibung wird nicht beachtet
def vergleiche(liste1, liste2, grosskleinegal)
    if grosskleinegal==true
            return (liste1 - liste2).sort {| a,b | a.downcase <=> b.downcase }
    else
            return (liste1 - liste2).sort
    end
end
# Standardwerte
grosskleinegal=false
# Parser für Optionen einrichten
opts = OptionParser.new do |o|
    o.banner = "Benutzung: dirdiff.rb [optionen] verzeichnis1 verzeichnis2"
    o.separator( "Vergleicht zwei Verzeichnisbäume miteinander." )
    o.separator( "" )
    # Optionen
    o.on("-i", "--ignore-case", "Groß-/Kleinschreibung ignorieren.") do
            grosskleinegal=true
    end
    o.on("-h", "--help", "Hilfe." ) do
            puts o
            exit
    end
end
# Übergebene Argumente auswerten
begin
    opts.parse!( ARGV )
    # Verzeichnisse angegeben?
    verz1 = ARGV[0] or raise( "Verzeichnis 1 fehlt." )
    verz2 = ARGV[1] or raise( "Verzeichnis 2 fehlt." )
rescue => e
    STDERR.puts "Fehler: #{e.message}"
    STDERR.puts opts.to_s
    exit 1
end
# Verzeichnisse einlesen…
begin
    liste1 = hole_verzeichnis(verz1)
    liste2 = hole_verzeichnis(verz2)
rescue SystemCallError => e
    STDERR.puts "Fehler: #{e.message}"
    exit
end
# … und vergleichen
printf "\nDateien, die in #{verz1} jedoch nicht in #{verz2} existieren:\n"
puts vergleiche(liste1, liste2, grosskleinegal)
printf "\nDateien, die in #{verz2} jedoch nicht in #{verz1} existieren:\n"
puts vergleiche(liste2, liste1, grosskleinegal)