1. Einführung in Ruby On Rails
Architektur und Konzepte
Frank Egger
Okt. 2007

2. Agenda
Basis-Sprache Ruby / Programmierparadigmen
Rails Architekturprinzipien und -eigenschaften
Spezialthemen
– „Scaffolding“, Generatoren, Plugins und Engines
– AJAX
– Email-Versand
– Webservices
– Datenbank-Management / -Migrationen
Testing
Entwicklungsumgebung
Seite 2
Einführung in Ruby On Rails – Architektur und Konzepte

3. Die Sprache Ruby - Programmierparadigmen
Dynamisch typisierte (Script-)Programmiersprache
Rein objektorientiert und voll funktional class RubyClass < SuperClass
include RubyModule
Introspektion/Reflexion, „duck typing“ def method(param)
@instvar = param
end
principle of least surprise (POLS) end
obj = RubyClass.new
obj.method(quot;Rubyquot;)
Erscheinungsjahr ca. 1995
Einflüsse von Perl, Python, Smalltalk, LISP, u.a.
Initiator: Yukihiro Matsumoto („Matz“), mittlerweile Open Source
Garbage Collection, Exceptions, reguläre Ausdrücke, Erweiterung von
Klassen, Code-Blöcke, RubyGems (Paketmanager), Rdoc (vgl. Javadoc),
usw.
Seite 3
Einführung in Ruby On Rails – Architektur und Konzepte

4. Rails Architekturprinzipien und -merkmale
MVC Paradigma als Schichtenarchitektur
Konventionen über Konfigurationen
„DRY“-Prinzip („Don‘t Repeat Yourself“)
Plugin-fähige Architektur zur einfachen Erweiterung
von Anwendungen durch Standardkomponenten
Eingebaute bzw. ergänzbare Einweg-Generatoren
Identischer Anwendungsrahmen
(Verzeichnisse, Struktur)
Integrierte AJAX-Unterstützung
Hohe Testbarkeit
Seite 4
Einführung in Ruby On Rails – Architektur und Konzepte

5. Basiswissen MVC-Paradigma
Model
Views werden über die Controller ändert den
Änderungen des Zustandes Zustand des
des Geschäftsmodells Geschäftsmodells
informiert
View Controller
Views geben die
Benutzerinteraktionen an
den Controller weiter
Seite 5
Einführung in Ruby On Rails – Architektur und Konzepte

6. MVC bei Rails
Controller
Request
Creates, Reads,
Deletes, Modifies
Redirects
Forwards
Model
Response
Provides Data
View
Helper
Client Web/App- Database
Server
Seite 6
Einführung in Ruby On Rails – Architektur und Konzepte

7. Rails Controller in Aktion
Controller steuern Ablauf
(Routing anpassbar)
Controller
Controller verwalten Modell class TasksController < ApplicationController
def show
Aufruf der Controller über @task = Task.find(params[:id])
end
Konvention und Introspektion
end
Jede Methode im Controller
entspricht einer ausführbaren Action View
View erhält Daten (für Vorbelegungen) über show.rhtml
Instanzvariablen
Views werden über Konvention vom Controller
angesprochen bzw. erzeugt
Seite 7
Einführung in Ruby On Rails – Architektur und Konzepte

8. Rails Controller – Features und Merkmale
Controller
Zugriff auf Session, Cookies, Parameter class TasksController < ApplicationController
über Hashs include AuthenticatedSystem
before_filter :login_required
Verhalten der Controller kann mit Hilfe def access
von Filtern beeinflusst werden (z.B. für user = session[:user]
cookie = cookies[:user_cookie]
Autorisierung, Authentifizierung) param = params[:id]
end
Seitenlayout kann über Controller oder end
Action gesteuert werden
render(:action => quot;actionquot;, :layout => quot;layoutnamequot;)
render(:layout => quot;layoutnamequot;)
Seite 8
Einführung in Ruby On Rails – Architektur und Konzepte

9. Rails Model
Model
s
class Task < ActiveRecord::Base
validates_presence_of :description
def print
return quot;Die Aufgabe heißt #{description}.quot;
end
end
Validierungen werden im Model definiert
Durch Ableitung von ActiveRecord werden automatisch getter/setter für
Attribute erzeugt
DRY-Prinzip: Definition der Attribute nur in der Datenbank
Konvention: Tabellennamen immer Plural vom Modellnamen (Legacy-
Schemata werden auch unterstützt)
Vererbung (Single Table Inheritance) ist möglich
Seite 9
Einführung in Ruby On Rails – Architektur und Konzepte

10. Rails Model – Assoziationen / Relationen
Model s
class Task < ActiveRecord::Base
belongs_to :user
...
end
Model
class User < ActiveRecord::Base
has_many :tasks s
...
end
Relationen textuell beschreiben:
– 1:1 -> has_one / belongs_to
– 1:n -> has_many / belongs_to
– n:m -> has_and_belongs_to_many / has_and_belongs_to_many
Foreign Keys werden über Konvention benannt: „relationierte Entität“_id
Seite 10
Einführung in Ruby On Rails – Architektur und Konzepte

11. Rails Views
Embedded Ruby (ERB) als Templating-Mechanismus
Datenzugriff über Instanzvariablen des Controllers
Inkludierung von Seitenteilen möglich (Partials)
Seitenweises blättern (Pagination)
View
<%= link_to 'Next page', { :page => @task_pages.current.next } if @task_pages.current.next %>
Neben HTML als Ausgabeformat werden auch Javascript/RJS (AJAX), XML
und Binärformate unterstützt
Controller View
<% for @task in @tasks %>
class TasksController < ApplicationController
<p class=quot;taskdescriptionquot;>
def list <%= @task.description %>
@task_pages, @tasks = paginate :tasks, </p>
:per_page => 10
end <p class=quot;accountablequot;>
<%= (@task.accountable == 1 ? quot;jaquot; : quot;neinquot;) %>
end </p> ...
Seite 11
Einführung in Ruby On Rails – Architektur und Konzepte

12. Rails Anwendungsrahmen
Jede Rails-Anwendung hat einen identisch aufgebauten
Anwendungsrahmen
Über einen Generator wird der Anwendungsrahmen
angelegt („rails <projektname>“)
Danach muss nur noch die
Datenbankverbindung
konfiguriert werden und die
Enticklung kann starten
Seite 12
Einführung in Ruby On Rails – Architektur und Konzepte

13. Scaffolding und Generatoren
Scaffolding (Gerüstbau)
– schnelle Abbildung von z. B. CRUD-Methoden auf allen
Architekturebenen (Modell/Controller/View) „on the fly“
– Einmalgenerierung von Sourcecode für CRUD-Methoden
Generatoren
– Bieten Unterstüzung bei der Erstellung von Architekturelementen
(Models, Controllers, Views, Helpers)
– Können komplexe Umgebungen bereitstellen (z.B. Autorisierung / Login)
– Können Artefakte auch wieder löschen (Verlust von manuell
hinzugefügtem Sourcecode möglich!)
– Sind erweiterbar und können als Plugins in Projekten eingebunden
werden
Seite 13
Einführung in Ruby On Rails – Architektur und Konzepte

14. Rails und
Scriptaculous u. Prototype sind in Rails per Default integriert
RJS (Rails Javascript) vereinfacht die Umsetzung von AJAX-Elementen
ABER: Keine aufwändigen AJAX-Anwendungen ohne fundiertes Javascript-
Know How
Rails ermöglicht die automatische Erkennung von Javascript
– AJAX-Formulare werden bei fehlender Javascript-Unterstützung des
Clients in „normale“ Formulare gewandelt
– ABER: Controller muss beide Varianten beherrschen!
View
<% form_remote_tag(:html => { :action =>
url_for(:action => quot;createquot;) },
:url => { :action => :createAjax },
:update => {:failure => quot;inputformquot; },
:loading => quot;Element.show('loading')quot;,
:loaded => quot;Element.hide('loading')quot; ) do %>
Seite 14
Einführung in Ruby On Rails – Architektur und Konzepte

15. Email-Versand / (-Empfang) bei Rails
Email-Versand über ActionMailer-Model
Aufruf der Model-Methoden zum Versand mit „deliver_Methodenname“
Email-Inhalt als View-Template
Multipart-Email möglich
Mailversand über integrierten „Dummy“-Mailserver testbar
Model
class UserNotifier < ActionMailer::Base
def signup_notification(user)
url = HOST_URL
@recipients = quot;#{user.email}quot;
@from = quot;f.egger@dpcom.dequot;
@subject = quot;Please activate your new accountquot;
@sent_on = Time.now
Your account has been created. @body[:user] = user
Username: <%= @user.login %> @body[:url] =
Visit this url to activate your account: quot;#{url}/account/activate/#{user.activation_code}quot;
end
<%= @url %>
end
Seite 15
Einführung in Ruby On Rails – Architektur und Konzepte

16. Webservices mit Rails
Definition einer Webservice-API über ein von ActionWebservice
abgeleitetes Interface
Abbilden der API auf einen / mehrere Controller mit einem / mehreren
Endpoint/s (direct, delegated, layered)
Einfache und komplexe Parameter-Typen werden unterstützt (z. B. string,
Model Elemente, arrays, hashs...)
Unterstützung für WSDLs mit soap4r
Controller
class TaskAPI < ActionWebService::API::Base
api_method :new_task, :expects => [Task], :returns => [:bool]
end
class TaskController < ApplicationController
web_service_api TaskAPI
def new_task(task)
return task.save
end
end
Seite 16
Einführung in Ruby On Rails – Architektur und Konzepte

17. Datenbank-Management / -Migrationen
Repräsentation des Schemas in Datenbank-unabhängiger Sprache (Ruby)
Migrationsscripte enthalten einzelne Updates für Änderungen am Schema
oder den Daten
Das Schema wird in der Datenbank versioniert
Rails kann mit Hilfe der Version automatisch Up-/Down-Migrationen der
Datenbank vornehmen
Es existieren per Default drei Datenbanken: Entwicklung, Test, Produktion
class CreateUsers < ActiveRecord::Migration
def self.up
create_table quot;usersquot;, :force => true do |t|
t.column :login, :string
t.column :crypted_password, :string
end
end
def self.down
drop_table quot;usersquot;
end
end
Seite 17
Einführung in Ruby On Rails – Architektur und Konzepte

18. Testing bei Rails
def setup
create_fine_working_time
Grundlage für Testing bilden end
Unit-Tests def test_create_without_task
@working_time.task = nil
@working_time.task_id = nil
Entwicklung und Ausführung result = @working_time.save
vergleichbar mit Junit assert !result
errors = @working_time.errors
(setup, teardown...) assert_not_nil errors[:task_id]
assert includes_match?(errors[:task_id],
'Bitte eine Aufgabe auswählen!')
Sind aufgrund der dynamischen end
Typisierung sehr wichtig zur Model-Tests
Sicherung der Funktionalität bei Refactorings
Unterteilung der Tests in Unit-Tests (Model) und Functional-Tests
(Controller / View)
Bei Functional-Tests werden Requests und Responds gemockt
(vergleichbar mit HttpUnit + integriertem Webserver)
E-Mail- und Webservice-Infrastrukturen können gemockt werden
Seite 18
Einführung in Ruby On Rails – Architektur und Konzepte

19. Testdatendefinition
Testdaten werden in „Fixtures“ definiert Fixture
<% today = Date.today %>
worked_and_traveled:
Fixtures werden in yaml (vereinfachtes id: 1
date: <%= (today - 1).to_s :db %>
XML) formuliert hours_worked: 5
minutes_worked: 30
hours_traveled: 2
Jedes Fixture entspricht einem Datensatz minutes_traveled: 30
in der Datenbank comment: kunde ausgequetscht
task_id: 1
project_id: 4
Fixtures sollten sprechende Bezeichnungen user_id: 1
besitzen fixtures :working_times
def setup
Fixtures werden vor Ausführung von Tests create_fine_working_time
end
automatisch in die Datenbank geladen
def test_create_without_task
working_times(:worked_and_traveled)
Als Standard laufen Test-Methoden [...]
innerhalb einer Transaktion ab end
Model-Tests
Auch Beziehungen werden in den Testdaten abgebildet
Seite 19
Einführung in Ruby On Rails – Architektur und Konzepte

20. Rails Entwicklungsumgebung
Aptana Rails / RadRails (basiert auf Eclipse)
– Syntax Highlighting
– Code Completion
(etwas buggy!)
– Unit-Testing
– Webserver (WEBrick,
LightTPD, Mongrel)
– Generatoren
– Rake Tasks
– Rails Plugins
– RI (API Doku)
Seite 20
Einführung in Ruby On Rails – Architektur und Konzepte

21. Quellen
http://www.rubyonrails.org/
http://www.rubyonrails.de/
http://www.rubyonrailsblog.com/
http://www.ruby-lang.org/de/
http://prototypejs.org/api
http://www.sitepoint.com/article/learn-ruby-on-rails/
http://home.vr-web.de/juergen.katins/ruby/buch/
Seite 21
Einführung in Ruby On Rails – Architektur und Konzepte