README.de.rdoc in sinatra-1.3.0.d vs README.de.rdoc in sinatra-1.3.0.e

- old
+ new

@@ -42,11 +42,11 @@ delete '/' do .. entferne etwas .. end options '/' do - .. lege etwas fest .. + .. zeige, was wir können .. end Die Routen werden in der Reihenfolge durchlaufen, in der sie definiert wurden. Das erste Routen-Muster, das mit dem Request übereinstimmt, wird ausgeführt. @@ -76,10 +76,16 @@ get '/download/*.*' do # passt auf /download/pfad/zu/datei.xml params[:splat] # => ["pfad/zu/datei", "xml"] end +Oder mit Block-Parametern: + + get '/download/*.*' do |pfad, endung| + [pfad, endung] # => ["Pfad/zu/Datei", "xml"] + end + Routen mit regulären Ausdrücken sind auch möglich: get %r{/hallo/([\w]+)} do "Hallo, #{params[:captures].first}!" end @@ -219,424 +225,217 @@ <tt>./views</tt>-Ordner befinden. Es kann jedoch ein anderer Ordner festgelegt werden: set :views, File.dirname(__FILE__) + '/templates' -Eine wichtige Sache, die man sich hierbei merken sollte, ist, dass man immer -mit Symbols auf Templates verweisen sollte, auch wenn sich ein Template in -einem Unterordner befindet (in diesen Fall <tt>:'subdir/template'</tt>). -Rendering-Methoden rendern jeden String direkt. +Es ist zu beachten, dass immer mit Symbolen auf Templates verwiesen werden +muss, auch dann, wenn sie sich in einem Unterordner befinden: -=== Haml-Templates + haml :'unterverzeichnis/template' -Das +haml+-Gem wird benötigt, um Haml-Templates rendern zu können: +Rendering-Methoden rendern jeden String direkt. - # haml muss eingebunden werden - require 'haml' +=== Verfügbare Templatesprachen - get '/' do - haml :index - end +Einige Sprachen haben mehrere Implementierungen. Um festzulegen, welche +verwendet wird (und dann auch Thread-sicher ist), verwendet man am besten zu +Beginn ein 'require': -Dieser Code rendert <tt>./views/index.haml</tt>. + require 'rdiscount' # oder require 'bluecloth' + get('/') { markdown :index } -{Haml-Optionen}[http://haml-lang.com/docs/yardoc/file.HAML_REFERENCE.html#options] -können global durch die Sinatra-Konfiguration gesetzt werden, -siehe {Optionen und Konfiguration}[http://www.sinatrarb.com/configuration.html], -und individuell überschrieben werden. +=== Haml Templates - set :haml, :format => :html5 # Standard-Haml-Format ist :xhtml +Abhängigkeit:: {haml}[http://haml-lang.com/] +Dateierweiterungs:: <tt>.haml</tt> +Beispiel:: <tt>haml :index, :format => :html5</tt> - get '/' do - haml :index, :format => :html4 # überschrieben - end +=== Erb Templates -=== Erb-Templates +Abhängigkeit:: {erubis}[http://www.kuwata-lab.com/erubis/] oder + erb (included in Ruby) +Dateierweiterungs:: <tt>.erb</tt>, <tt>.rhtml</tt> oder <tt>.erubis</tt> + (nur Erubis) +Beispiel:: <tt>erb :index</tt> - # erb muss eingebunden werden - require 'erb' +=== Builder Templates - get '/' do - erb :index - end +Abhängigkeit:: {builder}[http://builder.rubyforge.org/] +Dateierweiterungs:: <tt>.builder</tt> +Beispiel:: <tt>builder { |xml| xml.em "Hallo" }</tt> -Dieser Code rendert <tt>./views/index.erb</tt>. +Nimmt ebenso einen Block für Inline-Templates entgegen (siehe Beispiel). -=== Erubis +=== Nokogiri Templates -Das +erubis+-Gem wird benötigt, um Erubis-Templates rendern zu können: +Abhängigkeit:: {nokogiri}[http://nokogiri.org/] +Dateierweiterungs:: <tt>.nokogiri</tt> +Beispiel:: <tt>nokogiri { |xml| xml.em "Hallo" }</tt> - # erbubis muss eingebunden werden - require 'erubis' +Nimmt ebenso einen Block für Inline-Templates entgegen (siehe Beispiel). - get '/' do - erubis :index - end +=== Sass Templates -Dieser Code rendert <tt>./views/index.erubis</tt>. +Abhängigkeit:: {sass}[http://sass-lang.com/] +Dateierweiterungs:: <tt>.sass</tt> +Beispiel:: <tt>sass :stylesheet, :style => :expanded</tt> -Es ist auch möglich, Erb durch Erubis zu ersetzen: +=== SCSS Templates - require 'erubis' - Tilt.register :erb, Tilt[:erubis] - - get '/' do - erb :index - end +Abhängigkeit:: {sass}[http://sass-lang.com/] +Dateierweiterungs:: <tt>.scss</tt> +Beispiel:: <tt>scss :stylesheet, :style => :expanded</tt> -Dieser Code rendert ebenfalls <tt>./views/index.erb</tt>. +=== Less Templates -=== Builder-Templates +Abhängigkeit:: {less}[http://www.lesscss.org/] +Dateierweiterungs:: <tt>.less</tt> +Beispiel:: <tt>less :stylesheet</tt> -Das +builder+-Gem wird benötigt, um Builder-Templates rendern zu können: +=== Liquid Templates - # builder muss eingebunden werden - require 'builder' +Abhängigkeit:: {liquid}[http://www.liquidmarkup.org/] +Dateierweiterungs:: <tt>.liquid</tt> +Beispiel:: <tt>liquid :index, :locals => { :key => 'Wert' }</tt> - get '/' do - builder :index - end +Da man aus dem Liquid-Template heraus keine Ruby-Methoden aufrufen kann +(ausgenommen +yield+), wird man üblicherweise locals verwenden wollen, mit +denen man Variablen weitergibt. -Dieser Code rendert <tt>./views/index.builder</tt>. +=== Markdown Templates -=== Nokogiri-Templates +Abhängigkeit:: {rdiscount}[https://github.com/rtomayko/rdiscount], + {redcarpet}[https://github.com/tanoku/redcarpet], + {bluecloth}[http://deveiate.org/projects/BlueCloth], + {kramdown}[http://kramdown.rubyforge.org/] *oder* + {maruku}[http://maruku.rubyforge.org/] +Dateierweiterungs:: <tt>.markdown</tt>, <tt>.mkd</tt> und <tt>.md</tt> +Beispiel:: <tt>markdown :index, :layout_engine => :erb</tt> -Das +nokogiri+-Gem wird benötigt, um Nokogiri-Templates rendern zu können: +Da man aus den Markdown-Templates heraus keine Ruby-Methoden aufrufen und auch +keine locals verwenden kann, wird man Markdown üblicherweise in Kombination mit +anderen Renderern verwenden wollen: - # nokogiri muss eingebunden werden - require 'nokogiri' + erb :overview, :locals => { :text => markdown(:einfuehrung) } - get '/' do - nokogiri :index - end +Beachte, dass man die +markdown+-Methode auch aus anderen Templates heraus +aufrufen kann: -Dieser Code rendert <tt>./views/index.nokogiri</tt>. + %h1 Gruß von Haml! + %p= markdown(:Grüsse) -=== Sass-Templates +Da man Ruby nicht von Markdown heraus aufrufen kann, können auch Layouts nicht +in Markdown geschrieben werden. Es ist aber möglich, einen Renderer für die +Templates zu verwenden und einen anderen für das Layout, indem die +<tt>:layout_engine</tt>-Option verwendet wird. -Das +haml+- oder +sass+-Gem wird benötigt, um Sass-Templates rendern zu können: +=== Textile Templates - # sass muss eingebunden werden - require 'sass' +Abhängigkeit:: {RedCloth}[http://redcloth.org/] +Dateierweiterungs:: <tt>.textile</tt> +Beispiel:: <tt>textile :index, :layout_engine => :erb</tt> - get '/stylesheet.css' do - sass :stylesheet - end +Da man aus dem Textile-Template heraus keine Ruby-Methoden aufrufen und auch +keine locals verwenden kann, wird man Textile üblicherweise in Kombination mit +anderen Renderern verwenden wollen: -Dieser Code rendert <tt>./views/stylesheet.sass</tt>. + erb :overview, :locals => { :text => textile(:einfuehrung) } -{Sass-Optionen}[http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#options] -können global durch die Sinatra-Konfiguration gesetzt werden, siehe -{Optionen und Konfiguration}[http://www.sinatrarb.com/configuration.html], -und individuell überschrieben werden. +Beachte, dass man die +textile+-Methode auch aus anderen Templates heraus +aufrufen kann: - set :sass, :style => :compact # Standard Sass-Style ist :nested + %h1 Gruß von Haml! + %p= textile(:Grüsse) - get '/stylesheet.css' do - sass :stylesheet, :style => :expanded # überschrieben - end +Da man Ruby nicht von Textile heraus aufrufen kann, können auch Layouts nicht +in Textile geschrieben werden. Es ist aber möglich, einen Renderer für die +Templates zu verwenden und einen anderen für das Layout, indem die +<tt>:layout_engine</tt>-Option verwendet wird. -=== SCSS-Templates +=== RDoc Templates -Das +haml+- oder +sass+-Gem wird benötigt, um SCSS-Templates rendern zu können: +Abhängigkeit:: {rdoc}[http://rdoc.rubyforge.org/] +Dateierweiterungs:: <tt>.rdoc</tt> +Beispiel:: <tt>textile :README, :layout_engine => :erb</tt> - # sass muss eingebunden werden - require 'sass' +Da man aus dem RDoc-Template heraus keine Ruby-Methoden aufrufen und auch +keine locals verwenden kann, wird man RDoc üblicherweise in Kombination mit +anderen Renderern verwenden wollen: - get '/stylesheet.css' do - scss :stylesheet - end + erb :overview, :locals => { :text => rdoc(:einfuehrung) } -Dieser Code rendert <tt>./views/stylesheet.scss</tt>. +Beachte, dass man die +rdoc+-Methode auch aus anderen Templates heraus +aufrufen kann: -{SCSS-Optionen}[http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#options] -können global durch die Sinatra-Konfiguration gesetzt werden, siehe -{Optionen und Konfiguration}[http://www.sinatrarb.com/configuration.html], und -individuell überschrieben werden. + %h1 Gruß von Haml! + %p= rdoc(:Grüße) - set :scss, :style => :compact # Standard-SCSS-Style ist :nested +Da man Ruby nicht von RDoc heraus aufrufen kann, können auch Layouts nicht +in RDoc geschrieben werden. Es ist aber möglich, einen Renderer für die +Templates zu verwenden und einen anderen für das Layout, indem die +<tt>:layout_engine</tt>-Option verwendet wird. - get '/stylesheet.css' do - scss :stylesheet, :style => :expanded # überschrieben - end +=== Radius Templates -=== Less-Templates +Abhängigkeit:: {radius}[http://radius.rubyforge.org/] +Dateierweiterungs:: <tt>.radius</tt> +Beispiel:: <tt>radius :index, :locals => { :key => 'Wert' }</tt> -Das +less+-Gem wird benötigt, um Less-Templates rendern zu können: +Da man aus dem Radius-Template heraus keine Ruby-Methoden aufrufen kann, wird +man üblicherweise locals verwenden wollen, mit denen man Variablen weitergibt. - # less muss eingebunden werden - require 'less' +=== Markaby Templates - get '/stylesheet.css' do - less :stylesheet - end +Abhängigkeit:: {markaby}[http://markaby.github.com/] +Dateierweiterungs:: <tt>.mab</tt> +Beispiel:: <tt>markaby { h1 "Willkommen!" }</tt> -Dieser Code rendert <tt>./views/stylesheet.less</tt>. +Nimmt ebenso einen Block für Inline-Templates entgegen (siehe Beispiel). -=== Liquid-Templates +=== Slim Templates -Das +liquid+-Gem wird benötigt, um Liquid-Templates rendern zu können: +Abhängigkeit:: {slim}[http://slim-lang.com/] +Dateierweiterungs:: <tt>.slim</tt> +Beispiel:: <tt>slim :index</tt> - # liquid muss eingebunden werden - require 'liquid' +=== Creole Templates - get '/' do - liquid :index - end +Abhängigkeit:: {creole}[https://github.com/minad/creole] +Dateierweiterungs:: <tt>.creole</tt> +Beispiel:: <tt>creole :wiki, :layout_engine => :erb</tt> -Dieser Code rendert <tt>./views/index.liquid</tt>. +Da man aus dem Creole-Template heraus keine Ruby-Methoden aufrufen und auch +keine locals verwenden kann, wird man Creole üblicherweise in Kombination mit +anderen Renderern verwenden wollen: -Da aus Liquid-Templates heraus keine Methoden (abgesehen von +yield+) -aufgerufen werden können, ist es möglich, +locals+ zu übergeben: + erb :overview, :locals => { :text => creole(:einfuehrung) } - liquid :index, :locals => { :key => 'value' } +Beachte, dass man die +creole+-Methode auch aus anderen Templates heraus +aufrufen kann: -=== Markdown-Templates + %h1 Gruß von Haml! + %p= creole(:Grüße) -Das +rdiscount+-Gem wird benötigt, um Markdown-Templates rendern zu können: +Da man Ruby nicht von Creole heraus aufrufen kann, können auch Layouts nicht +in Creole geschrieben werden. Es ist aber möglich, einen Renderer für die +Templates zu verwenden und einen anderen für das Layout, indem die +<tt>:layout_engine</tt>-Option verwendet wird. - # rdiscount muss eingebunden werden - require "rdiscount" +=== CoffeeScript Templates - get '/' do - markdown :index - end +Abhängigkeit:: {coffee-script}[https://github.com/josh/ruby-coffee-script] + und eine {Möglichkeit JavaScript auszuführen}[https://github.com/sstephenson/execjs/blob/master/README.md#readme] +Dateierweiterungs:: <tt>.coffee</tt> +Beispiel:: <tt>coffee :index</tt> -Dieser Code rendert <tt>./views/index.markdown</tt> (+md+ und +mkd+ sind -ebenfalls zulässige Dateiendungen). +=== Eingebettete Templates -Da es weder möglich ist, Methoden aufzurufen, noch +locals+ zu übergeben, ist -es am sinnvollsten, Markdown in Kombination mit einer anderen Template-Engine -zu nutzen: - - erb :overview, :locals => { :text => markdown(:introduction) } - -Es ist auch möglich, die +markdown+-Methode aus anderen Templates heraus -aufzurufen: - - %h1 Hallo von Haml! - %p= markdown(:greetings) - -Da man Ruby aus Markdown heraus nicht aufrufen kann, ist es nicht möglich, -Layouts zu verwenden, die in Markdown geschrieben sind. Es ist aber möglich, -einen anderen Renderer für das Template zu verwenden als für das Layout, indem -man die <tt>:layout_engine</tt>-Option angibt: - get '/' do - markdown :index, :layout_engine => :erb - end - -Das wird <tt>./views/index.md</tt> mit <tt>./views/layout.erb</tt> als Layout -rendern. - -Denk daran, dass solche Einstellungen auch global gesetzt werden können: - - set :markdown, :layout_engine => :haml, :layout => :post - - get '/' do - markdown :index - end - -Das wird <tt>./views/index.md</tt> (und jedes andere Markdown-Template) mit -<tt>./views/post.haml</tt> als Layout rendern. - -Ebenso ist es möglich, Markdown mit BlueCloth anstelle von RDiscount zu parsen: - - require 'bluecloth' - - Tilt.register 'markdown', BlueClothTemplate - Tilt.register 'mkd', BlueClothTemplate - Tilt.register 'md', BlueClothTemplate - - get '/' do - markdown :index - end - -Das sollte <tt>./views/index.md</tt> mit BlueCloth rendern. - -=== Textile-Templates - -Das +redcloth+-Gem wird benötigt, um Textile-Templates rendern zu können: - - # redcloth muss eingebunden werden - require "redcloth" - - get '/' do - textile :index - end - -Dieser Code rendert <tt>./views/index.textile</tt>. - -Da es weder möglich ist, Methoden aufzurufen, noch +locals+ zu übergeben, ist -es sinnvoll, Textile in Kombination mit einer anderen Template-Engine zu -nutzen: - - erb :overview, :locals => { :text => textile(:introduction) } - -Es ist auch möglich, die +textile+-Methode aus anderen Templates heraus -aufzurufen: - - %h1 Hallo von Haml! - %p= textile(:greetings) - -Da man Ruby aus Textile heraus nicht aufrufen kann, ist es nicht möglich, -Layouts zu verwenden, die in Textile geschrieben sind. Es ist aber möglich, -einen anderen Renderer für das Template zu verwenden als für das Layout, indem -man die <tt>:layout_engine</tt>-Option angibt: - - get '/' do - textile :index, :layout_engine => :erb - end - -Das wird <tt>./views/index.textile</tt> mit <tt>./views/layout.erb</tt> als -Layout rendern. - -Denk daran, dass solche Einstellungen auch global gesetzt werden können: - - set :textile, :layout_engine => :haml, :layout => :post - - get '/' do - textile :index - end - -Das wird <tt>./views/index.textile</tt> (und jedes andere Markdown-Template) -mit <tt>./views/post.haml</tt> als Layout rendern. - -=== RDoc-Templates - -Das +rdoc+-Gem wird benötigt, um RDoc-Templates rendern zu können: - - # rdoc/markup/to_html muss eingebunden werden - require "rdoc/markup/to_html" - - get '/' do - rdoc :index - end - -Dieser Code rendert <tt>./views/index.rdoc</tt>. - -Da es weder möglich ist, Methoden aufzurufen, noch +locals+ zu übergeben, ist -es sinnvoll, RDoc in Kombination mit einer anderen Template-Engine zu nutzen: - - erb :overview, :locals => { :text => rdoc(:introduction) } - -Es ist auch möglich, die +rdoc+-Methode aus anderen Templates heraus -aufzurufen: - - %h1 Hallo von Haml! - %p= rdoc(:greetings) - -Da man Ruby aus RDoc heraus nicht aufrufen kann, ist es nicht möglich, Layouts -zu verwenden, die in RDoc geschrieben sind. Es ist aber möglich, einen anderen -Renderer für das Template zu verwenden als für das Layout, indem man die -<tt>:layout_engine</tt> option angibt: - - get '/' do - rdoc :index, :layout_engine => :erb - end - -Das wird <tt>./views/index.rdoc</tt> mit <tt>./views/layout.erb</tt> als Layout -rendern. - -Denk daran, dass solche Einstellungen auch global gesetzt werden können: - - set :rdoc, :layout_engine => :haml, :layout => :post - - get '/' do - rdoc :index - end - -Das wird <tt>./views/index.rdoc</tt> (und jedes andere Markdown-Template) mit -<tt>./views/post.haml</tt> als Layout rendern. - -=== Radius-Templates - -Das +radius+-Gem wird benötigt, um Radius-Templates rendern zu können: - - # radius muss eingebunden werden - require 'radius' - - get '/' do - radius :index - end - -Dieser Code rendert <tt>./views/index.radius</tt>. - -Da aus Radius-Templates heraus keine Methoden (abgesehen von +yield+) -aufgerufen werden können, es es möglich, +locals+ zu übergeben: - - radius :index, :locals => { :key => 'value' } - -=== Markaby-Templates - -Das +markaby+-Gem wird benötigt, um Markaby-Templates rendern zu können: - - # markaby muss eingebunden werden - require 'markaby' - - get '/' do - markaby :index - end - -Dieser Code rendert <tt>./views/index.mab</tt>. - -=== Slim-Templates - -Das +slim+-Gem wird benötigt, um Slim-Templates rendern zu können: - - # slim muss eingebunden werden - require 'slim' - - get '/' do - slim :index - end - -Dieser Code rendert <tt>./views/index.slim</tt>. - -=== Creole-Templates - -Das +creole+-Gem wird benötigt, um Creole-Templates rendern zu können: - - # creole muss eingebunden werden - require 'creole' - - get '/' do - creole :index - end - -Dieser Code rendert <tt>./views/index.creole</tt>. - -=== CoffeeScript-Templates - -Das <tt>coffee-script</tt>-Gem und mindestens eine der folgenden Optionen -werden benötigt, um JavaScript auf dem Server ausführen zu können: - -* +node+ (von Node.js) befindet sich im Pfad -* du bist unter OS X -* +therubyracer+ gem/library - -Siehe auch http://github.com/josh/ruby-coffee-script für eine vollständige -Liste aller Optionen. - -Nun können CoffeeScript-Templates in der Applikation gerendert werden: - - # coffee-script muss eingebunden werden - require 'coffee-script' - - get '/application.js' do - coffee :application - end - -Dieser Code rendert <tt>./views/application.coffee</tt>. - -=== Inline-Templates - - get '/' do haml '%div.title Hallo Welt' end -Rendert den Inline-Template-String. +Rendert den eingebetteten Template-String. === Auf Variablen in Templates zugreifen Templates werden in demselben Kontext ausgeführt wie Routen. Instanzvariablen in Routen sind auch direkt im Template verfügbar: @@ -648,11 +447,11 @@ Oder durch einen expliziten Hash von lokalen Variablen: get '/:id' do foo = Foo.find(params[:id]) - haml '%h1= foo.name', :locals => { :foo => foo } + haml '%h1= bar.name', :locals => { :bar => foo } end Dies wird typischerweise bei Verwendung von Subtemplates (partials) in anderen Templates eingesetzt. @@ -700,11 +499,11 @@ Wenn ein Template mit dem Namen "layout" existiert, wird es bei jedem Aufruf verwendet. Durch <tt>:layout => false</tt> kann das Ausführen verhindert werden: get '/' do - haml :index, :layout => !request.xhr? + haml :index, :layout => request.xhr? end === Dateiendungen zuordnen Um eine Dateiendung einer Template-Engine zuzuordnen, kann @@ -966,12 +765,14 @@ Wenn <tt>send_file</tt> oder statische Dateien verwendet werden, kann es vorkommen, dass Sinatra den Mime-Typ nicht kennt. Registriert wird dieser mit +mime_type+ per Dateiendung: - mime_type :foo, 'text/foo' - + configure do + mime_type :foo, 'text/foo' + end + Es kann aber auch der +content_type+-Helfer verwendet werden: get '/' do content_type :foo "foo foo foo" @@ -1476,14 +1277,21 @@ Rack bietet eine Vielzahl von Standard-Middlewares für Logging, Debugging, URL-Routing, Authentifizierung und Session-Verarbeitung. Sinatra verwendet viele von diesen Komponenten automatisch, abhängig von der Konfiguration. So muss +use+ häufig nicht explizit verwendet werden. +Hilfreiche Middleware gibt es z.B. hier: +{rack}[https://github.com/rack/rack/tree/master/lib/rack], +{rack-contrib}[https://github.com/rack/rack-contrib#readme], +mit {CodeRack}[http://coderack.org/] oder im +{Rack wiki}[https://github.com/rack/rack/wiki/List-of-Middleware]. + == Testen Sinatra-Tests können mit jedem auf Rack aufbauendem Test-Framework geschrieben -werden. {Rack::Test}[http://gitrdoc.com/brynary/rack-test] wird empfohlen: +werden. {Rack::Test}[http://rdoc.info/github/brynary/rack-test/master/frames] +wird empfohlen: require 'my_sinatra_app' require 'test/unit' require 'rack/test' @@ -1508,24 +1316,21 @@ get '/', {}, 'HTTP_USER_AGENT' => 'Songbird' assert_equal "Du verwendest Songbird!", last_response.body end end -Anmerkung: Das eingebaute Sinatra::Test-Modul und die -Sinatra::TestHarness-Klasse werden seit Version 0.9.2 nicht mehr unterstützt. - == Sinatra::Base - Middleware, Bibliotheken und modulare Anwendungen Das Definieren einer Top-Level-Anwendung funktioniert gut für Mikro-Anwendungen, hat aber Nachteile, wenn wiederverwendbare Komponenten wie Middleware, Rails Metal, einfache Bibliotheken mit Server-Komponenten oder auch Sinatra-Erweiterungen geschrieben werden sollen. Die Top-Level-DSL belastet den Objekt-Namespace und setzt einen -Mikro-Anwendungsstil voraus (eine einzelne Anwendungsdatei, ./public und -./views Ordner, Logging, Exception-Detail-Seite, usw.). Genau hier kommt -Sinatra::Base ins Spiel: +Mikro-Anwendungsstil voraus (eine einzelne Anwendungsdatei, <tt>./public</tt> +und <tt>./views</tt> Ordner, Logging, Exception-Detail-Seite, usw.). Genau +hier kommt <tt>Sinatra::Base</tt> ins Spiel: require 'sinatra/base' class MyApp < Sinatra::Base set :sessions, true @@ -1541,19 +1346,19 @@ +use+ oder +run+ von einer Rackup-<tt>config.ru</tt>-Datei oder als Server-Komponente einer Bibliothek: MyApp.run! :host => 'localhost', :port => 9090 -Die Methoden der Sinatra::Base-Subklasse sind genau dieselben wie die der -Top-Level-DSL. Die meisten Top-Level-Anwendungen können mit nur zwei -Veränderungen zu Sinatra::Base-Komponenten konvertiert werden: +Die Methoden der <tt>Sinatra::Base</tt>-Subklasse sind genau dieselben wie die +der Top-Level-DSL. Die meisten Top-Level-Anwendungen können mit nur zwei +Veränderungen zu <tt>Sinatra::Base</tt> konvertiert werden: * Die Datei sollte <tt>require 'sinatra/base'</tt> anstelle von <tt>require 'sinatra/base'</tt> aufrufen, ansonsten werden alle von Sinatras DSL-Methoden in den Top-Level-Namespace importiert. * Alle Routen, Error-Handler, Filter und Optionen der Applikation müssen in - einer Subklasse von Sinatra::Base definiert werden. + einer Subklasse von <tt>Sinatra::Base</tt> definiert werden. <tt>Sinatra::Base</tt> ist ein unbeschriebenes Blatt. Die meisten Optionen sind per Standard deaktiviert. Das betrifft auch den eingebauten Server. Siehe {Optionen und Konfiguration}[http://sinatra.github.com/configuration.html] für Details über mögliche Optionen. @@ -1579,11 +1384,11 @@ Will man jedoch von einem Stil auf den anderen umsteigen, sollten einige Unterschiede beachtet werden: Szenario Classic Modular - app_file file loading sinatra nil + app_file sinatra ladende Datei Sinatra::Base subklassierende Datei run $0 == app_file false logging true false method_override true false inline_templates true false @@ -1608,11 +1413,11 @@ Oder über eine <tt>config.ru</tt>-Datei, die es erlaubt, einen beliebigen Rack-Handler zu verwenden: # config.ru - require 'mein_app' + require './mein_app' run MeineApp Starte: rackup -p 4567 @@ -1628,11 +1433,11 @@ 'Hallo Welt!' end sowie eine dazugehörige <tt>config.ru</tt>-Datei: - require 'app' + require './app' run Sinatra::Application === Wann sollte eine config.ru-Datei verwendet werden? Anzeichen dafür, dass eine <tt>config.ru</tt>-Datei gebraucht wird: @@ -1661,11 +1466,11 @@ enable :sessions get('/login') { haml :login } post('/login') do - if params[:name] = 'admin' and params[:password] = 'admin' + if params[:name] == 'admin' && params[:password] == 'admin' session['user_name'] = params[:name] else redirect '/login' end end @@ -1686,11 +1491,11 @@ === Dynamische Applikationserstellung Manche Situationen erfordern die Erstellung neuer Applikationen zur Laufzeit, ohne dass sie einer Konstanten zugeordnet werden. Dies lässt sich mit -`Sinatra.new` erreichen: +<tt>Sinatra.new</tt> erreichen: require 'sinatra/base' my_app = Sinatra.new { get('/') { "hallo" } } my_app.run! @@ -1729,16 +1534,17 @@ Der Geltungsbereich (Scope) legt fest, welche Methoden und Variablen zur Verfügung stehen. === Anwendungs- oder Klassen-Scope -Jede Sinatra-Anwendung entspricht einer Sinatra::Base-Subklasse. Falls die Top- -Level-DSL verwendet wird (<tt>require 'sinatra'</tt>), handelt es sich um -Sinatra::Application, andernfalls ist es jene Subklasse, die explizit angelegt -wurde. Auf Klassenebene stehen Methoden wie +get+ oder +before+ zur Verfügung, -es gibt aber keinen Zugriff auf das +request+-Object oder die +session+, da nur -eine einzige Klasse für alle eingehenden Anfragen genutzt wird. +Jede Sinatra-Anwendung entspricht einer <tt>Sinatra::Base</tt>-Subklasse. Falls +die Top- Level-DSL verwendet wird (<tt>require 'sinatra'</tt>), handelt es sich +um <tt>Sinatra::Application</tt>, andernfalls ist es jene Subklasse, die +explizit angelegt wurde. Auf Klassenebene stehen Methoden wie +get+ oder ++before+ zur Verfügung, es gibt aber keinen Zugriff auf das +request+-Object +oder die +session+, da nur eine einzige Klasse für alle eingehenden Anfragen +genutzt wird. Optionen, die via +set+ gesetzt werden, sind Methoden auf Klassenebene: class MyApp < Sinatra::Base # Hey, ich bin im Anwendungsscope! @@ -1846,28 +1652,29 @@ [ Rubinius ] Rubinius (rbx >= 1.2.3) wird offiziell unter Einbezug aller Templates unterstützt. [ JRuby ] - JRuby wird offiziell unterstützt (JRuby >= 1.6.0). Probleme mit Template- + JRuby wird offiziell unterstützt (JRuby >= 1.6.1). Probleme mit Template- Bibliotheken Dritter sind nicht bekannt. Falls JRuby zum Einsatz kommt, sollte aber darauf geachtet werden, dass ein JRuby-Rack-Handler zum Einsatz kommt – der Thin-Web-Server wird bisher nicht unterstütz. JRubys Unterstützung für C-Erweiterungen sind zur Zeit noch experimenteller Natur, - betrifft im Moment aber nur RDiscount. + betrifft im Moment aber nur RDiscount und Redcarpet. -<b>Ruby 1.8.6 wird nicht weiter unterstützt.</b> +<b>Ruby 1.8.6 wird nicht weiter unterstützt.</b> Falls Sinatra trotzdem unter +1.8.6 eingesetzt wird, muss Sinatra 1.2 verwendet werden, dass noch bis zum +Release von Sinatra 1.4.0 mit kleinen Bugfixes versorgt werden wird. Weiterhin werden wir auf kommende Ruby-Versionen ein Auge haben. -Die nachfolgend aufgeführten Ruby-Implementationen werden offiziell nicht von +Die nachfolgend aufgeführten Ruby-Implementierungen werden offiziell nicht von Sinatra unterstützt, funktionieren aber normalerweise: * Ältere Versionen von JRuby und Rubinius * MacRuby, Maglev, IronRuby * Ruby 1.9.0 und 1.9.1 -* Ruby 1.8.6 mit {backports}[https://github.com/marcandre/backports/#readme] Nicht offiziell unterstützt bedeutet, dass wenn Sachen nicht funktionieren, wir davon ausgehen, dass es nicht an Sinatra sondern an der jeweiligen Implentierung liegt. @@ -1962,16 +1769,17 @@ == Mehr * {Projekt-Website}[http://sinatra.github.com/] - Ergänzende Dokumentation, News und Links zu anderen Ressourcen. -* {Hilfe beisteuern}[http://sinatra.github.com/contributing.html] - Einen +* {Mitmachen}[http://sinatra.github.com/contributing.html] - Einen Fehler gefunden? Brauchst du Hilfe? Hast du einen Patch? * {Issue-Tracker}[http://github.com/sinatra/sinatra/issues] * {Twitter}[http://twitter.com/sinatra] * {Mailing-Liste}[http://groups.google.com/group/sinatrarb] * {IRC: #sinatra}[irc://chat.freenode.net/#sinatra] auf http://freenode.net - +* {Sinatra Book}[http://sinatra-book.gittr.com] Kochbuch Tutorial +* {Sinatra Book Contrib}[http://sinatra-book-contrib.com/] Sinatra-Rezepte aus + der Community * API Dokumentation für die {aktuelle Version}[http://rubydoc.info/gems/sinatra] oder für {HEAD}[http://rubydoc.info/github/sinatra/sinatra] auf http://rubydoc.info -