Pizza on Rails. Frank Rothmann

Transkript

1 Pizza on Rails Frank Rothmann

2 Inhaltsverzeichnis Einführung Ruby Hello World Kommentare puts Objektorientierung Merkmale Eisenbahn-Beispiel Klassen Attribute Methoden Variablen Zahlenwerte String Boolean Array Hash Symbol lokale Variablen Instanz-Variablen Class-Variablen Globale-Variablen Schleifen While / Until each Bedingungen If.. then else Blöcke Rails unter der Lupe Blog in 15 Minuten Aufbau einer Rails Application Die Rails Komponenten Skeletton Controller Model View...51 Index-View...51 Edit-View...52 Show-View Die Pizza App Story Pizzas Scaffold View Controller Model Orders Scaffold...54

3 4.3.2 View Controller Model...54

4 1 Einführung Die Intention ein Rails Tutorial zu schreiben rührt daher, dass ich seit einigen Jahren begeistert mit dem Rails-Framework Anwendungen entwickele. Rails hat sich durchaus als alltagstauglich erwiesen. Das Framework avanciert vielfach als eine Möglichkeit in kürzester Zeit eine Webapplication zu schreiben. Das ist zunächst einmal durchaus richtig, wenn man die Applikation jedoch mit mehr als den Grundfunktionen austatten möchte, kommt man über richtige Programmierung nicht umher. Aus diesem Grund habe ich dem eigentlichen Rails-Teil des Tutorial eine kurze Einführung in Ruby vorangestellt. Ein Grundverständnis der zugrunde liegenden Sprache halte ich für unumgänglich.

5 2 Ruby Die Programmiersprache Ruby wurde von dem japanischen Studenten Yukihiro Matz Matsumoto 1995 entwickelt. Die Programmiersprache sollte durchgängig objektorientiert sein, jedoch zunächst als Skriptsprache zu Verfügung gestellt werden. In den letzten Jahren entwickelte sich die Sprache massiv weiter, es kamen eine Vielzahl von Klassen hinzu, wodurch diese Sprache sich jetzt als objektorientierte Allroundsprache darstellt. Interpreter sind für die gängigen Betriebssysteme wie Windows, MacOS und Linux kostenlos erhältlich, zudem gibt es eine unter der JAVA-JVM laufende Variante JRUBY, die Ruby auf jeder JVM lauffähig macht. 2.1 Hello World Traditionsgemäß beginnt man einen Beitrag über eine Programmiersprache mit HelloWorld. Ich möchte hier keine Außnahme machen, daher hier das Beispiel: puts "Hello World" Wie man sieht besteht das Programm aus lediglich einer Zeile. Einfacher geht es nicht! 2.2 Kommentare Auch wenn unser HelloWorld keine Kommentare beinhaltet, möchte ich hier mit den Kommentare anfangen. Sie werden entweder als Zeilenkommentar gesetzt: # Hallo oder mit einem /# #/ umgeben: /# Hallo hier geht es weiter #/ 2.3 puts Der einzige Befehl in HelloWorld ist der puts Befehl. Mit ihm wird ein String ausgegeben. puts "Hello World" ergibt Hello World Pizza on Rails - 5 -

6 [Finished in 0.1s] 2.4 Objektorientierung Auch wenn bei dem HelloWorld-Beispiel nichts von Objektorientierung zu sehen war, handelt es sich bei Ruby um eine streng objektorientierte Sprache. Der Begriff Objektorientierte- Programmierung steht für einen sich von der herkömmlichen Programmierung grundsätzlich unterschiedlichen Ansatz. Ihn in vollem Umfang zu beschreiben würde ganze Bücher füllen, daher möchte ich hier auf das Wesentliche eingehen, was man zum Verständnis der Sprache Ruby und der Entwicklung mit Rails benötigt. Während man bei prozeduralen Sprachen grundsätzlich Aufgaben in Teilaufgaben unterteilt und diese dann programmiert, geht die objektorientierte Programmierung einen gänzlich anderen Weg. Hier beschreibt man ein Objekt durch eine Klasse in der man alle relevanten Attribute und alle diese Attribute veränderten Methoden definiert. Ein Programm besteht also aus einer Reihe unterschiedlicher, miteinander in Beziehung stehenden Klassen Merkmale Objekte sind grundsätzlich gekapselt! Eisenbahn-Beispiel Den theoretischen Ansatz möchte ich durch ein kleines Beispiel verdeutlichen. Die Aufgabe besteht darin, ein Lokomotive zu programmieren. Eine Lokomotive wird programmiert, indem man die relevanten Eigenschaften in einer Klasse definiert. Gerade die Frage welche Eigenschaften relevant sind ist nicht unerheblich für die Komplexität des späteren Programms. Infrage kämen zunächst eine große Anzahl möglicher Attribute: Länge, Breite, Farbe, Höchstgeschwindigkeit, Gewicht.... Wir beschränken uns zunächst mal auf Attribute, die wir auch tatsächlich im Programm verwenden werden, in unserem Beispiel auf die Geschwindigkeit. 1!#/bin/ruby 2 class Lok 3 4 def initialize = 0 6 end 7 puts "Hallo" end emma = Lok.new 13 p emma Pizza on Rails - 6 -

7 Wir definieren zunächst eine Klasse Lok ( 2 10). Dazu definieren wir in Zeile 2 die Klasse und initialisieren diese mit der Methode initialize in Zeile 4 bis 6. Die setzen wir auf den Initialwert 0. Um zu sehen, dass wir die Klasse erstellt haben, geben wir mit dem Befehl puts in Zeile 7 Hallo aus. In Zeile 12 erstellen wir ein Objekt emma der Klasse Lok. Dieser Schritt ist wichtig. Die Klasse definiert die Eigenschaften und Methoden eines Objekts, durch die Methode.new wird aus der Klasse ein Objekt erstellt. Zeile 13 gibt mit dem Befehl p alle Objekteigenschaften des Objekts emma aus. Wenn wir das Programm starten ergibt sich: Hallo [Finished in 0.0s] Neben der zu erwartenden Ausgabe Hallo wird die Klasse emma ausgegeben. Man sieht, dass es sich um ein Objekt vom de Klasse Lok handelt, dass in der Speicherstelle 0x7f044a1c3590 gebildet wurde und das einzige besitzt. Pizza on Rails - 7 -

8 Nach dem ersten Erfolg erweitern wir die Klasse ein wenig: 1!#/bin/ruby 2 class Lok 3 4 def initialize = 0 6 end def geschwindigkeit? 10 puts "Geschwindigkeit: #{@geschwindigkeit}" 11 end end emma = Lok.new 16 p emma 17 emma.geschwindigkeit? In den Zeilen 9 11 wird die Methode geschwindigkeit? definiert. Man benötigt sie, um auf die zugreifen zu können, da Klassen grundsätzlich gekapselt sind. Somit kann nur über definierte Methoden auf Variablen zugegriffen werden. Man spricht hier von einer sogenannten getter- Methode, die auf den Wert einer Variablen zugreift. Das in Zeile 15 erzeugte Objekt emma zeigt nun, wenn man die Methode geschwindigkeit? In Zeile 17 aufruft die die Geschwindigkeit an: Hallo Geschwindigkeit: 0 [Finished in 0.0s] Pizza on Rails - 8 -

9 Somit haben wir gerade die erste Eigenschaft objektorientierter Entwicklung kennengelernt: Objekte sind grundsätzlich gekapselt! Der Grund für die Kapselung von Objekten ist naheliegend. Da ein Programm aus vielen Objekten besteht, teilweise werden auch ganze Objekt-Bibliotheken importiert, ist es notwendig Objektinterna soweit wie möglich zu kapseln. Nur so können Seiteneffekte vermieden werden. Wir erweitern unsere Klasse um zwei weitere Methoden: 1!#/bin/ruby 2 class Lok 3 4 def initialize = 0 6 end def beschleunige end def bremse end def geschwindigkeit? 20 puts "Geschwindigkeit: #{@geschwindigkeit}" 21 end end emma = Lok.new 26 p emma 27 emma.geschwindigkeit? 28 emma.beschleunige 29 emma.geschwindigkeit? 30 emma.bremse 31 emma.geschwindigkeit? Geschwindigkeit: 0 Geschwindigkeit: 10 Geschwindigkeit: 0 [Finished in 0.0s] Die Methoden beschleunige und bremse wirken wie zu erwarten auf das Attribut geschwindigkeit. Attribute ( Objekteigenschaften) werden durch Variablen definiert Pizza on Rails - 9 -

10 Attribute werden durch Methoden beeinflusst Mit einer weiteren Erweiterung kann man den Methoden auch Werte übermitteln: 1!#/bin/ruby 2 class Lok 3 4 def initialize = 0 6 end 7 8 def beschleunige(wert) + wert 10 end def bremse(wert) - wert 14 end def geschwindigkeit? 17 puts "Geschwindigkeit: #{@geschwindigkeit}" 18 end end emma = Lok.new 23 p emma 24 emma.geschwindigkeit? 25 emma.beschleunige(20) 26 emma.geschwindigkeit? 27 emma.bremse(10) 28 emma.geschwindigkeit? Geschwindigkeit: 0 Geschwindigkeit: 20 Geschwindigkeit: 10 Pizza on Rails

11 Wir erweitern unser Bespiel ein letztes Mal zum Big Picture 1!#/bin/ruby 2 class Lok 3 4 def initialize = 0 6 end 7 8 def beschleunige(wert) + wert 10 end def bremse(wert) - wert 14 end def geschwindigkeit? 17 puts "Geschwindigkeit: #{@geschwindigkeit}" 18 end end class Elok < Lok def initialize 25 super = 320 = "elok" 28 end end class Diesellok < Lok def initialize 35 super = "Diesel-Lok" = 320 = 0 39 end def tanken(wert) + wert 43 end def tankinhalt? 46 puts "Tankinhalt: #{@tankinhalt}" 47 end end Pizza on Rails

12 51 emma = Lok.new 52 p emma 53 emma.geschwindigkeit? 54 emma.beschleunige(20) 55 emma.geschwindigkeit? 56 emma.bremse(10) 57 emma.geschwindigkeit? fritzi = Elok.new 60 p fritzi 61 fritzi.beschleunige(180) 62 fritzi.geschwindigkeit? 63 fritzi.bremse(60) 64 fritzi.geschwindigkeit? stinki = Diesellok.new 67 p stinki 68 stinki.beschleunige(130) 69 stinki.geschwindigkeit? 70 stinki.bremse(20) 71 stinki.geschwindigkeit? 72 stinki.tanken(200) 73 stinki.tankinhalt? Das Ergebnis: stinki = Diesellok.new p stinki stinki.beschleunige stinki.geschwindigkeit? stinki.bremse stinki.geschwindigkeit? stinki.tanken stinki.tankinhalt? Pizza on Rails

13 Um das Programm zu verstehen, untersuchen wir es in mehreren Etappen. Wir haben jetzt erstmals Klassen gebildet, die alle Eigenschaften einer Elternklasse geerbt haben. Dies ist ein grundsätzliches Feature objektorientierter Entwicklung. 22 class Elok < Lok def initialize 25 super = 320 = "elok" 28 end end Zeile 22 beschreibt mit dem Zeichen <, dass die Klasse Elok alle Merkmale der Klasse Lok erbt. In Zeile erweitern wir die Methode initialize der Klasse Lok. Damit die weiterhin vorbelegt wird, übernehmen wir alle Werte der initiaze-methode von Lok in Zeile 25 mit dem Command super. Ohne diese Anweisung würden wir die initialize-methode überschreiben. Die werden in Zeile 26 und 27 definiert. Natürlich kann eine erbende Klasse auch weitere Methoden beinhalten. Hier ein Beispiel dafür: 32 class Diesellok < Lok def initialize 35 super = "Diesel-Lok" = 320 = 0 39 end def tanken(wert) + wert 43 end def tankinhalt? 46 puts "Tankinhalt: #{@tankinhalt}" 47 end Die Klassen werden nachfolgend ganz einfach initialisiert: 66 stinki = Diesellok.new 67 p stinki 68 stinki.beschleunige(130) 69 stinki.geschwindigkeit? 70 stinki.bremse(20) 71 stinki.geschwindigkeit? 72 stinki.tanken(200) 73 stinki.tankinhalt? Pizza on Rails

14 Mit diesem Beispiel möchte ich den ersten Ausflug in die Objektorientierung abschließen. Es ist leicht ersichtlich, dass gerade die Vererbung ein großes Potential birgt. Wenn man Objekte sinnvoll arrangiert, können Erweiterungen des Objektmodells einfach durch das Hinzufügen von Methoden an einer Stelle an die Kinderobjekte weiter vererbt werden. Im Fall von Ruby gibt es jedoch die Einschränkung, dass eine Klasse immer nur eine Elternklasse haben kann. Eine Klasse kann alle Eigenschaften jeweils einer Elternklasse erben. 2.5 Klassen Objekte werden in der objektorientierten Programmierung durch Klassen definiert. Diese bilden sozusagen den Bauplan für Objekte. Als erstes Beispiel möchte ich einen Taschenrechner programmieren. Dazu definiere ich zunächst die Klasse Calculator. In der UML-Notation, einer beliebten Methode zur Darstellung objektorientierter Systeme, sieht die Klasse zunächst wie folgt aus: Objektname Attribute Methoden Der Code dazu: 1!#/bin/ruby 2 3 class Calculator 4 5 end Pizza on Rails

15 2.5.1 Attribute Attribute sind die Eigenschaften von Objekten. Hier werden also all relevanten Eigenschaften der Objekte definiert. Die Eigenschaften werden in der Methode initialize initiiert. Bei unserem Taschenrechner-Beispiel werden die Eigenschaften wert1, wert2 und ergebnis definiert und in der Methode initialize vordefiniert. In der UML-Notation werden im 1. Block die Objekteigenschaften angegeben: 1!#/bin/ruby 2 3 class Calculator 4 5 def initialize 6 wert1 = 0 7 wert2 = 0 8 ergebnis = 0 9 end end Pizza on Rails

16 2.5.2 Methoden Neben den Attributen gibt es die Methoden. Sie definieren die Möglichkeiten, auf Attribute zuzugreifen oder sie zu verändern. Auch hier werden lediglich die relevanten Methoden definiert. Ein Objekt wird also in der Regel nie vollständig definiert sein. Der Code dazu: 1!#/bin/ruby 2 3 class Calculator 4 5 def initialize 6 wert1 = 0 7 wert2 = 0 8 ergebnis = 0 9 end def addiere(eingabe1, eingabe2) 12 ergebnis = eingabe1 + eingabe2 13 puts "#{eingabe1} + #{eingabe2} = #{ergebnis}" 14 end def subtrahiere(eingabe1, eingabe2) 17 ergebnis = eingabe1 - eingabe2 18 puts "#{eingabe1} - #{eingabe2} = #{ergebnis}" 19 end def multipliziere(eingabe1, eingabe2) 22 ergebnis = eingabe1 * eingabe2 23 puts "#{eingabe1} * #{eingabe2} = #{ergebnis}" 24 end def dividiere(eingabe1, eingabe2) 27 ergebnis = eingabe1 / eingabe2 28 puts "#{eingabe1} / #{eingabe2} = #{ergebnis}" 29 end end Pizza on Rails

17 Eine Methode wird innerhalb von def end definiert. Wenn an eine Methode Argumente übergeben werden müssen, so folgen diese in einer Argumentenliste durch Kommata voneinander getrennt (Beisp. Zeile 11). Die im Beispiel angegebenen Klammern sind optional, dienen aber der Übersichtlichkeit. Innerhalb der Methode verwendet man in der Regel lokale Variablen (Beisp. Zeile 17). Mit puts wird in unserem Calculator dass ein Ergebnis ausgegeben. Um innerhalb des Ausgabestrings auf die Variablenwerte zugreifen zu können, werden diese in #{ } gesetzt. Um aus der reinen Klassendefinition ein ablaufendes Programm zu machen, erweitern wir den Code: 33 cal1 = Calculator.new 34 cal1.addiere(10,20) 35 cal1.subtrahiere(12,6) 36 cal1.multipliziere(2,3) 37 cal1.dividiere(6,3) In Zeile 33 instanzieren wir das Calculatorobjekt cal1 mit dem Methodenaufruf new. Damit haben wir aus der Klassendefinition Calculator ein Objekt im Hauptspeicher geschaffen. Die Methoden des Objektes rufen wir einfach mit <objekt>.<methode><argumente> auf. Das Ergebnis gibt uns Recht: = = 6 2 * 3 = 6 6 / 3 = 2 [Finished in 0.0s] 2.6 Variablen Attribute werden in Ruby, wie in allen Programmiersprachen, mit Variablen abgebildet. Hier unterscheidet sich Ruby zunächst nicht von anderen Sprachen. Variablen sind in Ruby nicht typisiert. Das ist jedoch ein immenser Unterschied zu anderen Sprachen. Was das konkret bedeutet, zeigt das folgende Beispiel: 1 variable1 = "Hello" 2 p variable1.class 3 variable1 = p variable1.class Wir weisen in Zeile 1 der variablen1 einen String und in Zeile3 einen Integer zu. Der Variablenwert wurde nirgendwo definiert, trotzdem weist Ruby derselben Variable den jeweils richtigen Objekttyp zu. String Fixnum [Finished in 0.0s] Praktisch, aber auch tückisch, da der Typ einer Variablen im Programmablauf verändert werden Pizza on Rails

18 kann! Zahlenwerte Der erste bekannte Variablentyp ist der Typ Integer 1 variable1 = p variable1 3 p variable1.class 4 variable1.to_i 5 p variable1 6 p variable1.class 7 variable1 = variable1 * p variable1 9 p variable1.class 10 variable1 = variable1 / p variable1 12 p variable1.class 13 variable2 = variable1 / 2 14 p variable2 15 p variable2.class 16 variable2 = variable1 / p variable2 18 p variable2.class Wir weisen der variablen1 eine Zahl zu, nehmen diese mal und teilen sie darauf wieder durch Wie zu erwarten wird der Variablentyp von Fixnum auf Bignum und wieder zurück angepasst. Beides sind Integer Werte, die sich lediglich durch den intern belegten Speicherplatz unterscheiden. Interessant wird es beim Teilen einer Integer-Zahl durch eine weitere Integer-Zahl (Zeile 13). Das Ergebnis ist eine Integer-Zahl, also nur der genzzahlige Teil des Bruchs! Wenn man korrekten Wert haben möchte, muss man durch eine Float-Zahl ( Zeile 16) teilen. Das Ergebnis ist dann ebenfalls eine Float-Zahl (mit Kommastellen) Fixnum Fixnum Bignum Fixnum 6172 Fixnum Float [Finished in 0.0s] Pizza on Rails

19 2.6.2 String Wie in allen Programmiersprachen, gibt es auch in Ruby Stringvariablen. Sie werden ganz einfach durch eine Wertzuweisung definiert ( Z.1 / Z.2). Grundsätzlich können dabei doppelte ( ) wie auch einfache (') Anführungszeichen verwendet werden. Der Unterschied liegt darin, dass bei der Verwendung von doppelten Anführungszeichen ein Variable mit #{variable} im String ersetzt wird. Einfache Anführungszeichen lassen eine solche Ersetzung nicht zu. 1 var1 = "Hallo" 2 var2 = 'hallo' 3 ergebnis = var3 = "Das Ergebnis von 9-5 ist #{ergebnis}" 5 puts var3 6 var4 = 'Das Ergebnis von 9-5 ist #{ergebnis}' 7 puts var4 Das Ergebnis von 9-5 ist 4 Das Ergebnis von 9-5 ist #{ergebnis} [Finished in 0.2s] Oft benutzte Methoden der String-Objekte sind 1. Die Verkettung mit + 2. Die Längenermittlung mit.size 3. Umwandlung in Großbuchstaben mit.upcase 4. Umwandlung in Kleinbuchstaben miz.downcase 5. Umkehrung der Buchstabenreihenfolge mit.reverse 6. Die Umwandlung in eine Integer-Zahl mit.to_i 1 var1 = "Hallo" 2 var2 = 'ich bin die zweite Variable' 3 var3 = "100" 4 puts var1.size 5 puts var1.upcase 6 puts var1.downcase 7 puts var2.reverse 8 puts var3.class 9 var4 = var3.to_i 10 puts var4.class 11 puts var4 5 HALLO hallo elbairav etiewz eid nib hci String Fixnum 100 [Finished in 0.0s] Pizza on Rails

20 2.6.3 Boolean Booleans werden als eigenständige Klassen zugewiesen: 1 var1 = false 2 var2 = true 3 p var1.class 4 p var2 5 p var1.class 6 p var2 FalseClass true FalseClass true [Finished in 0.0s] Array Ein Array ist eine Sammlung von Objekten. 1 a = [ 1,2,3,4,5,6,7] 2 p a[0] 3 p a.size 4 a<<8 5 p a.size 6 p a 7 a<<"hallo" 8 p a 9 b = [1,2,3,4,5] 10 a<<b 11 p a [1, 2, 3, 4, 5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8, "Hallo"] [1, 2, 3, 4, 5, 6, 7, 8, "Hallo", [1, 2, 3, 4, 5]] [Finished in 0.0s] In Zeile 1 definieren wir das Array. Auf ein einzelnes Objekt greift man zu, indem man die Objektnummer (bei 0 beginnend) in Klammern angibt (Zeile 2). Die Größe bekommt man mit der.size Methode angezeigt. Ein weiteres Objekt fügt man mit << an. Interessant ist hierbei, dass es sich dabei um alle möglichen Objekte handeln kann ( Z. 7 und Z.9 ) Pizza on Rails

21 2.6.5 Hash Beim Hash handelt es sich um einen Sonderfall eines Arrays. Hier werden Keys und Values innerhalb einer geschweiften Klammer gespeichert. 1 meine_autos = { 'erstes Auto' => 'Simca', 'zweites Auto' => 'Talbot', 'drittes Auto' => 'Peugeot'} 2 p meine_autos['zweites Auto'] "Talbot" [Finished in 0.0s] Symbol Ein Symbol ist wie ein Label zu verstehen, dass auf einen Speicherplatz verweist. Eine Symbolvariable wird oft in Hashes verwendet, sie wird initialisiert, indem man dem Variablennamen einen Doppelpunkt voranstellt. 1 meine_autos = { :erstes_auto => 'Simca', :zweites_auto => 'Talbot', :drittes_auto => 'Peugeot'} 2 p meine_autos[:drittes_auto] "Peugeot" [Finished in 0.0s] Pizza on Rails

22 2.6.7 lokale Variablen Grundsätzlich sollten Variablen lokal verwendet werden. Ihre Sichtbarkeit ist dabei auf den jeweiligen Codeblock beschränkt. 1 class Scope 2 3 def initialize 4 var1 = "Hallo" 5 end 6 7 def zeige_an 8 var1 9 end end sc = Scope.new 14 sc.zeige_an /home/frank/pizzaonrails/variables.rb:8:in `zeige_an': undefined local variable or method `var1' for #<Scope:0x7f40c0d414f0> (NameError) from /home/frank/pizzaonrails/variables.rb:14 [Finished in 0.0s with exit code 1] Die Variable wir außerhalb der Methode initialize nicht mehr gefunden. Gerade zur Vermeidung von Seiteneffekten ein durchaus gewolltes Verhalten! Instanz-Variablen Durch das Voransetzen wird die Variable zur Instanz-Variablen. Ihr Wert ist innerhalb der kompletten Instanz sc sichtbar. 1 class Scope 2 3 def initialize = "Hallo" 5 end 6 7 def zeige_an 8 9 end end sc = Scope.new 14 sc.zeige_an "Hallo" [Finished in 0.0s] Pizza on Rails

23 2.6.9 Class-Variablen Klassen-Variablen sind über die Instanz eines Objekte in allen Objekten einer Klasse sichtbar. Sie werden durch definiert. 1 class Scope 2 3 def initialize = "Hallo" 5 6 end 7 8 def setze_var0 = 0 10 end def zeige_an end def addiere end end 23 sc1 = Scope.new 24 sc1.setze_var0 25 sc1.addiere 26 sc1.zeige_an 27 sc2 = Scope.new 28 sc2.zeige_an 29 sc2.addiere Das Ergebnis: Die in Zeile 24 gesetzte und in Zeile 25 um 1 erhöhte der Instanz sc1 ist auch der Instanz sc2 der Klasse Scope sichtbar. "Hallo" 1 "Hallo" 1 [Finished in 0.0s] Pizza on Rails

24 Globale-Variablen Durch das Voransetzen von $ wird eine Variable zur Globalen-Variablen. Im gesamten Programm sichtbar. 1 class Scope 2 3 def initialize = "Hallo" 5 6 end 7 8 def zeige_an 9 10 p $var0 11 end def addiere 14 $var0=$var end end 19 $var0=0 20 sc1 = Scope.new 21 sc1.zeige_an 22 sc1.addiere 23 sc2 = Scope.new 24 sc2.zeige_an 25 sc2.addiere 26 p $var0 "Hallo" 0 "Hallo" 1 2 [Finished in 0.0s] Pizza on Rails

25 2.7 Schleifen Wie in fast allen Programmiersprachen gibt es natürlich auch in Ruby Schleifen. Die Wichtigsten Schleifen ( Loops ) sind: While / Until Das bekannteste Beispiel ist die while Schleife: 1 i = 0 2 while i < 5 do 3 puts i 4 i=i+1 5 end [Finished in 0.0s] nicht ungewöhnlich ist auch die until-schleife: 1 i = 0 2 until i == 6 do 3 puts i 4 i=i+1 5 end zu Beachten ist der Unterschied zwischen einer Wertzuweisung = und einem Wertevergleich == (Zeile 6) [Finished in 0.0s] Pizza on Rails

26 2.7.2 each Eine interessante Alternative ist der each-operator. Mit ihm kann über Arrays iteriert werden. 1 i = [1,2,3,4,5,6] 2 i.each do v 3 puts v 4 end In Zeile i wird ein Array definiert. Zeile 2 Speichert jedes einzelne Array-Objekt in der Blockvariablen v ( Das Thema Block folgt später) und printed dessen Wert in Zeile 3 an. Besonders reizvoll ist diese Variante bei der Verwendung von SQL-Abfrageergebnissen, über die man damit einfach iterieren kann [Finished in 0.0s] Pizza on Rails

27 2.8 Bedingungen If.. then else Die if.. then Schleife kann in der einfachen Form so aussehen: 1 i = if i == 10 then 4 puts "i = #{i}" 5 end i = 10 [Finished in 0.0s] oder alternativ mit einem else-zweig und / oder elseif versehen werden: 1 i = if i == 10 then 4 puts "i = #{i}" 5 elsif i == 15 6 puts "i == 15" 7 else 8 puts "i <> 10 oder 15" 9 end 10 i <> 10 oder 15 [Finished in 0.0s] Pizza on Rails

28 2.9 Blöcke Blöcke sind eine Besonderheit von Ruby. In dem each Beispiel haben wir den Block schon vorweggenommen. Daher möchte ich ihn hier nochmal diskutieren: 1 i = [1,2,3,4,5,6] 2 i.each do v 3 puts v 4 end In der Zeile 2 wird ein aus einem Iterator gewonnenes Ergebnis über eine sogenannte Blockvariable v an einen Block weitergegeben. Hier können beliebig viele Statements stehen, die den Block dann weiterverarbeiten. Pizza on Rails

29 3 Rails unter der Lupe Ruby on Rails ist ein Framework für die Entwicklung von Webapplikationen. Es wurde von David Heinemeier Hanson entwickelt, um Webapplikationen mit der objektorientierten Sprache Ruby in einer extrem strukturierten Entwicklungsumgebung aufbauen zu können. Um uns dem Framework nähern zu können, schreiben wir zunächst den berühmten Weblog in 15 Minuten. 3.1 Blog in 15 Minuten Um in Rails eine Webapplikation anlegen zu können, bedient man sich zunächst eines Generators. Wir generiern zunächst mit dem Command rails new blog ein Webapplikation mit dem Namen blog. Der rails-generator generiert jetzt eine Reihe von Dateien und Verzeichnissen, die das Ökosystem für die eigentliche Rails-Applikation darstellen. Zunächst wird die Verzeichnisstruktur mit den Systemdateien generiert: $ rails new blog create create README.rdoc create Rakefile create config.ru create.gitignore create Gemfile create app create app/assets/images/rails.png create app/assets/javascripts/application.js create app/assets/stylesheets/application.css create app/controllers/application_controller.rb create app/helpers/application_helper.rb create app/mailers create app/models create app/views/layouts/application.html.erb create app/mailers/.gitkeep create app/models/.gitkeep create config create config/routes.rb create config/application.rb create config/environment.rb create config/environments create config/environments/development.rb create config/environments/production.rb create config/environments/test.rb create config/initializers create config/initializers/backtrace_silencers.rb create config/initializers/inflections.rb create config/initializers/mime_types.rb create config/initializers/secret_token.rb Pizza on Rails

30 create config/initializers/session_store.rb create config/initializers/wrap_parameters.rb create config/locales create config/locales/en.yml create config/boot.rb create config/database.yml create db create db/seeds.rb create doc create doc/readme_for_app create lib create lib/tasks create lib/tasks/.gitkeep create lib/assets create lib/assets/.gitkeep create log create log/.gitkeep create public create public/404.html create public/422.html create public/500.html create public/favicon.ico create public/index.html create public/robots.txt create script create script/rails create test/fixtures create test/fixtures/.gitkeep create test/functional create test/functional/.gitkeep create test/integration create test/integration/.gitkeep create test/unit create test/unit/.gitkeep create test/performance/browsing_test.rb create test/test_helper.rb create tmp/cache create tmp/cache/assets create vendor/assets/javascripts create vendor/assets/javascripts/.gitkeep create vendor/assets/stylesheets create vendor/assets/stylesheets/.gitkeep create vendor/plugins create vendor/plugins/.gitkeep run bundle install Dann werden mit einem sogenannten Bundler die notwendigen Systemblbliotheken des Frameworks dazukopiert: Fetching gem metadata from Fetching gem metadata from Installing rake (10.0.3) Installing i18n (0.6.1) Installing multi_json (1.5.0) Using activesupport (3.2.6). Your bundle is complete! Use `bundle show [gemname]` to see where a bundled gem is installed. Pizza on Rails

31 Jetzt wechseln wir in das Verzeichnis blog und starten mit rails server den Webserver: cd blog rails server => Booting WEBrick => Rails application starting in development on => Call with -d to detach => Ctrl-C to shutdown server SECURITY WARNING: No secret option provided to Rack::Session::Cookie. This poses a security threat. It is strongly recommended that you provide a secret to prevent exploits that may be possible from crafted cookies. This will not be supported in future versions of Rack, and future versions will even invalidate your existing user cookies. Called from: /home/frank/.rvm/gems/ruby p358/gems/actionpack /lib/action_dispatch/middleware/session/abstract_store.rb:28:in `initialize'. [ :57:43] INFO WEBrick [ :57:43] INFO ruby ( ) [x86_64-linux] [ :57:48] INFO WEBrick::HTTPServer#start: pid=5875 port=3000 Das Ergebnis können wir direkt unter der Adresse localhost:3000 im Browser sehen Pizza on Rails

32 Das Grundgerüst steht. Nun müssen wir den Weblog entwickeln. Er soll ganz einfach aus einer Überschrift und einem Textbereich bestehen. Dazu benutzen wir erneut einen Generator namens scaffold: rails generate scaffold weblog titel:string memo:text SECURITY WARNING: No secret option provided to Rack::Session::Cookie. This poses a security threat. It is strongly recommended that you provide a secret to prevent exploits that may be possible from crafted cookies. This will not be supported in future versions of Rack, and future versions will even invalidate your existing user cookies. Called from: /home/frank/.rvm/gems/ruby p358/gems/actionpack /lib/action_dispatch/middleware/session/abstract_store.rb:28:in `initialize'. invoke active_record create db/migrate/ _create_weblogs.rb create app/models/weblog.rb invoke test_unit create test/unit/weblog_test.rb create test/fixtures/weblogs.yml invoke resource_route route resources :weblogs invoke scaffold_controller create app/controllers/weblogs_controller.rb invoke erb create app/views/weblogs create app/views/weblogs/index.html.erb create app/views/weblogs/edit.html.erb create app/views/weblogs/show.html.erb create app/views/weblogs/new.html.erb create app/views/weblogs/_form.html.erb invoke test_unit create test/functional/weblogs_controller_test.rb invoke helper create app/helpers/weblogs_helper.rb invoke test_unit create test/unit/helpers/weblogs_helper_test.rb invoke assets invoke coffee create app/assets/javascripts/weblogs.js.coffee invoke scss create app/assets/stylesheets/weblogs.css.scss invoke scss create app/assets/stylesheets/scaffolds.css.scss Nun müssen wir noch schnell eine Datenbank anlegen: rake db:migrate == CreateWeblogs: migrating ================================================== -- create_table(:weblogs) -> s == CreateWeblogs: migrated (0.0019s) ========================================= Den server erneut starten: $ rails server und fertig ist unsere Applikation Pizza on Rails

33 Nachdem wir die Adresse localhost:3000/weblogs aufgerufen haben, sehen wir: zunächst eine leere Liste. Wenn wir auf new weblog klickt erscheint das Eingabescreen: Pizza on Rails

34 Pizza on Rails

35 Mit create Weblog gelangt man in die sogenannte show-view, in der der erzeugte Datensatz angezeigt wird: Pizza on Rails

36 Und über back in die List-View: Pizza on Rails

37 3.2 Aufbau einer Rails Application Die Rails Komponenten Als nächste beschäftigen wir uns mit dem Aufbau einer Rails-Applikation. Grundsätzlich besteht eine Rails-Application aus Models, Views und Controller. Den Aufbau möchte ich in einer kleinen Graphik darstellen: Pizza on Rails

38 Als Beispiel betrachten wir die Abfrage der Auflistung der Weblog-Anträge unserer gerade geschriebenen Applikation. Über unseren Webbrowser rufen wir die Adresse auf (1). Der Web-Server nimmt die Anfrage entgegen und ermittelt aus der URL der Anfrage und seiner Konfiguration, dass die Anfrage an die Rails-Applikation weblog weitergegeben werden muss. Innerhalb der Applikation ruft er den Router auf (2). Der Router erkennt aufgrund der URL ( /weblogs), dass die Methode (action) index des weblogs _controllers aufgerufen werden muss (3). Der Controller wiederum gibt den find :all Befehl an das Model weiter (4). Im Model ist zum einen die Business-Logik der logischen Objekte definiert, zum Anderen wird über eine Object Reational Mapper (Active-Record) die Verbindung zur Datenbank hergestellt (5). Die Datenbank führt den select * from weblogs Befehl aus und gibt das Ergebnis über das Model in den Controller zurück. Der Controller erkennt an der URL dass er normales HTML an den Anwender zurückgeben soll und gibt das aus der Datenbank kommende Objekt zur Aufbereitung in HTML an die View weiter (6). In der View wird die HTML der Ausgabeseite definiert und an den Web-Server weitergeleitet (7). Der Webserver wiederum gibt die so generierte Webseite an den Browser des Rechners zurück (8). Pizza on Rails

39 3.2.2 Skeletton Betrachten wir nun den physischen Aufbau der Rails-Applikation: blog app... config... config.ru db... doc... Gemfile Gemfile.lock lib... log... public... Rakefile README.rdoc script... test... tmp... vendor assets... plugins Pizza on Rails

40 Die Applikation besteht im groben aus einem app-verzeichnis für die Applikation, sowie diversen Konfigurationsdateien. Als erstes möchte ich einen Blick auf das config-verzeichnis werfen. In diesem Verzeichnis befinden sich die anwendungsspezifischen Konfigurationsdateien: config application.rb boot.rb database.yml environment.rb environments development.rb production.rb test.rb initializers backtrace_silencers.rb inflections.rb mime_types.rb secret_token.rb session_store.rb wrap_parameters.rb locales en.yml routes.rb Wie man sieht besteht die Applikation aus drei Grundkonfigurationen test, development und production. Der Grund dafür ist, dass man hier drei unterschiedliche Datenquellen definieren kann. Eine Test-Umgebung besteht als Datenquelle immer nur temporär. Vor dem Test werden die Daten geladen, nach Testabschluss wieder gelöscht. Die Development-Umgebung ist die übliche Entwicklungsungebung mit einem Datenextrakt, der die typischen Scenarien abdeckt. Die Produktionsumgebung ist die Umgebung in die die Anwendung deployed wird, also die produktive Datenbank. Pizza on Rails

41 Betrachten wir zunächst die Datei database.yml 1 # SQLite version 3.x 2 # gem install sqlite3 3 # 4 # Ensure the SQLite 3 gem is defined in your Gemfile 5 # gem 'sqlite3' 6 development: 7 adapter: sqlite3 8 database: db/development.sqlite3 9 pool: 5 10 timeout: # Warning: The database defined as "test" will be erased and 13 # re-generated from your development database when you run "rake". 14 # Do not set this db to the same as development or production. 15 test: 16 adapter: sqlite3 17 database: db/test.sqlite3 18 pool: 5 19 timeout: production: 22 adapter: sqlite3 23 database: db/production.sqlite3 24 pool: 5 25 timeout: 5000 In den Zeilen 6-10 wird die development-datenbank definiert. Wenn man nichts anderes einträgt, wird hier eine sqlite3-datenbank verwendet. Im produktivem Umfeld steht hier oftmals eine MySql- Datenbank. Zeile definiert die Testdatenbank und Zeile die Produktionsdatenbank. Von Interesse ist hier auch die routes.rb-datei. In ihr definiert man, welche Methode (bie Rails auch action genannt) im jeweiligen Controller von einer URL angesprochen werden soll. Da Rails als oberste Maxime Convention over Configuration hat, genügt ein einziger Eintrag: 1 Blog::Application.routes.draw do 2 resources :weblogs 3 4 # The priority is based upon order of creation: 5 # first created -> highest priority. 6 7 # Sample of regular route: 8 # match 'products/:id' => 'catalog#view' 9 # Keep in mind you can assign values other than :controller and :action 10 Zeile 2 definiert eine Ressource weblogs mit allen standardmäßig zu ihr gehörenden Routen. Genaueres sehen wir im Kapitel Controller. Zunächst können wir es mit diesem kurzen Blick in die Konfigurationsdateien belassen. Pizza on Rails

42 Kommen wir zum eigentlichen Applikations-Verzeichnis app. app assets images rails.png javascripts application.js weblogs.js.coffee stylesheets application.css scaffolds.css.scss weblogs.css.scss controllers application_controller.rb weblogs_controller.rb helpers application_helper.rb weblogs_helper.rb mailers models weblog.rb views layouts application.html.erb weblogs edit.html.erb _form.html.erb index.html.erb new.html.erb show.html.erb Hier finden sich neben den assets, einem Verzeichnis mit applikationsspezifischen Javascript- Dateien, Bildern und CSS-Stylesheets, sowie einem helpers und mailers-verzeichnis die für uns zunächst wichtigen Verzeichnisse controllers, models und views. Pizza on Rails

43 3.2.3 Controller Im controllers-verzeichnis befinden sich alle Controller-Dateien der Applikation. Jedes Objekt, das wir in einer Applikation definieren hat dabei eine eigene Controller-Datei. Im Folgenden möchte ich einen Blick auf die Controller-Datei des Weblogs-Objekt werfen. 1 class WeblogsController < ApplicationController 2 # GET /weblogs 3 # GET /weblogs.json 4 def index = Weblog.all 6 7 respond_to do format 8 format.html # index.html.erb 9 format.json { render :json } 10 end 11 end # GET /weblogs/1 14 # GET /weblogs/1.json 15 def show = Weblog.find(params[:id]) respond_to do format 19 format.html # show.html.erb 20 format.json { render :json } 21 end 22 end # GET /weblogs/new 25 # GET /weblogs/new.json 26 def new = Weblog.new respond_to do format 30 format.html # new.html.erb 31 format.json { render :json } 32 end 33 end # GET /weblogs/1/edit 36 def edit = Weblog.find(params[:id]) 38 end # POST /weblogs 41 # POST /weblogs.json 42 def create = Weblog.new(params[:weblog]) respond_to do format format.html { :notice => 'Weblog was successfully created.' } 48 format.json { render :json :status => :created, :location } 49 else Pizza on Rails

44 50 format.html { render :action => "new" } 51 format.json { render :json :status => :unprocessable_entity } 52 end 53 end 54 end # PUT /weblogs/1 57 # PUT /weblogs/1.json 58 def update = Weblog.find(params[:id]) respond_to do format format.html { :notice => 'Weblog was successfully updated.' } 64 format.json { head :no_content } 65 else 66 format.html { render :action => "edit" } 67 format.json { render :json :status => :unprocessable_entity } 68 end 69 end 70 end # DELETE /weblogs/1 73 # DELETE /weblogs/1.json 74 def destroy = Weblog.find(params[:id]) respond_to do format 79 format.html { redirect_to weblogs_url } 80 format.json { head :no_content } 81 end 82 end 83 end Wir untersuchen nun einzelne Statements. In Zeile 1 wird die Klasse WeblogsController als Childklasse der Klasse ApplikationController definiert. 1 class WeblogsController < ApplicationController Sehen wir uns nun die ebenfalls im Verzeichnis controllers stehende Datei application_controller.rb an: 1 class ApplicationController < ActionController::Base 2 protect_from_forgery 3 end Hier wird in der Zeile 1 der ApplicationController als Childklasse der Klasse ActionController definert, Wenn man weiß dass der ActionController Teil des Rails-Frameworks ist, dann ist klar wie das Framework mit den Klassen verbunden wird die Klassen erben jeweils von einer Frameworkklasse alle relevanten Methoden. Pizza on Rails

45 Die erste wichtige Methode der Weblogs-Klasse ist die Methode index. 4 def index = Weblog.all 6 7 respond_to do format 8 format.html # index.html.erb 9 format.json { render :json } 10 end 11 end Neben dem üblichen def...end in Zeile 4 und 11 wird in Zeile 5 der der wert von Weblog.all zugewiesen. Hinter Weblog.all steht der Aufruf des Models Weblog ( wird noch nachfolgend erklärt) mit der Kurzform des find_all Befehls. Dieser Befehl ist wiederum Teil des ActiveRecord Frameworks von Rails und kapselt den folgenden SQL-Befehl: SELECT "weblogs".* FROM "weblogs" Neben diesem find_all gibt es noch eine Vielzahl von Findern, die alle möglichen Select-Befehle einer Datenbank kapseln. Warum macht man das? Zum einen umgeht man damit Eigenarten der Datenbanken. Wenn ein Framework universell sein will, muss es auch mit allen möglichen Datenbanken kommunizieren können. Das sind zum einen natürlich SQL-Datenbanken, zum anderen die neueren objektorientierten non-sql-datenbanken wir CouchDB... Zum anderen verbirgt sich hinter ActiveRecord ein sogenannter Object Relaational Mapper. Objektorientiert betrachtet ist ja jede Zeile der Weblogs-Tabelle ein Weblogs-Objekt, dass man dann mit objektspezifischen Mathoden ansprechen kann. Diese Objekte werden als Models definiert. Das Ergebnis wird wie gesagt in die geschriebenen. In Zeile 7-9 wird je nach der mitgegebenen URL die Ausgabe im Format html an die entsprechende View weitergegeben oder als.json File für Webservices ausgegeben. Die Methode index wird mit der URL aufgerufen, Pizza on Rails

46 In Zeile wird die Metode show definiert, Sie wird über die URL aufgerufen, wobei 1 den ersten Datensatz spezifiziert. Man gelangt zu der URL, indem man in der Index View beispielsweise im 1, Datensatz auf den show-link drückt. 15 def show = Weblog.find(params[:id]) respond_to do format 19 format.html # show.html.erb 20 format.json { render :json } 21 end 22 end In Zeile 15 wird wieder Finder auf das Weblog-Model aufgerufen, diesmal wir ihm der in der URL mitgegebene Parameter und die zu durchsuchende Spalte id mitgegeben. Wie bei relationalen Datenbanken üblich besitzt jede Zeile der Tabelle Weblogs eine id-spate mit einer eindeutigen Integer-Zahl. Der aus dem Finder resultierende SQL-Befehl lautet: SELECT "weblogs".* FROM "weblogs" WHERE "weblogs"."id" =? LIMIT 1 [["id", "1"]] Das Ergebnis wird wieder in der gespeichert und in den Zeilen an je nach gewünschtem Tüp gerendert. Wenn in der URL nichts angegebenen ist, wird html angenommen. Gibt man aber beispielsweise die folgende URL an: resultiert daraus der folgende, von anderen Applikation weiterverarbeitbare Datenstrom im JSON- Format: {"updated_at":" t16:15:22z","memo":"rails ist gar nicht schwer!","created_at":" t16:15:22z","titel":"mein erster Blogeintrag","id":1} Ein neuer Eintrag wird über die Methode new initiiert: 26 def new = Weblog.new respond_to do format 30 format.html # new.html.erb 31 format.json { render :json } 32 end 33 end Hier wird Einfach mit Weblog.new ein neuer Datensatz angelegt und über die new.html.erb-view mit Daten gefüllt (Weiteres dazu in der View-Beschreibung). Damit wird aber lediglich die new-view zur Eingabe der Daten aufgerufen. Das Schreiben des neuen Datensatzes in die Datenbank geschieht später in der create-methode. Pizza on Rails

47 42 def create = Weblog.new(params[:weblog]) respond_to do format format.html { :notice => 'Weblog was successfully created.' } 48 format.json { render :json :status => :created, :location } 49 else 50 format.html { render :action => "new" } 51 format.json { render :json :status => :unprocessable_entity } 52 end 53 end 54 end Die wird nun mit dem aus der new-view zurückgegebenen :weblog-objekt bestückt. Entsprechend des Ergebnisses des im Framework automatisch durchgeführten save- Befehls auf die Datenbank wird im Erfolgsfall (Zeile 47, 48) entweder als html-message 'Weblog was successfully created.' oder in JSON der Status created zurückgeben. Die URL ist: der von ActiveRecord erzeugte SQL-BEfehl: INSERT INTO "weblogs" ("created_at", "memo", "titel", "updated_at") VALUES (?,?,?,?) [["created_at", Mon, 14 Jan :23:52 UTC +00:00], ["memo", "mein zweiter Blogeintrag"], ["titel", "zweiter Blog"], ["updated_at", Mon, 14 Jan :23:52 UTC +00:00]] Um einen bestehenden Eintrag zu editieren, wird analog der Neuanlage zunächst die edit-methode und dann aus der edit-view die update-methode aufgerufen. Sehen wir uns zunächst die edit-methode an: 36 def edit = Weblog.find(params[:id]) 38 end Ähnlich der show-methode wird ein Eintrag anhand seiner :id gesucht und in der gespeichert. Der Inhalt wird an die korrespondierende View weitergegeben und dann in der update-methode gehandelt: Pizza on Rails

48 58 def update = Weblog.find(params[:id]) respond_to do format format.html { :notice => 'Weblog was successfully updated.' } 64 format.json { head :no_content } 65 else 66 format.html { render :action => "edit" } 67 format.json { render :json :status => :unprocessable_entity } 68 end 69 end 70 end Auch hier sind die Mechanismen bekannt. Man sucht in Zeile 59 wieder das Weblog über die id, um ihn dann mit den im :weblog übergebenen Objekt zu überschreiben (Zeile 62). Gelingt dies so wird 'Weblog was successfully updated.' zurückgeben. Funktioniert das Schreiben des Datensatzes nicht, wird automatisch wieder in die edit-view zurückgeben. Aufgerufen wird edit mit: Die resultierende SQL lautet: SELECT "weblogs".* FROM "weblogs" WHERE "weblogs"."id" =? LIMIT 1 [["id", "1"]] Nach Abschluß der Eingaben folgt: UPDATE "weblogs" SET "memo" = 'Rails ist gar nicht so schwer!', "updated_at" = ' :22: ' WHERE "weblogs"."id" = 1 Pizza on Rails

49 Bleibt letztlich noch die delete-action. Das Framework gibt zunächst nach anklicken des Links eine Sicherheitsabfrage aus, um dann zu der destroy-action weiterzuleiten. 74 def destroy = Weblog.find(params[:id]) respond_to do format 79 format.html { redirect_to weblogs_url } 80 format.json { head :no_content } 81 end 82 end In Zeile 75 wird mit dem über die :id gefundenen Objekt gefüllt. In Zeile 76 wird dann der eigentliche derstroy durchgeführt. Bleibt letztlich noch die delete-action. DELETE FROM "weblogs" WHERE "weblogs"."id" =? [["id", 2]] Die genannten Aktionen nennt man entsprechend den Methoden Create, Read, Update, Delete auch CRUD-Aktionen. Die Notation der URL entspricht dem sogenannten REST (Representational Stateless Transfer) Standard. Da die Rails Applikationen JSON-Objekte zurückgeben können, kann man mit ihnen einfach über Webservices mit anderen Web-Applikationen kommunizieren. Pizza on Rails

50 3.2.4 Model Das Model bildet zum einen die Schnittstelle zur Datenbank, denn als Objekt gesehen wird es auf der Datenbank gespeichert (persistiert), zum anderen beinhaltet es die gesamte Business-Logik der Applikation, In unserem Beispiel ist davon wenig zu sehen, da wir außer dem Weblog-Model kein weiteres Model in unserer Anwendung vorgesehen haben. Daher besteht die Datel weblog.rb im models-verzeichnis nur aus wenigen Zeilen: 1 class Weblog < ActiveRecord::Base 2 attr_accessible :memo, :titel 3 end In Zeile 1 verbindet sich das Model mit dem ActiveRecord aus dem Rails Framework. Hierüber erbt es alle datenbankspezifischen Methoden, wie z.b. die Finder, update und destroy In Zeile 2 werden die Attribute :memo und :titel von aussen zugreifbar gemacht. Obwohl das Model hier unscheinbar daherkommt, beinhaltet es die Fähigkeit, Datenbanksätze als Objekte umgewandelt zu bekommen. Per Definition mappt das Model Weblog die Datrenbanktabelle Weblogs. Pizza on Rails

51 3.2.5 View Die Views sind für die Generierung der HTML an den Browser zuständig. Da es sich dabei um html-files mit sogenanntem embedded Ruby handelt werden sie als.html.erb abgekürzt. HTML-Grundkenntnisse werden hier zwar vorausgesetzt, werden jedoch im Folgenden auch schnell erworben. Index-View Sehen wir uns zunächst die Index-View an: 1 <h1>listing weblogs</h1> 2 3 <table> 4 <tr> 5 <th>titel</th> 6 <th>memo</th> 7 <th></th> 8 <th></th> 9 <th></th> 10 </ tr> do weblog %> 13 <tr> 14 <td><%= weblog.titel %></td> 15 <td><%= weblog.memo %></td> 16 <td><%= link_to 'Show', weblog %></td> 17 <td><%= link_to 'Edit', edit_weblog_path(weblog) %></td> 18 <td><%= link_to 'Destroy', weblog, :method => :delete, :data => { :confirm => 'Are you sure?' } %></ td> 19 </ tr> 20 <% end %> 21 </ table> <br /> <%= link_to 'New Weblog', new_weblog_path %> In Zeile 1 wird mit <h1>...</h1> die Übetrschrift definiert. Darauf folgt von Zeile 3 bis Zeile 21 mit <table>...></table> die Definition einer Tabelle. Die Tabellenköpfe werden in der ersten Tabellenreihe <tr>..</tr> in den Zeilen 5 und 6 in den Tags <th>...</th> definiert. Die eigentliche Rails Magie entsteht in den Zeilen 12 bis 20. Wir erinnern uns: Die Index View wurde aufgerufen, nachdem der Controller in der Methode index über einen Finder alle Weblog- Einträge in die geschrieben hat. Um einen Ruby-Befehl in html.erb einzufügen, muss man ihn in <% %> setzen. Wir setzen zunächst einen each.iterator über aus dem Controller und speichern jedes gefundene Objekt in der Blockvariablen weblog ab ( Zeile 12). In dem in Zeile 20 abgeschlossenen Bock werden jetzt in einer neuen html-zeile <tr>...</tr> (Zeile 13 bis 19) mit dem Tag <td>...</td> jeweils als Spalteneinträge der Titel und die Memo des weblog-objekts ausgegeben. Da hier jeweils ein Ergebnis aus Ruby ausgegeben wird werden die Statements mit <%=. %> gekapselt. Pizza on Rails

52 In Zeile 16 wird ein Link zur Show-Methode des Controllers mit der Übergabe des aktuellen weblog-objekts definiert. Die Zeilen 17 und 18 definieren die Edit und Destroy-Links zum Controller. Dieser Block wird bis zum Ende aller gespeicherten Objekte durchgeführt. Schlussendlich wird in Zeile 25 noch der Link zur new-action für den Controller definiert, Edit-View Der nächste Blick gilt der Edit-View. Sie ist erstaunlich kurz: 1 <h1>editing weblog</h1> 2 3 <%= render 'form' %> 4 5 <%= link_to %> 6 <%= link_to 'Back', weblogs_path %> In Zeile 1 steht die Überschrift, die Zeile5 und 6 setzen die Links zur Show Action des Controllers und Zeile 6 führt zurück zur aufrufrnden View. Hier steckt die Magie in Zeile 3. Mit dem Befehl render 'form' wird ein sogenanntes Partial mit dem Namen _form.html.erb aufgerufen. 1 <%= form_for(@weblog) do f %> 2 <% %> 3 <div id="error_explanation"> 4 <h2><%= pluralize(@weblog.errors.count, "error") %> prohibited this weblog from being saved:</ h2> 5 6 <ul> 7 do msg %> 8 <li><%= msg %></li> 9 <% end %> 10 </ ul> 11 </ div> 12 <% end %> <div class="field"> 15 <%= f.label :titel %><br /> 16 <%= f.text_field :titel %> 17 </ div> 18 <div class="field"> 19 <%= f.label :memo %><br /> 20 <%= f.text_area :memo %> 21 </ div> 22 <div class="actions"> 23 <%= f.submit %> 24 </ div> 25 <% end %> In der Zeile 1 wird ein Form-Objekt definier und der Blockvariablen f zugewiesen. Auf dieses Objekt werden dann alle HTML-Methoden angewendet. Sollte es im Verlauf der Action zu Fehlern kommen, werden diese in der <div id= error_explanation>...</div> ausgegeben. Die <div>s vin Zeile 14 bis 20 geben die Felder Titel mit einem Label aus. In den Zeilen wird die <div class= actions > mit dem Submit- Button definiert. Die class= Bezeichnungen verweisen auf Klassen in den css-files. Dort werden dann die Textauszeichnungen wie Farbe, Font, Größe etc beschrieben. Mit der Partial- Definition haben wir ein einfaches Grundgerüst für die folgende View geschrieben. Pizza on Rails