Produktiv programmieren

Wer seine Brötchen mit Software-Entwicklung verdient, braucht Strategien, um besser, schneller und kostengünstiger zu programmieren. Dieses Buch bietet Ihnen erprobte Hilfsmittel, die Zeit sparen, Ihre Produktivität erhöhen, und die Sie unabhängig von der verwendeten Plattform auf der Stelle nutzen können. Meister-Programmierer Neal Ford vermittelt nicht nur Einsichten in die Mechanismen der Produktivität, sondern gibt darüber hinaus zahlreiche wertvolle Praxistipps, die helfen, Ihren Code zu verbessern und verbreitete Fallen zu umgehen.

Erfahren Sie, wie Sie * erst die Tests und dann den zugehörigen Code schreiben, * den Lebenszyklus Ihrer Objekte präzise planen, * sich auf die Implementierung der aktuellen Anforderungen beschränken, * antike Philosophie auf die Software-Entwicklung übertragen, * Autoritäten infrage stellen und nicht blind Standards folgen, * durch Metaprogrammierung schwierige Dinge einfacher und unmögliche Dinge möglich machen, * auf ein einheitliches Abstraktionsniveau innerhalb von Methoden achten, * den richtigen Editor und die besten Hilfsmittel für Ihre Arbeit auswählen.

Was Sie hier lesen, ist keine trockene Theorie, sondern die Essenz aus Neal Fords langjähriger Erfahrung als IT-Consultant. Egal, ob Sie Einsteiger oder Profi sind – die einfachen und gradlinigen Prinzipien, die dieses Buch vermittelt, werden Ihnen zu spürbar besseren Arbeitsergebnissen verhelfen.

Neal Ford arbeitet als Anwendungsarchitekt bei ThoughtWorks, einem globalen IT-Consulting-Unternehmen. Sein Beratungsschwerpunkt liegt auf dem Entwurf und der Umsetzung von Enterprise-Applikationen, außerdem führt er Schulungen bei Großunternehmen im In- und Ausland durch.

Rails in a Nutshell

Rails in a Nutshell vom OReilly Verlag ist momentan frei als Online-Version verfügbar. Die Nutshell-Reihe behandelt i.d.R. Themen in einem sehr kurzen und knappen Umfang und konzentriert sich auf das Wesentliche. Daher werden diese Bücher gerne als Nachschlagewerke benutzt.

Die Autoren von Rails in a Nutshell sind Cody Fauser, James MacAulay, Edward Ocampo-Gooding und John Guenin. Das Buch geht auf die verschiedensten Bereiche von Rails ein und viele werden es sicher begrüßen ein solch kompaktes Werk zur Hnd zu haben.

Die gedruckte Version wird voraussichtlich Anfang 2010 erscheinen und soll die kommende Rails-Version 3.0 abdecken.

Auf den Seitenvon OReilly könnt ihr euch selber ein Bild von dem Buch machen: http://rails-nutshell.labs.oreilly.com/

Viel Spaß bei der Lektüre.

Enterprise Recipes with Ruby and Rails

„Enterprise Recipes with Ruby and Rails“ helps you to overcome typical obstacles hidden in every enterprise’s infrastructure. It doesn’t matter if your Rails application needs to access your company’s message-oriented middle ware or if it has to scan through tons of huge XML documents to get a missing piece of data. Ruby and Rails enable you to create solutions that are both elegant and efficient. With more than 50 concise, targeted recipes, this book shows you how to use existing infrastructure to develop effectively for the enterprise. For example, Ruby is an excellent language for manipulating both textual and binary data. This is enormously useful, because typical enterprise software is about storing and processing huge amounts of data. You’ll learn how to process data in various popular data formats such as XML, CSV, fixed length records, and JSON.This book covers the whole spectrum of distributed application technologies, ranging from simple socket-based servers to full-blown Service Oriented Architectures. In addition, Ruby is a perfect ally when you have to integrate with RESTful and SOAP services, or when you have to access message-oriented middle ware. It even helps you to reuse your existing C/C++, Java, or .NET code with ease.

Since the advent of the Web, many enterprises have opened their internal services to the outside world to participate in the rapidly growing world of e-commerce.As an enterprise programmer you’d better learn how to use existing payment gateways and how to implement security mechanisms to protect your company’s data and your customers‘ privacy, and this book shows you how. Enterprise programming is not only about developing huge software projects but also about maintaining and operating them. You’ll save a lot of valuable time if you document your software (of course, automatically) and automate tedious and recurring tasks, such as monitoring your servers and testing your programs. „Enterprise Recipes with Ruby and Rails“ covers these major enterprise concerns, giving you tools and knowledge you’ll turn to over and over.

Synopsis
„Enterprise Recipes with Ruby and Rails“ helps you to overcome typical obstacles hidden in every enterprise’s infrastructure. It doesn’t matter if your Rails application needs to access your company’s message-oriented middle ware or if it has to scan through tons of huge XML documents to get a missing piece of data. Ruby and Rails enable you to create solutions that are both elegant and efficient. With more than 50 concise, targeted recipes, this book shows you how to use existing infrastructure to develop effectively for the enterprise. For example, Ruby is an excellent language for manipulating both textual and binary data. This is enormously useful, because typical enterprise software is about storing and processing huge amounts of data. You’ll learn how to process data in various popular data formats such as XML, CSV, fixed length records, and JSON.This book covers the whole spectrum of distributed application technologies, ranging from simple socket-based servers to full-blown Service Oriented Architectures. In addition, Ruby is a perfect ally when you have to integrate with RESTful and SOAP services, or when you have to access message-oriented middle ware.

It even helps you to reuse your existing C/C++, Java, or .NET code with ease. Since the advent of the Web, many enterprises have opened their internal services to the outside world to participate in the rapidly growing world of e-commerce.As an enterprise programmer you’d better learn how to use existing payment gateways and how to implement security mechanisms to protect your company’s data and your customers‘ privacy, and this book shows you how. Enterprise programming is not only about developing huge software projects but also about maintaining and operating them. You’ll save a lot of valuable time if you document your software (of course, automatically) and automate tedious and recurring tasks, such as monitoring your servers and testing your programs. „Enterprise Recipes with Ruby and Rails“ covers these major enterprise concerns, giving you tools and knowledge you’ll turn to over and over.

Alle Produktbeschreibungen

  • Taschenbuch: 425 Seiten
  • Verlag: (2008-12-05 )
  • Preis: 22.15 €
  • Sprache: german
  • ISBN-10: 1934356239
  • Autor(en): Maik Schmidt
  • kaufen

Ruby on Rails für JEE-Experten. Umfassender Einstieg in Rails und JEE-Integration mit JRuby

LECKERBISSEN FÜR JEE-ENTWICKLER
– Topaktuell: Basiert auf Rails 2.1
– Lernen Sie die Vorzüge von Ruby on Rails kennen und erfahren Sie, wie Sie Ihre JEE-Anwendungen mit JRuby integrieren können.
– Verfolgen Sie, wie der Onlineshop briefcasten.com in 7 Iterationen entsteht, und erfahren Sie live, wie Rails und JRuby funktionieren.
-Kostenloser Download für alle Käufer des Buches:
Alle Quellcodes des Buches unter pastie.org
Screencasts zu den Iterationen des Onlineshops unter briefcasten.com

Sie sind JEE-Entwickler und haben schon von dem sagenhaften Webframework Ruby on Rails und den vielen Web 2.0-Projekten, die damit umgesetzt werden, gehört? Sie wollen wissen, was es damit wirklich auf sich hat und wie Sie Ihre Java-Enterprise-Anwendungen um Rails-Anwendungen ergänzen können? Oder vielleicht sogar ganz umsteigen? Dann sind Sie hier genau richtig!
Dieses Praxisbuch von Michael Johann ist ein Standardwerk für die professionelle Anwendungsentwicklung mit Ruby on Rails ab Version 2.1. Es wendet sich gezielt an JEE-Entwickler und setzt Java-Wissen voraus. Die Konzepte von Rails und die Unterschiede zu Java EE lernen Sie anhand zahlreicher Beispiele detailliert kennen. Sie erfahren auch, wie sich Rails-Anwendungen dank JRuby in die Java-Enterprise-Welt integrieren lassen.
An einem realistischen Projekt in 7 Iterationen zeigt der Autor, wie ein komplette Web-Seite mit Shop und Abrechnungsschnittstelle zu Paypal entsteht. Zu jeder Iteration gibt es einen Screencast, auf den Sie als Besitzer dieses Buches kostenlosen Zugriff haben, um sich das Wissen noch effektiver und schneller anzueignen.
Aus dem Inhalt: Einführung in Ruby on Rails – Einführungs-Tutorial: Newsfeed-Verwaltung – Testgetriebene Entwicklung – Ruby: Das Wichtigste – Versionskontrolle – JRuby – Projekt: briefcasten.com – Internationalisierung und Lokalisierung

Über den Autor
Dipl.-Ing. (FH) Michael Johann ist als Gründer und ehemaliger Chefredakteur des Magazins JavaSpektrum sowie als Autor und Konferenzsprecher weit über die Grenzen Europas hinaus bekannt geworden. Nach der Unterstützung zahlreicher JEE Projekte war er Mitgründer der CARNOT AG und widmete sich dem Thema Business Process Development. Seit 2003 konzentriert er sein Know How auf die Neuentwicklungen Web und ist seit 2006 begeistert von Ruby on Rails. Heute bietet er Unternehmen Trainings und Beratung an und entwickelt Konferenzinhalte und hält Vorträge zum Thema dynamische Sprachen und Ruby on Rails.

  • Taschenbuch: 487 Seiten
  • Verlag: (2008-10-01 )
  • Preis: 49.90 €
  • Sprache: german
  • ISBN-10: 3446415351
  • Autor(en): Michael Johann
  • kaufen

RedCloth Cookbook

Um in Ruby/Rails-Apllikationen Textile für Texteingaben zu nutzen kommt häufig das GEM RedCloth zum Einsatz. Textile ist eine Beschreibungssprache die oft in Wikis benutzt wird, um Autoren nicht HTML für die Formatierung abzuverlangen.

Um Textile auch für seine eigene Applikation zu nutzen ist RedCloth eins der meist verbreiteten GEMs.

Gerald Bauer hat in seinem Blog ein kleines Cookbook erstellt, in dem er beschreibt wie man das GEM verwendet:

http://rubybook.ca/2008/08/16/redcloth/

Neben dem Tutorial listet er ein paar Links auf, unter denen man ggf. mehr Informationen zu RedCloth bekommt.

Scaffolding (Teil 3)

Scaffolding-Code generieren:

Codegenerierung ist die andere wichtige Form des Scaffolding. Sie generieren das Scaffolding mit dem Befehl ruby script/generate scaffold.

Führen Sie es ohne Parameter aus, um eine Beschreibung des Generators und die von ihm verwendeten Parameter zu erhalten:

> ruby script/generate scaffold
Usage: script/generate scaffold ModelName [ControllerName] [action, …]

General Options:
    -p, –pretend        Run but do not make any changes.

    -f, –force          Overwrite files that already exist.
    -s, –skip           Skip files that already exist.

    -q, –quiet          Suppress normal output.
    -t, –backtrace      Debugging: show backtrace on errors.

    -h, –help           Show this help message.
    -c, –svn            Modify files with subversion. (Note: svn must be in path)

Description:
    The scaffold generator creates a controller to interact with a model.

Sie müssen den Namen eines Modells und eines Controllers angeben. Um also das Scaffolding für den Controller und die Views unseres Photo-Modells zu generieren, müssen Sie Folgendes eingeben:

ruby script/generate scaffold photo photos

Antworten Sie mit y, wenn Sie von Rails gefragt werden, ob Dateien ersetzt werden sollen. Wenn Sie den Namen des Controllers weglassen, verwendet Rails den englischen Plural des Modellnamens. Um also das Scaffolding für slides, slideshows und categories zu generieren, geben Sie Folgendes ein:

ruby script/generate scaffold slide
ruby script/generate scaffold slideshow

ruby script/generate scaffold category

Warum Scaffolding Controller-Namen pluralisiert

Wenn Sie das Scaffolding wie folgt ausführen:

ruby script/generate scaffold Photo

erhalten Sie ein Modell namens Photo und einen Controller namens PhotosController. Sie bekommen dieses Verhalten, weil der Scaffolding-Generator zwei Parameter verlangt: das Modell und den Controller. Lassen Sie den Controller weg, pluralisiert der Generator den Namen. Oft ist das genau das, was Sie wollen, weil Rails-Controller häufig mit Kollektionen von Dingen umgehen.

Üblicherweise wollen Sie einen singulären Modellnamen. Zum Beispiel könnten Sie einen Administrations-Controller namens Admin benötigen. Wenn Sie normalerweise mit Pluralformen arbeiten, können Sie den Namen des Controllers weglassen. Wünschen Sie einen Controllernamen im Singular, müssen Sie sowohl den Modell- als auch den Controller-Namen angeben. Weitere Informationen erhalten Sie über die Scaffolding-Hilfe, wenn Sie Folgendes eingeben:

ruby script/generate scaffold

Der generierte Code

Sehen wir uns den von Rails erzeugten Controller an. Ihr Code könnte etwas anders aussehen als der hier abgebildete, das Prinzip sollte aber das gleiche sein. Öffnen Sie apps/controllers/photos_controller.rb:

class PhotosController < ApplicationController

  def index
    list
    render :action => ‚list‘

  end
  def list

    @photo_pages, @photos = paginate :photos, :per_page => 10

  end
  def show
    @photo = Photo.find(params[:id])

  end

  def new
    @photo = Photo.new

  end
  def create

    @photo = Photo.new(params[:photo])

    if @photo.save
      flash[:notice] = ‚Photo angelegt.‘

      redirect_to :action => ‚list‘
    else
      render :action => ’new‘

    end
  end
  def edit

    @photo = Photo.find(params[:id])
  end
  def update
    @photo = Photo.find(params[:id])
    if @photo.update_attributes(params[:photo])

      flash[:notice] = ‚Photo aktualisiert.‘
      redirect_to :action => ’show‘, :id => @photo

    else
      render :action => ‚edit‘
    end

  end
  def destroy

    Photo.find(params[:id]).destroy

    redirect_to :action => ‚list‘
  end
end

Wie Sie sehen, generiert Rails einen Controller für jede Methode aus Tabelle 4-1. Gehen Sie mit Ihrem Browser auf http://localhost:3000/photos und überprüfen Sie, dass der generierte Code sich genauso verhält wie der durch die scaffold :photo-Methode generierte Code.

Dennoch weicht der Code leicht ab. Statt die Views innerhalb des Controllers zu generieren, wie das die scaffold-Methode tut, enthält der Code explizit gerenderte Views in rhtml-Code. Sehen wir uns einen dieser Views an. Öffnen Sie app/views/photos/list.rhtml:

1 <% for column in Photo.content_columns %>

2 <p>

3   <b><%= column.human_name %>:</b> <%=h @photo.send(column.name) %>

4 </p>
5 <% end %>
6
7 <%= link_to ‚Bearbeiten‘, :action => ‚edit‘, :id => @photo %> |

8 <%= link_to ‚Zur&uuml;ck‘, :action => ‚list‘ %>

Dieser View wurde von der list-Methode von PhotosController erzeugt. Sehen wir uns die erste und dritte Zeile genauer an:

<% for column in Photo.content_columns %>
In der ersten Zeile geht der View jede Spalte der Datenbank durch. Vergessen Sie nicht, dass Active Record Metadaten in Photo eingefügt hat, das auch ein Array mit jeder Spalte der Tabelle umfasst. content_columns enthält alle Spalten, die für die öffentliche Ausgabe vorgesehen sind. (Sie sehen beispielsweise weder Fremdschlüssel noch die id.)

<b><%= column.human_name %>
Der View enthält einen freundlichen Namen, der als Label für das Element dient.
<%=h @photo.send(column.name) %>
Der View sendet eine Nachricht mit dem Namen der Spalte an @photo und rendert das Ergebnis. (Zum Beispiel wäre @photo.send „filename“ identisch mit @photo.filename.)

Abbildung 4-5 zeigt das Ergebnis. Der View führt alle Eigenschaften eines Photo-Datensatzes in der Datenbank auf. Die Dateinamen-Eigenschaft war von Anfang an in der Datenbank enthalten. Die Eigenschaften Erzeugt am, Thumbnail und Beschreibung wurden bereits in diesem Kapitel mit Hilfe einer Migration eingefügt. Würden wir weitere Eigenschaften hinzufügen, müssten wir im list.rhtml-View keinerlei Änderungen vornehmen, um sie mit auszugeben.

Abbildung 4-5
Dieser show-View ist dynamisch

Der show.rhtml-View spiegelt Änderungen in der Datenbank wider. Sehen wir uns nun einen View an, der etwas weniger dynamisch ist. Öffnen Sie app/views/photos/_form. rhtml:

<%= error_messages_for ‚photo‘ %>
<!–[form:photo]–>

<p><label for=“photo_created_at“>Erzeugt am</label><br/>
<%= datetime_select ‚photo‘, ‚created_at‚  %></p>

<p><label for=“photo_filename“>Dateiname</label><br/>
<%= text_field ‚photo‘, ‚filename‘  %></p>

<p><label for=“photo_thumbnail“>Thumbnail</label><br/>
<%= text_field ‚photo‘, ‚thumbnail‚  %></p>

<p><label for=“photo_description“>Beschreibung</label><br/>
<%= text_field ‚photo‘, ‚description‘  %></p>

<!–[eoform:photo]–>

Dies ist ein so genannter partieller View, und er ist für die Ausgabe eines Formulars für ein Photo in edit.rhtml und new.rhtml verantwortlich. (Sie erfahren im nächsten Kapitel mehr über partielle Views.) Die fett gedruckten Wörter sind Attribute von Photo. Weil wir zur Ausgabe des Formulars expliziten Code generiert haben, funktioniert dieser View nur mit Datenbankspalten, die bereits vorhanden waren, als wir das Scaffolding generiert haben. Hier sehen Sie einen der primären Unterschiede zwischen Scaffolding mittels Metaprogrammierung und codegeneriertem Scaffolding. Wenn Sie mit Metaprogrammierung arbeiten, spiegelt das Scaffolding Änderungen in der Datenbank wider, weil unsere scaffold :photo-Methode den Code zur Laufzeit generiert. Mit dem generierten Code erhalten wir durch das Scaffolding einen einmaligen Vorteil, müssen ihn nachfolgend aber auch pflegen.

Das Beste beider Welten

Die meisten Rails-Entwickler nutzen beide Arten des Scaffolding. Die scaffold-Methode ist hilfreich, wenn sich Ihre Active Record-Modelle schnell ändern, weil sie Änderungen an der Datenbank in der Benutzerschnittstelle wiedergibt. Später können Sie das Scaffolding nutzen und Controller und Benutzerschnittstellen mit der Zeit weiter ausbauen, wobei Sie den generierten Code als Grundlage verwenden. Die Kombination dieser beiden Techniken ist eine äußerst leistungsstarke Vorgehensweise.

Scaffolding hat aber auch seine Grenzen. Sie erhalten für jeden Zweck ein und dieselbe Benutzerschnittstelle und einen Controller. Dieser ist nicht für jeden Zweck geeignet und auch nicht vollständig. Eine der größten Schwächen des Scaffolding ist das fehlende Beziehungsmanagement. Das Scaffolding berücksichtigt bei der Codegenerierung keine Beziehungen im existierenden Modell.

Was kommt jetzt?

In diesem Kapitel haben wir Scaffolding für eine einfache Benutzerschnittstelle generiert. Aber der Scaffolding-Code hat seine Grenzen. Er berücksichtigt keine Beziehungen, d.h. Sie können die mit einer Kategorie verknüpften Photos weder sehen noch editieren, ebenso wenig die Dias in einer Diashow. Die Views sind darüber hinaus hässlich und unvollständig. Im nächsten Kapitel wollen wir diesen Problemen abhelfen. Wir verwenden das generierte Scaffolding als Basis und bauen eine umfassendere Benutzerschnittstelle auf. Photo Share entwickelt sich schnell, und so geht es auch weiter.

1Wenn Sie nicht mit uns zusammen codiert haben, nun aber damit anfangen wollen, können Sie sich den Code bis Kapitel 3 von der Webseite zum Buch (http://www.oreilly.com/catalog/rubyrails) herunterladen.

2Sie finden die eigentliche Definition im Rails-Quellcode. scaffold ist tatsächlich in ClassMethods definiert und wird als Modul in ActionController eingebunden.

Dieses Tutorial stammt aus dem Buch „Durchstarten mit Rails“ aus dem O’Reilly Verlag.
Details zu dem Buch

Alle drei Teile dieser Scaffolding-Serie steht unseren Leseren auch als PDF zur Verfügung: Downloadlink: Scaffolding_Kap4.pdf

Scaffolding (Teil 2)

Scaffolding ersetzen:

Bei vielen Frameworks (etwa denjenigen, die vollständig auf Codegenerierung basieren) übernehmen Sie die Verantwortung für die Verwaltung des Scaffoldings selbst, sobald Sie einen Teil des Scaffoldings ersetzen. Nicht so bei Rails. Sie können einen einzelnen View oder Controller modifizieren oder neu schreiben, ohne dass sich das auf den Rest des Scaffoldings auswirkt.

Fügen wir beispielsweise eine Titelseite über die index-Methode in die PhotosController-Klasse ein:

class PhotosController < ApplicationController
  scaffold :photo
  
  def index

    render_text(‚Willkommen auf der Photo Share Titelseite‘)

  end
end

Laden Sie nun http://localhost:3000/photos/index. Sie sehen die Meldung »Willkommen auf der Titelseite von Photo Share« wie in Abbildung 4-2, was zeigt, dass Sie die index-Methode überschrieben haben, die durch das Scaffolding zur Verfügung gestellt wurde.

Abbildung 4-2
Überschreiben der index-Methode

Laden Sie http://localhost:3000/photos/list, um sicherzustellen, dass der Rest des Scaffoldings noch immer intakt ist. Rails macht es einem auch leicht, einen View zu ersetzen, während das Controller-Scaffolding erhalten bleibt. Lassen Sie uns den View für die show-Aktion ersetzen. Legen Sie die Datei app/views/photos/show.rhtml an:

<h1>Photos anzeigen</h1>
<p>Dateiname: <%= @photo.filename %></p>

<%= link_to ‚Photoliste‘, :action => ‚list‘, :id => @photo %>

Sie sehen den erzeugten View in Abbildung 4-3. Wie vorhin können Sie einige Views ersetzen, während andere unangetastet bleiben. Wie Sie sehen, bleibt das Scaffolding aktiv, bis Sie es überschreiben. Ist das der Fall, verschwindet es Stückchen für Stückchen, je nachdem, wie Sie es ersetzen.

Abbildung 4-3
Überschreiben eines Scaffolding-Views
Das Scaffolding ist dynamisch

Sie können das Rails-Scaffolding nutzen, um eine einfache Benutzerschnittstelle zur Verfügung zu stellen, während Sie an Ihrem Datenbankschema arbeiten. Die Benutzer können überprüfen, ob Sie alle benötigten Daten verwenden. Sehen wir uns an, wie das Rails-Scaffolding Änderungen an einem Schema handhabt. Wir beginnen damit, zusätzliche Spalten für einen Timestamp, ein Vorschaubild (»Thumbnail«) und eine Beschreibung in die Datenbank einzufügen. Legen Sie eine neue Migration namens add_photo_columns an. Sie ändern die Definition der photos-Tabelle dann, indem Sie ruby script/generate migration add_photo_columns eingeben. Editieren Sie die resultierende Migration in db/migrate so, dass sie wie folgt aussieht:

class AddPhotoColumns < ActiveRecord::Migration
  def self.up
    add_column „photos“, „created_at“, :datetime

    add_column „photos“, „thumbnail“, :string
    add_column „photos“, „description“, :string
    Photo.find(:all).each do |photo|
      photo.update_attribute :created_at, Time.now
      photo.update_attribute :thumbnail, photo.filename.gsub(‚.‘, ‚_m.‘)

    end
  end
  def self.down

    remove_column „photos“, „created_at“
    remove_column „photos“, „thumbnail“
    remove_column „photos“, „beschreibung“

  end
end

Dieses Migrationsskript aktualisiert die Photos-Tabelle und die darin enthaltenen Daten. Nun führen Sie die Migration aus, indem Sie rake migrate eingeben und die Seite (http://localhost:3000/photos/list) im Browser neu laden. Die neuen Spalten erscheinen wie in Abbildung 4-4. Tatsächlich funktionieren alle Scaffolding-Views. Mittels Scaffolding können Sie Ihr Datenbankschema und -modell schnell anpassen, ohne sich gleichzeitig auf die Entwicklung der Benutzerschnittstelle konzentrieren zu müssen.

Abbildung 4-4
Mittels Scaffolding generierter View
Vor- und Nachteile

Sie haben gerade gesehen, wie man das Scaffolding mit Hilfe des scaffold-Tags bzw. mit Hilfe der Metaprogrammierung nutzt. Dieser Scaffolding-Ansatz hat gegenüber anderen Frameworks (etwa der Codegenerierung) einige entscheidende Vorteile:

    • Das scaffold-Tag ist dynamisch. Sie können unbesorgt an Ihrem Datenbankschema arbeiten, und die Schnittstelle passt sich automatisch an.
    • Sie können Controller-Methoden oder Views überschreiben, ohne das gesamte Scaffolding selbst pflegen zu müssen.
    • Das Scaffold-Tag ist sehr kompakt, d.h., Sie erreichen mit einer einzigen Codezeile sehr viel.

Generell bietet der Rails-Ansatz der Metaprogrammierung revolutionäre Vorteile gegenüber der Codegenerierung. Der wichtigste ist wohl, dass sich das dynamische Scaffolding kontinuierlich der Umgebung anpasst. Der Metaprogrammierungsansatz besitzt aber auch einige wesentliche Nachteile:

    • Sie wissen nicht, was passiert. Wenn Sie Rails und das Scaffolding kennenlernen, ist es von großem Nachteil, dass der Code vor Ihnen verborgen bleibt.
    • Das Verhalten des Scaffoldings könnte sich bei späteren Rails-Versionen verändern. Dieses Verhalten könnte sich als Nachteil herausstellen, wenn Ihnen Vorhersagbarkeit wichtig ist.
    • Sie können den Scaffolding-Code nicht als Basis für die weitere Entwicklung verwenden.

Aus diesen Gründen bietet Rails die Codegenerierung als Alternative zum Scaffolding an. Wir sehen uns als Nächstes an den Scaffolding-Codegenerator.

Dieses Tutorial stammt aus dem Buch „Durchstarten mit Rails“ aus dem O’Reilly Verlag.
Details zu dem Buch

Scaffolding (Teil 1)

Seit Jahrhunderten hilft das Gerüst (engl. scaffolding) Baumeistern während der frühen Bauphasen, indem es den Zugang zum Bau ermöglicht und die Konstruktion stützt. Auch Programmierer verwenden temporären Scaffolding-Code, um Struktur zu verleihen und das System zu unterstützen, bis ausgereifterer Code zur Verfügung steht. Rails automatisiert das Scaffolding, um die frühe Codierungsphase produktiver zu machen als jemals zuvor.

In nahezu jeder Ruby on Rails-Demo von fünf oder mehr Minuten Länge werden Sie sehr wahrscheinlich dem Scaffolding begegnen. Rails-Gegner lehnen dieses Feature mit der Begründung ab, dass jeglicher Scaffolding-Code wieder verworfen wird, so dass die Vorteile nur künstlicher Natur seien. In gewisser Weise haben die Gegner recht. Scaffolding-Benutzerschnittstellen sind hässlich und unvollständig. Aber das Scaffolding bietet mehr als nur billige Demoeffekte. Hier einige Vorteile:

    • Sie können Code sehr schnell generieren, um von Ihren Benutzern Feedback zu erhalten.
    • Sie sind durch schnelle Erfolge motiviert.
    • Sie können lernen, wie Rails funktioniert, indem Sie sich den generierten Code ansehen.
    • Sie können das Scaffolding als Grundlage nutzen, um Ihre Entwicklung voranzutreiben.
    • Sie können Metaprogrammierung nutzen, die sich automatisch anpasst, wenn sich die Struktur der Datenbank ändert.

In diesem Kapitel zeigen wir, wie man das Scaffolding zum Aufbau einer einfachen Benutzerschnittstelle für Photo Share nutzt. In späteren Kapiteln werden wir diese Grundlage erweitern, um unsere Anwendung weiter auszugestalten.

Die Scaffold-Methode

Wir haben bereits ein funktionierendes Modell für Photo Share vorgestellt, einschließlich Photos, Kategorien, Diashows und Dias, und wir sind in der Lage, das Schema über Active Record-Objekte innerhalb der Rails-Konsole zu verwalten. Der nächste Schritt besteht darin, das Scaffolding zu nutzen, um einfache Web-Benutzerschnittstellen für diese Klassen aufzubauen. Scaffolding bringt Sie auf Ihrem Weg ein gutes Stück weiter, generiert aber keine vollständige Anwendung. Aber das ist in Ordnung, schließlich suchen wir einen Anfang und keine vollständige Anwendung in Produktionsqualität.

Eine Liste von Photos

Beginnen wir damit, den Benutzer eine Liste von Photos über das Web verwalten zu lassen. Stellen Sie sicher, dass Sie über eine Datenbank verfügen, dass diese konfiguriert ist und dass Sie über Tabellen mit Modellobjekten für Dias, Diashows, Kategorien und Photos verfügen.1 Wenn Ihr Server nicht läuft, starten Sie ihn wie üblich über ruby script/server. Besuchen Sie mit Ihrem Browser http://localhost:3000/, um sicherzustellen, dass die Dinge funktionieren. Sie sehen die Rails-Willkommensseite, wenn alles richtig funktioniert. Nutzen wir nun das Scaffolding.

Wir bauen unsere »Gerüste« mit Hilfe der scaffold-Methode auf. Diese Methode gehört zum Controller, weshalb wir einen Controller namens Photos anlegen müssen:

ruby script/generate controller Photos

Fügen Sie die scaffold :photo-Methode wie folgt in photo_controller.rb ein:

class PhotosController < ApplicationController

  scaffold :photo
end

Das war’s schon – Rails erledigt den Rest. Laden Sie nun die URL http://localhost:3000/photos, um sich das Scaffolding in Aktion anzusehen. Sie sehen eine Liste mit Photos, zusammen mit Links zum Anlegen neuer Photos, zum Editieren existierender Photos und zur Präsentation der vorhandenen Photos. Mit der einfachen Anweisung scaffold :photo erhalten Sie alle Seiten, die in Abbildung 4-1 aufgeführt sind. Das Scaffolding generiert überraschend vollständigen Controller- und View-Code. Um eins klarzustellen: Das Scaffolding erzeugt keinen produktionsfähigen Code, bietet aber einen guten Ausgangspunkt. Der nächste Abschnitt zeigt, wie das Scaffolding funktioniert.

Wenn Sie beim Zugriff auf die Anwendung die folgende Fehlermeldung erhalten, dann haben Sie den Server nicht neu gestartet:
Mysql::Error in Photo#list
Access denied for user: ‚root@localhost‘ (Using password: NO)

Abbildung 4-1
Scaffolding generiert alle vier Views

Mehr Metaprogrammierung

scaffold :photo erledigt die ganze Arbeit. scaffold ist eine Methode von ActionController.2 :photo ist ein Symbol, das das Active Record-Modell festlegt, das Rails für dieses Scaffolding benutzt. Wenn Sie diese Methode angeben, fügt Rails Ihrem Controller die neun Methoden aus Tabelle 4-1 hinzu. Vier dieser Methoden geben Views aus. Zusammen bilden diese Methoden eine einfache CRUD-Schnittstelle für Ihr Active Record-Modell (basierend auf dem Objektmodell). Innerhalb des Modells enthält das @@content_columns-Attribut Informationen zu jeder Spalte der Datenbank.

Tabelle 4-1

Die scaffold :target-Methode eines Rails-Controllers erzeugt die folgenden Methoden im Controller 

Methoden

Aufgabe

View

index

Generiert eine Willkommensseite. Standardmäßig wird index auf die list-Controller-Aktion umgeleitet. Standardmäßig ruft Rails auch die index-Aktion auf, wenn der Benutzer einen Controller angibt, aber keine Aktion.

Nein
list

Generiert einen View mit einer paginierten Liste von ziel-Objekten, wobei das Ziel-Objekt das Modellobjekt für das Scaffolding ist.

Ja
create(ziel)

Erzeugt und speichert ein Active Record-Objekt aus dem Ziel-Objekt.

Nein
new

Generiert einen View, um ein neues Controller-Objekt zu erzeugen.

Ja
edit(id)

Generiert einen View, um das Ziel-Objekt mit der angegebenen id zu editieren.

Ja
update(id)

Aktualisiert das Active Record-Ziel-Objekt mit der angegebenen id.

Nein
show(id)

Generiert einen View, um ein Objekt auszugeben.

Ja
destroy(id)

Zerstört das Objekt vom Typ ziel mit der angegebenen id.

Nein
render_scaffold

Generiert einen Standard-View für die View-Methoden, wenn kein .rhtml-View vorhanden ist.

N/A

Die meisten der Methoden aus Tabelle 4-1 rufen letztendlich die render_scaffold-Methode auf, die überprüft, ob Sie den entsprechenden View hinzugefügt haben. (Denken Sie daran, dass Rails-Views standardmäßig den gleichen Namen besitzen wie die Controller-Methode.) Ist das der Fall, verwendet Rails Ihre Views. Andernfalls stellt der Controller Standard-Views zur Verfügung.

Dieses Tutorial stammt aus dem Buch „Durchstarten mit Rails“ aus dem O’Reilly Verlag.

Details zu dem Buch

Durchstarten mit Ruby On Rails

Gehört hat wohl jeder schon vom Open Source Framework Ruby on Rails und wer datenbankgestützte Web-Anwendungen entwickelt, wird sich öfters mal Gedanken darüber gemacht haben, Ruby On Rails einzusetzen — also dann, los geht’s, denn Bruce A.

Tate und Curt Hibbs fegen mit Durchstarten mit Ruby On Rails alle Entschuldigungen länger zu warten einfach weg.

Sieben Kapitel, etwa 140 Seiten — dass ist schnell. Funktioniert aber, wenn man als Leser mit macht. Tate und Hibbs zielen auf gestandene Programmierer, die einen konkreten Überblick benötigen, um dann selbstständig mithilfe von Referenzhandbüchern ihre eigenen Bedürfnisse und Projekt mit Ruby on Rails umzusetzen. Anhand eines Projektes, das sie Schritt für Schritt mit dem Leser durchgehen, vermitteln sie die Grundlagen und die wichtigsten Stützen von Ruby on Rails — zusätzliche Schwerpunkte dabei sind Migrations und Ajax.

Tate und Hibbs haben sich in Durchstarten mit Ruby On Rails an der Ruby on Rails-Philosophie orientiert: „Quick and dirty“ ohne das „dirty“ — einfach, konkret übersichtlichmit einem klaren und soliden Ergebnis am Ende. Wer sich mit Programmierkenntnissen, aber ohne Ruby-Erfahrung schnell und ergebnisorientiert in das Framework einarbeiten will, macht hier zwei Schritte in einem. –Wolfgang Treß

phlow.net, April 2007
„Die neu erschienene Publikation „Durchstarten mit Ruby on Rails“ aus dem Hause O’Reilly ist ein sehr geradliniger Einstieg in die erste eigene Anwendung mit Ruby on Rails. Das Buch ist ein ausführliches Tutorial, das ohne Umschweife direkt zur ersten Anwendung führt.“

  • Taschenbuch: 173 Seiten
  • Verlag: (2008-07-03 )
  • Preis: 24.90 €
  • Sprache: german
  • ISBN-10: 3897214814
  • Autor(en): Bruce Tate, Curt Hibbs
  • kaufen

Professionelle Webentwicklung mit Ruby on Rails 2. Das Praxisbuch für Entwickler

Ruby on Rails hat sich in Windeseile zu einem beliebten Framework entwickelt. Jens-Christian Fischer richtet sich an ambitionierte Einsteiger und gibt Ihnen einen praxisbezogenen Einstieg in die Entwicklung von Webanwendungen. Der Leser wird Schritt für Schritt durch das Erstellen von Anwendungen wie z.B. eine „Social Software“ und ein CMS geführt, anhand derer alle Konzepte vermittelt werden.

Ruby on Rails hat sich in Windeseile zu einem der beliebtesten Frameworks für die Erstellung von Webanwendungen entwickelt. Mit kaum einem anderen Framework lassen sich so effektiv und mit so wenig Code funktionsreiche Webseiten erstellen — und mit keinem anderen Framework macht es so viel Spaß versprochen.—

Jens-Christian Fischer richtet sich an ambitionierte Einsteiger und Programmierer und ermöglicht ihnen einen praxisbezogenen Einstieg in die Entwicklung von Webanwendungen mit Ruby on Rails. Im Buch wird eine vollständige Webanwendung mit zahlreichen Funktionen erstellt, anhand derer die im Buch vorgestellten Konzepte sowie fortgeschrittenen Techniken vermittelt werden.—

Im ersten Teil werden zunächst die Grundsteine für die Webanwendung gelegt mit den ersten einfachen Funktionen, damit Sie direkt in die Praxis einsteigen und schnell Ergebnisse sehen können. Dabei wird bereits großer Wert auf das Testen gelegt. In Teil II geht es ans Eingemachte: Fischer erläutert hier insbesondere, wie Intra- und Internetanwendungen professionell entwickelt werden, und zeigt Ihnen hierfür viele relevante Techniken, z.B. die testgetriebene Entwicklung, Behaviour Driven Development und User Stories mit RSpec. Er verwendet neben den Standardfunktionen, die Rails mitbringt, wie REST für das Modellieren von Ressourcen, auch Alternativen wie HAML und SASS für das Erzeugen von HTML oder jQuery für JavaScript- und AJAX-Funktionalit&#auml;t. Gleichzeitig wird die Anwendung um fortgeschrittene Features erweitert: unter anderem die Einbindung einer komfortablen Suchfunktion mit Sphinx. Zu guter Letzt wird die Anwendung für den produktiven Einsatz vorbereitet und das automatische Deployment mit Capistrano erklärt.—

Teil III dient dazu, Ihnen nicht nur die Grundlagen von Ruby näherzubringen, sondern auch weiterführende Themen wie die Metaprogrammierung in Ruby sowie JRuby.—

Der Anhang behandelt ausführlich die Installation von Ruby und Rails unter allen verfügbaren Systemen.—

Wenn Sie wissen wollen, wie Sie aus Rails mehr machen und welche Techniken Sie für professionelle Anwendungen einsetzen kännen, dann werden Sie in diesem Buch fündig. Jens-Christian Fischer lässt Sie an seinem langjährigen Erfahrungsschatz teilhaben. ***

Aus dem Inhalt:

Teil I: Rails praktisch anwenden

– Praxiseinstieg: eine erste einfache Anwendung – Einführung ins Testen – ActiveRecord: mit Modellen arbeiten – Relationen zwischen Objekten herstellen – Navigation und Layout —

Teil II: Rails professionell einsetzen

– Tools für die Arbeitsumgebung: vom Editor bis zur – Versionskontrolle – Behaviour Driven – Development und RSpec – HAML und SASS – REST – User Stories – Erweiterungen für Rails: Plug-ins, Gems, Bibliotheken – Login und Authentisierung – Die Anwendung um Kommentare erweitern – Suchfunktionen integrieren – AJAX mit jQuery – Produktionsumgebung einrichten – Automatisches Deployment mit Capistrano —

Teil III: Ruby

– Ruby-Grundlagen – Metaprogrammierung in Ruby – Alternatives Ruby: JRuby —

Teil IV: Anhänge

– Installation von Ruby und Rails unter Mac 10.4/10.5, Unix/Linux, Windows – Weiterführende Ressourcen

  • Taschenbuch: 624 Seiten
  • Verlag: (2008-06-12 )
  • Preis: 31.95 €
  • Sprache: german
  • ISBN-10: 3826616839
  • Autor(en): Jens-Christian Fischer
  • kaufen