W eb development that doesn`t hurt

13.02.-15.02.2008 Campus Gummersbach
“Web development that doesn’t hurt”
ASS Training
Ruby on Rails
Andreas Bade
Dirk Breuer
self.inspect
?
self.inspect
• Wichtige theoretische Grundlagen
• Lernen durch Eigenleistung
Ruby on Rails und Webentwicklung
• Sehr praxisbezogener Einstieg in Ruby,
self.inspect
umgehen (Sessions/Cookies)
• Mit der Stateless-Problematik von HTTP
Entwicklung
• Konzepte und Praxis testgetriebener
Applikationen
• Erstellen von Ruby Code
• Selbstständiges Erstellen von Rails
def training; end
gegenüber anderen Technologien?
• Beantwortung der Fragen:
• Was ist Ruby?
• Was ist Rails?
• Was sind sie Vorteile / Nachteile
def training; end
• Im Wechsel Vortrag/Demos und Hands-On
• Mittagspause
• kleinere Pausen zwischendurch
Organisation
Text Editor
TextMate
Datenbank
SQLite3
Kommandozeile
iTerm
Browser
Firefox
Tools
export http_proxy=wwwproxygm.fh-koeln.de:8080
export PATH=/usr/local/bin:$PATH
Setup
•
•
•
•
•
•
•
Tag 1
Tag 2
Tag 3
User Login
Test-First Development
View und Controller (ActionPack)
ActiveRecord::Associations
Das M in MVC (ActiveRecord)
Beginn der Applikation (Rails)
Warm-Up & Grundlagen (Ruby)
3.days do
Get on the Track
Day One
• Dynamische OO-Programmiersprache
• Interpretersprache
• Fokus auf Simplicity und Productivity
• Ruby is fun!
Ruby.new
Keine “primitiven”
Datentypen
dynamische Typisierung
Alles sind Objekte!
{‘name’ => ‘Programming Ruby’,
‘author’ => ‘Dave Thomas’}.class
[‘Andi’, ‘Dirk’].class # Array
“Hello World”.class # String
42.class # Fixnum
Objektorientieung
• initialize Methode
Keywords
• class und module
training = Training.
def my_method
# ... do somethin
end
end
class Training
def initialize
# Constructor
end
Objekte definieren
• Klassenvariablen (@@class_var)
• Instanzvariablen (@instance_var)
• lokale Variablen (locale_var)
• Konstanten (CONSTANT)
Variablen
• Andere Repräsentation einer Zeichenkette
• Spart Speicherplatz
• Schreibweise: :andi
abgelegt und bei Gebrauch instanziiert
• Symbole werden einmal in Speicher
Symbole
•
Bei der Symbol Klasse
die selbe Zeichenkette
nur einmal.
wird die selbe
Zeichenkette zweimal im
Speicher abgelegt.
• Bei der String Klasse
"ruby".object_id
3256020
"ruby".object_id
3253400
:ruby.object_id
166018
:ruby.object_id
166018
>>
=>
>>
=>
>>
=>
>>
=>
Symbole
dennoch weitere
Eigenschaften zu
inkludieren
• Einfach Vererbung
• Aber: Mixins erlauben
class Training
include Launch
end
class Training << ASS
end
Vererbung
• while
• until
• for
for i in 0...10 do
puts i
end
until k < 42
# do something
end
file = File.open(‘test.txt
while line = file.gets
# do something
end
Schleifen
name == “Bob” ? puts “Hello Bob” : puts “Who a
case name
when “Bob”
puts “Hello Bob”
else
puts “Who are you”
end
Ternäre Ausdrücke
case Anweisung
if und unless
Ausdrücke
if name == “Bob”
puts “Hello Bob”
else
puts “Who are you”
end
Bedingungen
•
•
•
An den Code im Block können
auch Objekte übergeben
werden und lokale Variablen
innerhalb des Blocks gelten nicht
außerhalb.
Der Code im Block ist wie eine
Methode nur ohne an ein Objekt
gebunden zu sein.
Ein Proc-Objekt verpackt einen
Block Code und kann diesen zu
einem späteren Zeitpunkt
immer wieder ausführen.
Ho!
Ho!
Ho!
my_proc.call
my_proc.call
my_proc.call
my_proc = Proc.new
puts ‘Ho’
end
Procs und Blöcke
# => Today we got 42 degree!
# => Today we got 23 degree!
todays_weather.call 42
todays_weather.call 23
todays_weather = Proc.new do |temprature|
puts "Today we got #{teprature} degree!"
end
An Proc-Objekte können auch auch Objekte
übergeben werden.
Procs und Blöcke
[1,3,5,6,7].find Proc.new { |e| e.modulo(2) == 0 } # -> 6
class Array
def find(find_proc)
for i in 0...size
return self[i] if find_proc.call(self[i])
end
return nil
end
end
Iteratoren werden in Ruby mit Proc-Objekten
realisiert. Für jedes Element in einer Datenstruktur
kann eine beliebige Funktion ausgeführt werden.
Procs und Blöcke
ay = [“Hallo”]
ay << “Welt” # [“Hallo”, ”Welt”]
ing = “Hallo”
ing << “Welt” # “HalloWelt”
“If it walks like a duck and talks like a
duck, it maybe is a duck.”
Duck Typing
Experimentieren mit Code
• Interactive Ruby Shell (irb) für schnelles
starten
• Ruby Source Files enden auf .rb
• Ruby Programme mit ruby Dateiname
Syntactic Sugar
Demo
Hands-On!
Mittagspause
• MVC-Framework für Webapplikationen
• “Convention over Configuration”
• DRY (“Don’t Repeat Yourself!”)
• DSL für Webapplikationen
• Open-Source (MIT-Lizenz)
Ruby on Rails
•
•
•
•
•
•
•
•
Werkzeuge zur Automatisierung (rake)
Code Generierung (script/generate)
Test::Unit Integration
Webservice Integration (RESTful + ActiveResource)
Javascript Support (ActiveSupport)
(X)HTML-Rendering (ERb + ActionView)
HTTP-Request/Response Unit (ActionController)
ORM-Layer (ActiveRecord)
Architektur
Action
Mailer
Build Tool
Tests
e Generatoren
In Funktionalität
Bestandteil von Rails:
liefert aus
Active
Support
unterstützt
Action
View
zeigt an
Bowser oder
Client
rendert
Apache, WEBrick,
Lighttpd, mongrel
antwortet
CRUDs
Datenban
Abfragen
Active
Record
Validierung und
Business Prozesse
ruft FastCGI, SCGI,
CGI oder mod_ruby
Prozess auf
MySQL, PostgreSQL,
Oracle, ...
leitet um
Action
Controller
lädt
Dispatcher
leitet weiter
Web Server
Action Pack
(X)HTML, JS,
XML, ...
HTTP
Request
HTTP, RSS, ATOM, SOAP,
XML-RPC, etc.
Action
View
View
Benutzereingaben
Notifikation bei
Änderung
Zustandsabfrage
Auswahl
Anzeigen
Controller
Action
Controller
Active
Record
Model
Änderung des
Zustands
Rails & MVC
sondern in der HTTP Schnittstelle (HTTPVerbs)
• Keine Methodeninformation im URI,
über URI adressiert
• Representational State Transfer (REST)
• Repräsentationen von Ressourcen werden
REST
Action
Create
Read
Update
Delete
HTTP Verbs
POST
GET
PUT
DELETE
• CRUD wird auf HTTP Verbs abgebildet
RESTful
Demo
Speicher
• Kapseln den Zugriff auf die Daten
• Entsprechen meist “realen” Entitäten
• Webapplikationen: Meist Datenbanken als
Applikation
• Modelle halten die Business Logik der
M in MVC
n object that wraps a row in a database table or view, encapsulates
Datenzugriffs- und Domänenlogik vereinen si
einem Objekt
Daten sind meist persistent (Datenbank)
Objekte beinhaltet Daten und Verhalten
Martin Fowler (Chief Scientist ThoughtWorks.c
ActiveRecord?
(wird nicht behandelt)
• Abbilden von Relationen
• Validierung von Werten
• Abbilden der Objekte auf Datenbank (ORM)
• “Single Table Inheritance”
Fähigkeiten von AR
Methode bereit gestellt
• Spaltennamen werden zur Laufzeit als
Objekts aus der DDL der entsprechenden
Tabelle
• Dynamische Extraktion der Attribute eines
Fähigkeiten von AR
ActiveRecord::Migration
• Abstraktion der Schemadefinition durch
! Transparent für die Applikation
• (Fast) jedes relationale Datenbanksystem
• Abstraktion der Datenbankabfragen
Rails und DBMS
(rake db:migrate)
• Migration durchführen
(self.up, self.down)
• Zwei Methoden
(db/migrate/001_create_people.rb)
• Migrationsdatei
(script/generate migration)
• Erstellung der Migration
def self.down
drop_table :people
end
execute „ALTER TABLE ...“
end
t.timestamps
end
def self.up
create_table :people do |t|
t.string :firstname, :lastname
t.date :birthdate
class CreatePeople < ActiveRecord::Mi
ActiveRecord::Migration
ss Person
People < ActiveRecord::Base
ATE TABLE `people` (
`
int(11) NOT NULL auto_increment,
rstname` varchar(255) default NULL,
stname` varchar(255) default NULL,
irthdate` datetime default NULL,
IMARY KEY (`id`)
GINE=InnoDB DEFAULT CHARSET=latin1
self.down
self.down
drop_table
:people
rop_table :people
self.up
self.up
reate_table :people do |t|
create_table
:people do |t|
t.string :firstname, :lastname
t.column :firstname, :string
t.date :birthdate
t.column :lastname, :string
t.column :birthdate, :date
t.timestamps
end
nd
s CreateArticle
ss
CreatePeople <
< ActiveRecord::Migration
ActiveRecord::Migration
•
•
•
Die Klasse die Tabelle
Eine Instanz eine Zeile
Die Attribute die jeweiligen Spalte
•
•
•
Über die Klasse Customer lässt dich
die Eigenschaften zugreifen. Dabei
repräsentiert:
rake db:migrate wandelt diese in
spezifischen SQL Code um
Migration definiert in Ruby die DDL
ActiveRecord::Base
Demo
• Live Suche in den Einträgen
Kommentarfunktion und Loginbereich
• Einfaches Blogsystem mit
Workshops
• Beispielaufgabe für die Dauer des
MyBlog
Kommentare
User
Artikel
• Was ist Kernstück eines (unseres) Blogs?
MyBlog
Text
Titel
Autor
ok
blog
eintrag
blog
eintrag
blog
eintrag
StartSeite
kommentieren
zurück
Neues Kommentar anlegen
ommentieren
inzufügen (nach
ikel anzeigen
uchen
nzeigen
Navi
zurück
...
neuen eintrag
ansehen
Text
Titel
ok
Neuen Artikel anlegen
einen Antrag
ansehen
Login
blog
eintrag
Kommentar
Bild
DetailSeite Artikel
Flowchart
4. Anlegen der nötigen Views
3. Anlegen der nötigen Controller
2. Anlegen der nötigen Modelle
1. Rails Projekt anlegen (rails myblog)
Vorgehensweise
• Entweder “Alles auf einmal”
• oder “Iteratives Vorgehen”
• Rails begünstigt iteratives Vorgehen!
• Warum?
Vorgehensweise
• Dadurch:
• Gefahr der Wiederholung
• Nicht Berücksichtigung der Änderungen
während der Entwicklung
• Oft Änderungen der Anforderungen
Iteratives Vorgehen!?
• Rails unterstützt dabei durch
• MVC-Integration
• DSL
• Test-Integration (später)
OO-Programmierung
• Ausnutzung der Möglichkeiten der
Lösung
- Controller und View dafür
erzeugen mit Scaffold Generato
• Anfangen mit “Artikel”
• Scaffolding um Artikel einzutragen
• weitere Funktionen anschließend
MyBlog
- Modell “Article” erzeugen
Hands-On!
(errors Hash wird gefüllt)
• Gescheiterte Validierung = Fehlermeldung
Methode
• Validierung vor Speicherung des Objekts
• Jedes (Model-)Objekt hat eine ‘validate‘
festgelegt
• Validierung von Werten werden im Model
Validierung
:within => 5..2
• validates_presence_of :name
• validates_uniqueness_of :key
• validates_format_of :email
• validates_length_of :password,
Validierung
Mehr Informationen z
Validatoren im Handout
•
•
beinhaltet immer alle
Fehler die beim Versuch der
Speicherung aufgetreten sind.
errors
Bei eigener validate Logik
muss das errors Hash gefüllt
werden, da es die Schnittstelle
darstellt um mit den anderen
Funktionen von AktiveRecord
weiterhin arbeiten zu können
(Bsp.: valid?,
error_messages_for).
end
def validate
errors.add(„attribute_name“, „mess
unless „attribute_name" ==
„other_attribute“
end
validate_presence_of :firstname
class Customer < ActiveRecord::Base
Validierung
Mehr Informationen z
Validatoren im Handout
• Validieren der Benutzereingaben
• Sinnvolle Auswahl der Attribute
• Ausgabe bei Fehlermeldungen
Back to MyBlog
Hands-On!
• Rails als agiles MVC-Framework
• Meinungen bisher?
Programmiersprache
• Ruby als dynamische OO-
Tag 1 - Fazit
09:00 Uhr
Thursday, 16 Feb. 2008,
See You Tomorrow
Feel the Speed
Day Two
•
•
•
•
•
•
•
Tag 1
Tag 2
Tag 3
User Login
Test-First Development
View und Controller (ActionPack)
ActiveRecord::Associations
Das M in MVC (ActiveRecord)
Beginn der Applikation
Warm-Up & Grundlagen
3.days do
Fragen bis hierher?
"Weiteres Model/Tabelle in der Datenbank!
"Problem: Abbilden der Relation in Rails
werden können
• Bisher: Artikel anlegen und editieren
• Was fehlt: Artikel sollen kommentiert
MyBlog
• Stärkere Individualisierung der Applikation
• Daher: Auseinandersetzen mit ActiveRecor
Codes (Scaffolding)
• Bisher nur Verwendung des generierten
Working with AR
Demo
können
• Relationen auf Objektebene modellieren
• Die Relation muss persistiert werden
Entitäten
• Arbeit mit mehreren Entitäten
• Abbilden von Relationen zwischen
ActiveRecord::Associations
• has_one
• belongs_to
• has_many / has_many :through
• has_and_belongs_to_many
Beziehungstypen
id
title
filename
pictures
has_one
1
1
id
picture_id
filename
thumbnails
belongs_to
ss Thumbnail < ActiveRecord::Base
elongs_to :picture
Beziehung in der
Datenbank auf
• Löst die Foreign Key
Methode ‘thumbnail’
• Erweitert ‘Picture’ um
auf Objektebene ab
• Bildet eine 1:1 Bezieh
has_one
ss Picture
Pi t
< ActiveRecord::Base
as_one :thumbnail
n Keys sind
onvention der
nname im
ar plus ‘_id’
n sind nach
ntion im Plural
id
firstname
lastname
…
people
has_many
1
n
id
person_id
street
zip
…
addresses
belongs_to
ss Address < ActiveRecord::Base
elongs_to :person
ss Person < ActiveRecord::Base
as_many :addresses
Methode ‘person’
• Erweitert ‘Address’ um
den Foreign Key in ein
oder 1:1 Beziehung hä
• Beschreibt die Tabelle,
belongs_to
id
firstname
lastname
…
people
has_many
1
n
id
person_id
street
zip
…
addresses
belongs_to
ss Address < ActiveRecord::Base
elongs_to :person
ss Person < ActiveRecord::Base
as_many :addresses
addresses.person_id’
WHERE people.id =
aller Adressen zurück
‘SELECT * FROM addres
• ‘addresses’ gibt ein Ar
Methode ‘addresses’
• Erweitert ‘Person’ um
auf Objektebene ab
• Bildet eine 1:n Bezieh
has_many
me
adline
projects
n
1
n
1
id
name
skills
…
developers
has_many_and_belongs_to_many
developers_projects
project_id
any_and_belongs_to_many
ss Developer < ActiveRecord::Base
as_and_belongs_to_many :projects
auf Objektebene ab
Datenbank notwendig,
KEINE ActiveRecord::
Klasse
• Zwischentabelle nur! i
• has_and_belongs_to_
• Bildet eine n:m Bezieh
habtm
ss Project < ActiveRecord::Base
as_and_belongs_to_many :developers
isch geordnet
men der
pften Tabellen
line
projects
any :through
n
1
assignments
project_id
developer_id
belongs_to
n
1
id
name
skills
…
developers
has_many :through
s Developer < ActiveRecord::Base
s_many :projects, :through => :assignments
s Assignment < ActiveRecord::Base
longs_to :developer
longs_to :project
s Project < ActiveRecord::Base
s_many :developers, :through => :assignments
Attribute und bietet di
Möglichkeit Validierun
durchzuführen
• Zwischentabelle enthä
ActiveRecord::Base Kl
‘assignments’ abgebild
• Zwischentabelle wird
auf Objektebene ab
• Bildet eine n:m Bezieh
has_many :through
Demo
(Ein Kommentar darf niemals alleine stehen)
• Validierung beachten!
(mit Migration)
• Datenbanktabellen ggf. überarbeiten
ActiveRecord::Associations
• Modelle haben noch keine Relationen
• Relationen erstellen mit Hilfe von
Back to MyBlog
Hands-On!
Kommentarfunkti
implenentieren!
URL: ar.rubyonrails
Assoziationen
Mittagspause
Action
View
View
Benutzereingaben
Notifikation bei
Änderung
Zustandsabfrage
Auswahl
Anzeigen
Controller
Action
Controller
Active
Record
Model
Änderung des
Zustands
Einbinden der
Assoziationen
--
Controller und V
erklären
Views und Controller
View-Elemente in Ordner app/views
Layouts für ständigen Inhalt (Bsp: Header, Footer, etc)
•
•
•
•
Repräsentation der Daten aus DB
•
app/views/controllen_name/action_name.rhtml
Jede Action hat eigenes View-Template
app/views/controller_name
Jeder Controller hat eigenen View-Template Ordner in
app/views/layouts
View generiert das User-Interface
•
View
<%= Ruby expression -- replace with result %>
<%- Ruby code -- inline with output %>
• Einbettung durch Inline-Element <% %>
Dokumente (XHTML, XML…)
• ERB - Embedded Ruby
• Templatesprache für Plain-Text
View im Detail
ble>
tbody>
% @articles.each do |article| %>
<tr>
<% Articles.column_names.each do |column| %>
<td><%= article.send(column) %></td>
<% end %>
</tr>
% end %>
<table>
/tbody>
<tbody>
<
able>
...
ERB P
arser
<tr>
<td>ASS Training ist toll</t
<td>Dirk Breuer</td>
...
</tr>
...
</tbody>
Ausgabe in der View
HTML-Fragmente
• Lösung: Wrapper-Methoden für komplexe
Präsentationsschicht
• Entlastung der View von Ruby-Code
• Problem: Ruby-Code in der
ActionView::Helper
orm action=“/articles/create“ method=“post“>
<input type=“text“ size=“30“ name=“article[title]“ id=“article_title“ />
<input type=“submit“ name=“Create“ value=“commit“ />
href=“/articles/list“>Übersicht</a>
ht</a>
ERB P
arser
<%= start_form_tag :action => 'create' %>
<%= text_field “article“, “title“ %>
<%= submit_tag "Create" %>
<%= end_form_tag %>
<%= link_to “Übersicht“, :controller => ‘articles‘, :action => ‘list‘ %>
ActionView::Helper
‘Moderator‘ der Applikation (app/controllers)
HTTP-Request/Response Handler
Jeder Controller besitzt ein Request/Response-Objekt
•
•
! Teilen von übergreifenden Funktionen
Alle Controller erben vom ApplicationController
(application.rb)
•
•
Controller
Actions sind öffentliche Methoden des Controllers
Actions können rendern oder an andere Actions weiterle
Verfügbarkeit der Actions durch Routing
•
•
Eigentliche Operationen werden von den Actions
durchgeführt
•
•
Controller
params[:key], session[:key]
(redirect_to :action => ‘index‘)
(render :template => ‘show‘)
• Render
• Redirect
• Zugriff auf Request Parameter und Session
View-Template auf
• Action ruft automatisch gleichnamiges
Controller im Detail
• http://localhost:3000/articles/1/edit
• rake routes
• articles -> controller (params[:controller])
• 1 -> params[:id]
• edit -> action (params[:action])
URI und Parameter
• Überarbeiten von Controller und Views
• Create Read Update Delete - Methoden
• Eingaben und Ausgaben berücksichtigen
• Artikel sollen kommentiert werden können
Back to MyBlog
Hands-On!
(_form.rhtml)
• Partials sind Teilstücke der View
• Seperate Dateien
• Wiederverwendbarkeit von Code
• Modularisierung der View
Partials
!
!
Rendert Partial ‘person‘ mit lokaler Variable
•
Rendert Partial ‘comment‘ mit gleichnamiger lokaler Variable
‘comment‘ für alle Objekte in der Collection
render :partial=>‘comment‘,
:collection => @articles.comments
•
render :partial=>‘person‘,
:locals => {:name => “andi“}
• Verschiedene Möglichkeiten
Partial Aufruf
• Sinnvolle Partial-Elemente erzeugen
• DRY erleben!
implementieren
• Liste der Kommentare als Partial
Back to MyBlog
Hands-On!
• Integration des MVC-Konzepts in Rails
• Model (ActiveRecord)
• View (ActionView)
• Controller (ActionController)
• Meinungen bisher?
Tag 2 - Fazit
• Treffpunkt: Chaos Computer Club Cologne
• http://rurug.de
19:30 - 21:30 Uhr
• Jeden zweiten Donnerstag im Monat von
RuRUG Köln
09:00 Uhr
Friday, 15 Feb. 2008,
See You Tomorrow
Final round
Day Three
•
•
•
•
•
•
•
Tag 1
Tag 2
Tag 3
User Login
Test-First Development
View und Controller (ActionPack)
ActiveRecord::Associations
Das M in MVC (ActiveRecord)
Beginn der Applikation
Warm-Up & Grundlagen
3.days do
Fragen bis hierher?
• Was fehlt: Testing
• Was fehlt: Login
"Rails Test Environment kennen lernen
"Login Implementieren (test-driven)
Kommentare hinzufügen
• Bisher: Artikel anlegen und editieren,
MyBlog
existiert nicht!
• Nur automatisierte Tests gelten als Test
• Bei TDD: Code der nicht getestet wird,
immer im Browser.“
• „Aber ich teste doch! Ich mach das dann
Testen?!
Applikation zu verstehen
• Die Tests sind Spezifikation der
durchläuft
• Funktionalität implementieren bis Test
Implementierung
• Test Case formulieren vor der eigentlichen
TDD
• 3 verschiedene Arten von Tests
• Unit (Testen der Modelle)
• Functional (Testen der Controller)
• Integration (Übergreifende Testfälle)
Ordner test aus
• Führt alle vorhandenen Test-Fälle im
rake test
• Bei Rails: Testen der ActiveRecord Klassen
• Testen von Funktionen wie
• Validatoren (vor allem Selbstgeschriebene)
• eigene Methoden
• Abhängigkeiten
Software
• Allgemein: Testen einzelner Module in einer
Unit Tests
TestCase bereitgestellt
• Fixturedaten werden über users(:dirk) im
Datenbank gespielt
• Testdaten
• Werden für jeden Testfall neu in die
Fixtures
• Eine Datei pro Tabelle
Modellklassen lassen sich
ebenfalls abbilden
• Assoziationen zwischen
YAML (Serialisierung).
Hierarchien werden durch
Einrückungen abgebildet
(je zwei Leerzeichen
KEINE Tabs)
• Definition von Objekten in
# users.yml
dirk:
email: [email protected]
firstname: Dirk
lastname: Breuer
password: 5eb942810a75ebc850972a89285d570d4
created_at: <%= Time.parse("2006-04-12
16:00:12").to_s(:db) %>
# articles.yml
first:
title: Mein Artikel
content: Wichtiger Inhalt zum Artikel
author: dirk
Fixtures
ssertions (Aussagen
estätigen)
est Methoden (beginnen immer
it test)
etup Methode (wird vor jeder
estmethode ausgeführt)
ixtures (Testdaten)
rbt von Test::Unit::TestCase
article.title = "Valid Title"
article.author = users(:bob)
assert_valid article
assert article.save
end
article.title = "<script>javascript:alert('Hallo');</
assert !article.valid?
def test_has_valid_title
article = Article.new(:title => '')
assert !article.valid?
def setup
# Do some initial stuff
end
class ArticleTest < Test::Unit::TestCase
fixtures :articles
require File.dirname(__FILE__) + '/../test_helper'
Aufbau Test Case
Demo
• rake test:units
haben?
• Kann ein Artikel mehrere Kommentare
Artikel?
• Gehört ein Kommentar immer zu einem
Back to MyBlog
Hands-On!
•
•
•
•
•
•
•
Ist der Zugang tatsächlich beschränkt?
Stimmt die Sortierung?
Wird das richtige Suchergebnis geliefert?
Werden die richtigen Variablen gesetzt?
Testen von Funktionen wie
Testen einzelner Controller
Testen der Funktionen die einem User (oder anderem System)
angeboten werden
Functional Tests
Demo
Hands-On!
und anschließend das anlegen von
Kommentaren in Reihe?
• Testen von Workflows innerhalb der Applikation
• Testen mehrerer Controller im Zusammenspiel
• Testen von Funktionen wie:
• Klappt der Request von A nach B?
• Funktioniert der Login, anlegen eines Artikels
Intergration Tests
Mittagspause
zulassen
• Loginbereich
• Bestimmte Aktionen nur nach Login
bestehende editieren können
• Nicht jeder soll neue Artikel anlegen oder
User Login
• Anwendung des bisher Gelernten
• HTTP-Stateless-Problematik
User Login
hinterlegt
• Session-Key wird i.d.R. im Cookie
Server hinterlegt
• Session ist (temporär) persistent auf dem
von Session
• Problem: HTTP ist Stateless Protokoll
• Lösung: Pseudostate einführen in Form
Sessions
ession Key/Value Paar in
ie (der Domain) schreiben
User
Sessions
11. Request
4. Response
(mit Session Key/Value Paar)
3. Session
erzeugen!
Nein
2. Session
vorhanden??
Server
ession Key/Value Paar aus
us
Cookie (der Domain) laden
User
2. Request
(mit Session Value)
Sessions
5. Response
4. Session
laden
Ja
3. Session
vorhanden??
Server
Demo
•
•
•
•
•
•
Cookie (HÄ??)
Memcached
Speicher
Datenbank
Filesystem
In Rails ist die Session als Hash realisiert, das
serialisiert auf einem persistenten Speicher hinterlegt
wird, z.B.:
Sessions
•
•
•
Prinzipiell kann alles in der Session gespeichert
werden, aber abwägen was tatsächlich gespeichert
werden soll
session
Zugriff auf das Session Hash über die Methode
Hier verwenden wir nicht die Standardlösung (CookieBased), sondern Filesystem
Sessions
nicht behandelt)
• Hier: before_filter
(andere werden
Controllern gemeinsam benutzt werden
• Filter können von verschiedenen
die Applikation ein (Bsp: Authentisierung)
• Filter fügen Querschnittfunktionalität in
Filter Chain
ticlesController < ApplicationController
_filter :authenticated,
:only => [‘new‘, ‘create‘,
‘update‘, ‘edit‘]
class ApplicationController < ActionController::Base
def authenticated
if session[:user]
true
else
redirect_to :controller => ‘users‘, :action => ‘
end
end
end
typischerweise im ApplicationController
• Definition der Filter im Controller
• Definition der Methode die beim Filter ausgeführt,
Filter Chain
• Sicherstellung durch Testen
Berechtigung darf geschützte Funktionen
ausführen.
• Wichtige Funktion! Niemand ohne
Integration des Logins
Hash-Funktion
Salt
5eb942810a75ebc850972a8
Password
Exkurs: Hash-Funktion
• User mit Login erstellen
• Test-Case für Login im Blog erstellen
• Fixtures erstellen
• Testfall schreiben
• Test laufen lassen
Back to MyBlog
Hands-On!
• Kein Reload der Seite bei Aktualisierung
• Look&Feel von Desktop-Applikationen
Browser und Server
• Akronym für Asynchronous JavaScript and XML
• Der Begriff ist neu und voll im Trend!
• Das Konzept ist alt! (XmlHttpRequest)
• Asynchrone Datenübertragung zwischen
AJAX
Javascript-Aufruf
AJAX-Engine
Manipulation
des DOM
Browser
HTTP-Request
(XML-Daten)
XML-Daten
AJAX-Modell
Webserver
(Script.aculo.us, Prototype…)
• Kein Plugin erforderlich
• Völlig neue Interaktionsmöglichkeiten
• Live-Suche, Auto-Completion, etc.
• Viele kostenlose API‘s und Frameworks
Vorteile
• Polling-Problematik
• Zurück-Button
• Lesezeichen
• Feedback
Nachteile
•
,
link_to_remote form_remote_for observe_field
,
…
einfachen Zugriff auf AJAX-Funktionen
• Wrapper-Methoden ermöglichen
und Script.aculo.us
• Vollständige Integration von Prototype
AJAX in Rails
des Suchworts angezeigt
• Live-Suche
• Suchergebnisse werden bei der Eingabe
AJAX in Action
werden
• Veränderung mehrerer DOM-Elemente
• Nutzt XmlHttpRequest
• Bestimmt WIE Templates modifiziert
Javascript Generator
Templates (rjs)
nder :update do |page|
page.insert_html :before, ‘element-id‘, :partial => ‘cron
page.replace_html ‘element-id‘, :partial => ‘search‘,
:locals => { :articles => @articles }
page.remove ‘element-id‘
page.show ‘element-id‘
page.hide ‘element-id‘
d
render :update
• „Ajaxified“ Blog mit Live-Suche
• Suche für Artikel
• Welche Suchkriterien sind relevant?
Back to MyBlog
Hands-On!
End of Days
• Hauptanforderungen erfüllt!
• Nach der Pflicht kommt die Kür
• RSS-Feed für den Blog
• Bilder-Upload für Artikel
• Live-Suche mit AJAX
• ...
Projektabschluss
• Knowledge-Pack für alle!
• Rails unterstützt das MVC-Model
• Entlastung des Entwicklers bei Konfiguration
• Konzentration auf die wesentlichen Dinge
Applikationen
• Einstieg in das Rails Framework
• Agile Methode zur Entwicklung von Web-
Zusammenfassung
•
•
•
•
Kompletter Source Code
Hand-Outs
Folien
http://www.medieninformatik.fh-koeln.de
Knowledge-Pack
•
The Pragmatic Programmer - Dave Thomas, Andrew Hunt (Addison-Wesle
ISBN: 0-201-61622-X)
Programming Ruby - Dave Thomas, Andrew Hunt (The Pragmatic Program
ISBN: 0-974-51405-5)
Ruby for Rails - Dave A. Black (Manning, ISBN: 1-932394-69-9
Agile Web Development with Rails (2nd Ed.) - Dave Thomas, David Heinerm
Hansson (The Pragmatic Programmers, ISBN: 0-9776166-3-0)
Rails Recipes - Chad Fowler (The Pragmatic Programmers, ISBN:
0-9776166-0-6)
•
•
•
•
•
Literatur
Knowledge-Pack
http://errtheblog.com
http://weblog.jamisbuck.org
http://drnicwilliams.com
http://railscasts.com/
http://nubyonrails.com
http://peepcode.com/
http://therailsway.com/
http://code.google.com/p/blueprintcss/
http://csszengarden.com/
http://studios.thoughtworks.com
•
•
•
•
•
•
•
•
•
•
http://www.ruby-lang.org
http://rubyonrails.com
http://script.aculo.us
http://www.prototypejs.org
http://de.selfhtml.org/
http://groups.google.com/group/rubyonrails-talk
http://subversion.tigris.org/
http://git.or.cz
http://rubyquiz.com/
http://rubyforge.org
Web Links
Trac / Mingle / Basecamp
Subversion / Git
MySQL / SQLite3
RubyGems
Commandline
Mac OS X + TextMate
Firefox + Firebug
•
•
•
•
•
•
•
Aptana
3rdRails
NetBeans 6
RadRails
IDEs
Linux + JEdit
Windows + e + cygwin
Tools
• http://railsbros.de
• [email protected]
• [email protected]
• http://mediaventures.de
• http://pkw.de
About Us
• Eure Meinung ist uns wichtig!
• Was hat euch gefallen?
• Was hat euch nicht gefallen?
• Was kann man besser machen?
One Question…
Macht’s gut und Danke
für den Fisch