Ruby on Rails ist ein Framework für die Entwicklung von datenbankbasierten Webanwendungen in der Sprache Ruby. Rails basiert auf einer MVC-Architektur und bietet Unterstützung für den Versand von E-Mails, die Anbindung an Web Services, AJAX und mehr. Webanwendungen auf Basis von Rails kommen im Vergleich zu anderen mit wenig Code und ohne umfangreiche Konfiguration aus. Die einfache Testbarkeit der Anwendungen wurde von vornherein berücksichtigt, wodurch deren Wartbarkeit und Langlebigkeit gefördert wird. Den Großteil seiner Fähigkeiten verdankt Rails der Sprache Ruby (siehe Kasten „Ruby“), die auch unabhängig von Rails und der Webentwicklung einen tieferen Blick wert ist. (Eine Einführung findet sich hier.) Insgesamt befreit Rails den Entwickler von technischen Details und stärkt die Konzentration auf das Wesentliche, nämlich die Umsetzung der Geschäftslogik, und führt damit zu einer Steigerung der Produktivität.

Ruby on Rails basiert auf einer MVC-Architektur und bietet für jede Komponente ein Sub-Framework. Genau genommen ist Rails selbst ein Meta-Framework, quasi die Klammer um eine Reihe von einzelnen Frameworks, die auch unabhängig voneinander genutzt werden können. Persistierbare Geschäftsobjekte werden in Rails als Modelle bezeichnet und mithilfe des Frameworks Active Record entwickelt. Dieses stellt die Verbindung zwischen Datenbank und Geschäftsobjekten her. Ein Modell wird durch eine Ruby-Klasse repräsentiert, die von der Framework-Klasse ActionRecord::Base erbt (Listing 1).

Listing 1
---------------------------------------------------
# RAILS_ROOT/app/models/book.rb
class Book  "Wirdemann, Baustert"

Die Modelle entsprechen dadurch dem Active-Record-Muster, d.h. ein Modell ist immer mit genau einer Datenbanktabelle verbunden und eine Instanz der Modellklasse somit mit genau einer Spalte in der Tabelle. Die Zuordnung zwischen Modell und Datenbanktabelle erfolgt dabei ohne Konfiguration über eine Konvention. Der Tabellenname (zum Beispiel books) ist immer der pluralisierte Name des Modells (z.B. Book). Dazu führt das Framework intern ein Dictionary, das auch um deutsche Namen erweitert werden kann. Ein erstes Beispiel für eines der grundlegenden Prinzipien von Rails, nämlich „Konvention über Konfiguration“. Über die Verbindung zur Tabelle hat das Framework Zugriff auf die Attribute und stellt hierfür automatisch Getter- und Setter-Methoden im Modell zur Verfügung (Listing 1). Ein Beispiel für ein weiteres Prinzip von Rails, nämlich DRY („Don’t repeat yourself“).

Assoziationen zwischen Modellen werden einfach und aussagekräftig durch Klassenmethoden, wie z.B. has_many oder belongs_to ausgedrückt. Das Listing 2 zeigt z.B. die Modelle Book und Chapter, die ein Buch und ein enthaltenes Kapitel repräsentieren. (In Ruby können Klammern weggelassen werden und für Strings werden häufig so genannte Symbole verwendet. Die Angabe von has_many in Listing 2 ist eine für Ruby typische Schreibweise für has_many(„chapters“)). Neben einem entsprechenden Fremdschlüssel in der Datenbanktabelle (z.B. book_id in chapters) reicht dies Rails, um die Verbindung von Modellen zu kennen und auch hier automatisch entsprechende Zugriffsmethoden für Instanzen zur Verfügung zu stellen (Listing 2).

Listing 2
---------------------------------------------------------
# RAILS_ROOT/app/models/book.rb
class Book 

Über Active Record stehen jedem Modell außerdem bereits eine Reihe von Methoden für den Zugriff auf die Attribute der Tabelle zur Verfügung. Listing 3 zeigt z.B. dem Einsatz der find-Methode.

Listing 3
------------------------------------------------------------
# Buch erzeugen und speichern
b = Book.new(:title => "Rapid Web Development")
b.save

# Buch laden
book  = Book.find(:first)
books = Book.find(:all, conditions => ["title like '%?%'", "Web"])
books = Book.find_by_sql("select title from . ")
.