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.

Modelle

1. Listing 1
2. ---------------------------------------------------
3. # RAILS_ROOT/app/models/book.rb
4. class Book < ActiveRecord::Base
5. end
7. book.title= ”Rapid Web Development”
8. book.author # => ”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).

1. Listing 2
2. ---------------------------------------------------------
3. # RAILS_ROOT/app/models/book.rb
4. class Book < ActiveRecord::Base
5. has_many :chapters # ein Buch hat viele Kapitel
6. …
7. end
9. class Chapter < ActiveRecord::Base
10. belongs_to :book # ein Kapitel gehört zu einem Buch
11. …
12. end
14. # automatisch bereitgestellte Methoden
15. title = book.chapters.first.title
16. author = chapter.book.author

Ü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.

1. Listing 3
2. ------------------------------------------------------------
3. # Buch erzeugen und speichern
4. b = Book.new(:title => ”Rapid Web Development”)
5. b.save
7. # Buch laden
8. book = Book.find(:first)
9. books = Book.find(:all, conditions => [”title like ‘%?%’”, ”Web”])
10. books = Book.find_by_sql(”select title from … ”)
11. …