Einführung in Ruby On Rails

Architektur und KonzepteEinführung in Ruby On Rails

Frank Egger

Okt. 2007

Seite 2Einführung in Ruby On Rails – Architektur und Konzepte

Agenda

Basis-Sprache Ruby / Programmierparadigmen

Rails Architekturprinzipien und -eigenschaften

Spezialthemen

– „Scaffolding“, Generatoren, Plugins und Engines

– AJAX

– Email-Versand

– Webservices

– Datenbank-Management / -Migrationen

Testing

Entwicklungsumgebung


Dynamisch typisierte (Script-)Programmiersprache

Rein objektorientiert und voll funktional

Introspektion/Reflexion, „duck typing“

principle of least surprise (POLS)

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.

Die Sprache Ruby - Programmierparadigmen

class RubyClass < SuperClassinclude RubyModule

def method(param)@instvar = param

endend

obj = RubyClass.newobj.method("Ruby")


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


Basiswissen MVC-Paradigma

Model

ControllerView

Controller ändert den Zustand des Geschäftsmodells

Views werden über die Änderungen des Zustandes des Geschäftsmodells informiert

Views geben die Benutzerinteraktionen an den Controller weiter


MVC bei Rails

Model

Controller

View

Creates, Reads, Deletes, Modifies

Forwards

Request

Response

Client Web/App-Server

Redirects

Provides Data

Database

Helper


Controller steuern Ablauf(Routing anpassbar)

Controller verwalten Modell

Aufruf der Controller überKonvention und Introspektion

Jede Methode im Controller entspricht einer ausführbaren Action

View erhält Daten (für Vorbelegungen) über Instanzvariablen

Views werden über Konvention vom Controller angesprochen bzw. erzeugt

Controller

Rails Controller in Aktion

class TasksController < ApplicationController

def show@task = Task.find(params[:id])

end

end

show.rhtml

View


Rails Controller – Features und Merkmale

Zugriff auf Session, Cookies, Parameter über Hashs

Verhalten der Controller kann mit Hilfe von Filtern beeinflusst werden (z.B. für Autorisierung, Authentifizierung)

Seitenlayout kann über Controller oder Action gesteuert werden

class TasksController < ApplicationControllerinclude AuthenticatedSystem

before_filter :login_required

def accessuser = session[:user]cookie = cookies[:user_cookie]param = params[:id]

end

end

render(:action => "action", :layout => "layoutname")render(:layout => "layoutname")

Controller


Rails Model

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

class Task < ActiveRecord::Base

validates_presence_of :description

def printreturn "Die Aufgabe heißt #{description}."

endend

sModel


Rails Model – Assoziationen / Relationen

class Task < ActiveRecord::Base

belongs_to :user...

end

class User < ActiveRecord::Base

has_many :tasks...

end

s

s

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

Model

Model


Rails Views

Embedded Ruby (ERB) als Templating-Mechanismus

Datenzugriff über Instanzvariablen des Controllers

Inkludierung von Seitenteilen möglich (Partials)

Seitenweises blättern (Pagination)

Neben HTML als Ausgabeformat werden auch Javascript/RJS (AJAX), XML und Binärformate unterstützt

<%= link_to 'Next page', { :page => } if @task_pages.current.next %>

<% for @task in %><p class="taskdescription"><%= @task.description %></p>

<p class="accountable"><%= (@task.accountable == 1 ? "ja" : "nein") %></p> ...

class TasksController < ApplicationController

def list= paginate :tasks,

:per_page => 10end

end

@task_pages.current.next

@task_pages, @tasks

@tasks

View

ViewController


Rails Anwendungsrahmen

Jede Rails-Anwendung hat einen identisch aufgebauten Anwendungsrahmen

Über einen Generator wird der Anwendungsrahmenangelegt („rails <projektname>“)

Danach muss nur noch die Datenbankverbindung konfiguriert werden und die Enticklung kann starten


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


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!

<% form_remote_tag(:html => { :action =>url_for(:action => "create") },:url => { :action => :createAjax },:update => {:failure => "inputform" }, :loading => "Element.show('loading')",:loaded => "Element.hide('loading')" ) do %>

View


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

class UserNotifier < ActionMailer::Basedef signup_notification(user)

url = HOST_URL@recipients = "#{user.email}"@from = "[email protected]"@subject = "Please activate your new account"@sent_on = Time.now@body[:user] = user@body[:url] =

"#{url}/account/activate/#{user.activation_code}"end

end

Your account has been created.Username: <%= @user.login %>

Visit this url to activate your account:<%= @url %>

Model


Webservices mit Rails

Definition einer Webservice-API über ein von ActionWebserviceabgeleitetes 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

class TaskAPI < ActionWebService::API::Baseapi_method :new_task, :expects => [Task], :returns => [:bool]

end

class TaskController < ApplicationControllerweb_service_api TaskAPI

def new_task(task)return task.save

endend

Controller


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, Produktionclass CreateUsers < ActiveRecord::Migration

def self.upcreate_table "users", :force => true do |t|

t.column :login, :stringt.column :crypted_password, :string

endend

def self.downdrop_table "users"

endend


Testing bei Rails

Grundlage für Testing bilden Unit-Tests

Entwicklung und Ausführung vergleichbar mit Junit(setup, teardown...)

Sind aufgrund der dynamischen Typisierung sehr wichtig zur 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

def setupcreate_fine_working_time

end

def test_create_without_task@working_time.task = nil@working_time.task_id = nilresult = @working_time.saveassert !resulterrors = @working_time.errorsassert_not_nil errors[:task_id]assert includes_match?(errors[:task_id],

'Bitte eine Aufgabe auswählen!')end

Model-Tests


Testdatendefinition

Testdaten werden in „Fixtures“ definiert

Fixtures werden in yaml (vereinfachtes XML) formuliert

Jedes Fixture entspricht einem Datensatzin der Datenbank

Fixtures sollten sprechende Bezeichnungenbesitzen

Fixtures werden vor Ausführung von Testsautomatisch in die Datenbank geladen

Als Standard laufen Test-Methoden innerhalb einer Transaktion ab

Auch Beziehungen werden in den Testdaten abgebildet

<% today = Date.today %>worked_and_traveled:

id: 1date: <%= (today - 1).to_s :db %>hours_worked: 5minutes_worked: 30hours_traveled: 2minutes_traveled: 30comment: kunde ausgequetschttask_id: 1project_id: 4user_id: 1

fixtures :working_times

def setupcreate_fine_working_time

end

def test_create_without_taskworking_times(:worked_and_traveled)[...]

end

Fixture

Model-Tests


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)


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/

Technology

Einführung in Ruby On Rails