Erste Schritte mit Ruby on Rails 3.0

Hallo an alle Web-Entwickler unter uns! ;-) Jeder von euch kennt PHP, viele kennen auch Smarty oder sogar das eine oder das andere PHP Framework (CakePHP, CodeIgniter und viele viele andere).

Auch ich habe irgendwann mit PHP angefangen und erfolgreich mehrere größere und kleinere Websites damit programmiert. Doch dann — etwa vor drei Jahren — habe ich für mich RoR entdeckt. RoR ist der Kurzname des erfolgreichen Frameworks Ruby on Rails. Es wurde von dem erfolgreichen Programmierer und Geschäftsmann David Hansson entwickelt und 2004 an die Community als OpenSource abgegeben.

Die Geschichte von Ruby on Rails ist voll von Erfolgen und Misserfolgen, aber sie ist nicht der Punkt dieses Beitrags. Vielmehr möchte ich euch die neuste Version des Frameworks vorstellen und die Hintergründe zu Ruby on Rails könnt ihr dem Wikipedia-Artikel  entnehmen.

Gleich vorab: es existiert eine ziemlich gute Dokumentation, die alle Rails Anfänger einmal durchlesen sollten. Aber es gibt einige Dinge, die man so in den Manuals nicht findet, die aber trotzdem wichtig sind. Auf diese Probleme möchte ich in meinen Beiträgen über Ruby on Rails eingehen.
Bei meinen Projekten in der Vergangenheit habe ich in der letzten Zeit die Rails-Version 2.3.2 benutzt. Nun ist RoR 3.0 raus und ich wollte es ausprobieren. Alle meine Tests habe ich auf dem Betriebssystem Windows XP SP2 durchgeführt, aber es sollte auch problemlos mit Windows 7 und Vista funktionieren.

Womit anfangen?
Erstmals sollte man Ruby Installer herunterladen und die Installation durchführen. Ich habe die Vorgehensweise bereits in meinem älteren Beitrag beschrieben. Achtung: am besten sollte man gleich die PATH Variable setzten, so wie es auch vom Installer empfohlen wird.

Nun startet man die Kommandozeile mit Ruby ("Start Command Prompt with Ruby" im Startmenü) und installiert Rails mit einem einfachen Befehl:

gem install rails

Für Tests eignet sich  eigentlich auch eine simple SQLite3-Datenbank. So erspart man sich die Quälerei mit MySQL unter Windows ;)
Damit alles reibungslos abläuft sollte man 2 ZIP-Dateien (hier  und hier) herunterladen und in den Ordner mit RoR 3 Installation entpacken.

Jetzt installiert man Sqlite3-Bibliothek für Ruby:

gem install sqlite3-ruby

Die Vorbereitungen sind abgeschlossen und wir können unsere erste Rails-Applikation erstellen:

rails new hello_world

Fertig. Jetzt wechseln wir in das neu erstellte Verzeichnis mit der Anwendung:

cd hello_world

Das tolle an Rails ist, dass man in eigenen Projekten viele fertige Plugins und Bibliotheken (Gems) ganz leicht einbinden kann. Um die Gems, die in einem Projekt zum Einsatz kommen zu konfigurieren, gibt es bei Ruby on Rails 3.0 das Tool Bundler. Da wir keine weiteren Gems verwenden wollen, geben wir ein:

bundle install

SQLite3 Unterstützung ist bei Rails von Haus aus dabei. Diese DB eignet sich hervorragend für Entwicklung und Tests, aber nicht für den Produktiveinsatz. Zwar wird SQLite3 standardmäßig verwendet, man kann aber es leicht durch andere DB (z.B. durch MySQL oder PostgreSQL) ersetzen.
So sieht die Standardkonfiguration für Development-Umgebung aus (config/database.yml):

development:
 adapter: sqlite3
 database: db/development.sqlite3   
 pool: 5
 timeout: 5000

Jetzt erstellen wir eine neue leere Datenbank mit einem rake Befehl:

rake db:create

Damit wird in dem Verzeichnisdb/ zwei neue Datenbanken erstellt, development und test.
Eigentlich ist unsere erste Rails-Anwendung bereits lauffähig. Um es zu testen startet man einen Webserver mit dem Befehl:

rails server

...und öffnet im Browser die Adresse localhost:3000/

Die "Welcome Aboard" Seite zeigt, dass unsere Rails Applikation tatsächlich funktioniert und richtig konfiguriert ist. Man kann auf den Link "About your application's environment" klicken um die Informationen zur Umgebung und Einstellungen einzusehen.

Für ein einfaches "Hello World!" benötigen wir mindestens einen Controller (verarbeitet Anfragen) und ein View (stellt die im Controller verarbeitete Daten dar). Nichts leichter als das:

rails generate controller home index

Mit diesem Befehl werden gleich mehrere Dateien erstellt. Einschließlich app/views/home/index.html.erb. Dieses View ist für die Ausgabe von Daten, die in der index-Methode des home-Controllers generiert wurden. Wir können die index.html.erb Datei nun öffnen und deren Inhalt mit der folgenden Zeile ersetzen:

<h1>Hello World!</h1>

Noch sind wir nicht fertig. Zwar haben wir bestimmt WAS wir ausgeben müssen, aber wir müssen noch bestimmen WANN wir unser "Hello World" ausgeben. In unserem Fall sollte die Seite als Indexseite unserer kleinen Website erscheinen (dort wo jetzt noch "Welcome Aboard" zu sehen ist).
Als erstes müssen wir die Standardseite entfernen:

cd public
del index.html

Nun müssen wir in der Datei config/routes.rb angeben, wo unsere index-Seite zu sehen sein wird. In dieser Datei werden alle Routing-Regeln (Pfade) konfiguriert. Es gibt in der Datei bereits einige Beispiele und eins davon zeigt, wie man die Indexseite einstellen kann — das ist die Zeile mit root :to, die auskommentiert und wie folgt geändert werden muss:

Blog::Application.routes.draw do
 #...    
 # You can have the root of your site routed with "root" 
 # just remember to delete public/index.html.
  root :to => "home#index"

root :to => "home#index" gibt an, dass unsere Indexseite der index-Methode aus dem home-Controller entsprechen soll.

Wenn wir jetztlocalhost:3000 öffnen, ist unsere Überschrift "Hello World!" zu sehen.

Rails besitzt eine schnelle Möglichkeit einfaches Seiten-Gerüst (Scaffold) zu generieren. Es ist sehr Hilfreich, wenn man auf die Schnelle etwas ausprobieren möchte oder als Ausgangspunkt für eine echte Web-Anwendung.
In unserem Beispiel erstellen wir ein einfaches Blog. Mit Hilfe des Scaffolding erstellen wir das Modell Post, mit dem wir unsere Beiträge speichern und verwalten werden. Die zugehörigen (fast fertigen) Controller und Views werden mitgeneriert.

rails generate scaffold Post name:string title:string content:text

Mit diesem Befehl werden viele neue Dateien erstellt, unter anderem auch eine Datei für die Migration von Daten in unsere Datenbank. Mit einer Migration wird bei Rails Operationen an der Datenbank bezeichnet (Erstellen und Löschen von Tabellen, Hinzufügen von Indexen). Um die Migration für die neue Tabelle Posts auszuführen, verwenden wir den Befehl rake.
Aber zuerst öffnen wir die Migration db/migrate/20101018102235_create_posts.rb (Achtung: der Dateiname ist wahrscheinlich etwas anders!):

class CreatePosts < ActiveRecord::Migration
 def self.up
  create_table :posts do |t|
   t.string :name
   t.string :title
   t.text :content
   t.timestamps
  end
 end
 
 def self.down
  drop_table :posts
 end
end

Wie wir sehen können erstellt diese Migration eine neue Tabelle posts (Methode up). Die Migration löscht die Tabelle (Methode down), wenn man die Änderungen rückgängig machen möchte. Die Tabelle posts hat zwei Felder von Typ string, ein Content-Feld und außerdem Felder für created_at (Erstellungsdatum) und updated_at (Änderungsdatum) Attribute.
Jetzt führen wir die Migration aus:

rake db:migrate

Rails erstellt unsere Tabelle Posts.
Wir möchten auf unserer Indexseite auf unsere Blog-Beiträge verlinken. Hierzu öffnen wir wieder app/views/home/index.html.erb und ändern es wie folgt:

<h1>Hello, Rails!</h1>
<%= link_to "My Blog", posts_path %>

Die Methode link_to ist eine von vielen nützlichen Hilfsmethoden (helper) in Rails. In unserem Beispiel erstellt sie einen Link mit dem Linktext "My Blog" und der Adresse, die anhand von Routing-Regeln generiert wird.
Schnell unter localhost:3000 überprüfen, ob alles funktioniert.

Noch gibt es keine Beiträge im Blog, aber zu sehen ist ein Link "New Post". Dort kann kann man Beiträge erstellen und sie nachher bearbeiten oder löschen.

So, das war's schon! Viel Spaß mit Ruby on Rails und bis zum nächsten Mal!