sinatra 1.3.0.d → 1.3.0.e

data/.gitignore

@@ -0,0 +1,6 @@
+# please add general patterns to your global ignore list
+# see https://github.com/github/gitignore#readme
+
+/pkg
+/doc/api
+/Gemfile.lock

data/.yardopts

@@ -0,0 +1,4 @@
+--readme README.rdoc
+--title 'Sinatra API Documentation'
+--charset utf-8
+'lib/**/*.rb' - '*.rdoc'

data/CHANGES

@@ -10,22 +10,99 @@
    explicitly to prevent that behavior. (Magnus Holm, Ryan Tomayko, Konstantin
    Haase)
 
+ * Patterns now match against the escaped URLs rather than the unescaped
+   version. This makes Sinatra confirm with RFC 2396 section 2.2 and RFC 2616
+   section 3.2.3 (escaped reserved characters should not be treated like the
+   unescaped version), meaning that "/:name" will also match `/foo%2Fbar`, but
+   not `/foo/bar`. To avoid incompatibility, pattern matching has been adjusted.
+   Moreover, since we do no longer need to keep an unescaped version of
+   path_info around, we handle all changes to `env['PATH_INFO']` correctly.
+   (Konstantin Haase)
+
+ * `settings.app_file` now defaults to the file subclassing `Sinatra::Base` in
+   modular applications. (Konstantin Haase)
+
  * Set up `Rack::Logger` or `Rack::NullLogger` depending on whether logging
    was enabled or not. Also, expose that logger with the `logger` helper
    method. (Konstantin Haase)
 
  * The sessions setting now may be an options hash. (Konstantin Haase)
 
- * Important: 1.8.6 support has been dropped. It is still usable if you use the
-   backports gem, but no longer officially supported. (Konstantin Haase)
+ * Important: 1.8.6 support has been dropped. This version also depends on at
+   least Rack 1.3.0. This means that it is incompatible to Rails prior to 3.1.0.
+   Please use 1.2.x if you require an earlier version for Ruby or Rack, which we
+   will continue to supply with bug fixes. (Konstantin Haase)
 
  * It is now possible to use a different target class for the top level DSL (aka
    classic style) than `Sinatra::Application` by setting `Delegator.target`.
    This was mainly introduced to ease testing. (Konstantin Haase)
 
+ * Error handlers defined for an error class will now also handle subclasses of
+   that class, unless more specific error handlers exist. (Konstantin Haase)
+
+ * Error handling respects Exception#code, again. (Konstantin Haase)
+
+ * Changing a setting will merge hashes: `set(:x, :a => 1); set(:x :b => 2)`
+   will result in `{:a => 1, :b => 2}`. Use `set(:x, {:a => 1}, true)` to avoid
+   this behavior. (Konstantin Haase)
+
  * Added `request.accept?` and `request.preferred_type` to ease dealing with
    `Accept` headers. (Konstantin Haase)
 
+ * Uses SecureRandom to generate default session secret. (Konstantin Haase)
+
+ * `Sinatra.run!` now prints to stderr rather than stdout. (Andrew Armenia)
+
+ * Automatic `app_file` detection now works in directories containing brackets
+   (Konstantin Haase)
+
+ * Improved documentation. (Emanuele Vicentini, Peter Higgins, Takanori
+   Ishikawa, Konstantin Haase)
+
+ * Also specify charset in Content-Type header for JSON. (Konstantin Haase)
+
+ * Rack handler names will not be converted to lower case internally, this
+   allows you to run Sinatra with custom Rack handlers, like Kirk or Mongrel2.
+   Example: `ruby app.rb -s Mongrel2` (Konstantin Haase)
+
+ * Middleware setup is now distributed across multiple methods, allowing Sinatra
+   extensions to easily hook into the setup process. (Konstantin Haase)
+
+ * Internal refactoring and minor performance improvements. (Konstantin Haase)
+
+= 1.2.7 (backports release) / Not Yet Released
+
+Custom changes:
+
+ * Fix Ruby 1.8.6 issue with Accept header parsing. (Konstantin Haase)
+
+Backported from 1.3.0:
+
+ * `Sinatra.run!` now prints to stderr rather than stdout. (Andrew Armenia)
+
+ * Automatic `app_file` detection now works in directories containing brackets
+   (Konstantin Haase)
+
+ * Improved documentation. (Emanuele Vicentini, Peter Higgins, Takanori
+   Ishikawa, Konstantin Haase)
+
+ * Also specify charset in Content-Type header for JSON. (Konstantin Haase)
+
+ * Rack handler names will not be converted to lower case internally, this
+   allows you to run Sinatra with custom Rack handlers, like Kirk or Mongrel2.
+   Example: `ruby app.rb -s Mongrel2` (Konstantin Haase)
+
+ * Fix uninitialized instance variable warning. (David Kellum)
+
+= 1.2.6 / 2011-05-01
+
+ * Fix broken delegation, backport delegation tests from Sinatra 1.3.
+   (Konstantin Haase)
+
+= 1.2.5 / 2011-04-30
+
+ * Restore compatibility with Ruby 1.8.6. (Konstantin Haase)
+
 = 1.2.4 / 2011-04-30
 
  * Sinatra::Application (classic style) does not use a session secret in
@@ -149,7 +226,7 @@
  * Sinatra now ships with a Gemfile for development dependencies, since it eases
    supporting different platforms, like JRuby. (Konstantin Haase)
 
-= 1.1.4 / 2011-04-13
+= 1.1.4 (backports release) / 2011-04-13
 
  * Compatible with Tilt 1.3. (Konstantin Haase)
 

data/Gemfile

@@ -7,40 +7,46 @@
 # If you have issues with a gem: `bundle install --without-coffee-script`.
 
 RUBY_ENGINE = 'ruby' unless defined? RUBY_ENGINE
-TILT_REPO = "git://github.com/rtomayko/tilt.git"
-
 source :rubygems unless ENV['QUICK']
-gemspec
 
 gem 'rake'
 gem 'rack-test', '>= 0.5.6'
 
 # Allows stuff like `tilt=1.2.2 bundle install` or `tilt=master ...`.
 # Used by the CI.
-tilt = (ENV['tilt'] || 'stable').dup
-tilt.sub! 'tilt-', ''
-if tilt != 'stable'
-  tilt = {:git => TILT_REPO, :branch => tilt} unless tilt =~ /(\d+\.)+\d+/
-  gem 'tilt', tilt
+github = "git://github.com/%s.git"
+repos = { 'tilt' => github % "rtomayko/tilt", 'rack' => github % "rack/rack" }
+%w[tilt rack].each do |lib|
+  dep = (ENV[lib] || 'stable').sub "#{lib}-", ''
+  dep = nil if dep == 'stable'
+  dep = {:git => repos[lib], :branch => dep} if dep and dep !~ /(\d+\.)+\d+/
+  gem lib, dep
 end
 
 gem 'haml', '>= 3.0', :group => 'haml'
 gem 'sass', :group => 'sass'
 gem 'builder', :group => 'builder'
 gem 'erubis', :group => 'erubis'
-gem 'less', :group => 'less'
+gem 'less', '~> 1.0', :group => 'less'
 gem 'liquid', :group => 'liquid'
-gem 'nokogiri', :group => 'nokogiri'
 gem 'slim', :group => 'slim'
-gem 'RedCloth', :group => 'redcloth'
+gem 'RedCloth', :group => 'redcloth' if RUBY_VERSION < "1.9.3" and not RUBY_ENGINE.start_with? 'ma'
 gem 'coffee-script', '>= 2.0', :group => 'coffee-script'
 gem 'rdoc', :group => 'rdoc'
 gem 'kramdown', :group => 'kramdown'
 gem 'maruku', :group => 'maruku'
 gem 'creole', :group => 'creole'
 
-platforms :ruby do
+gem 'nokogiri', :group => 'nokogiri' if RUBY_ENGINE != 'maglev'
+#nokogiri_options = {:group => 'nokogiri'}
+#nokogiri_options[:git] = "https://github.com/MagLev/nokogiri.git" if RUBY_ENGINE == 'maglev'
+#gem 'nokogiri', nokogiri_options if RUBY_ENGINE != 'maglev'
+
+unless RUBY_ENGINE == 'jruby' && JRUBY_VERSION < "1.6.1"
+  # C extensions
   gem 'rdiscount', :group => 'rdiscount'
+  gem 'redcarpet', :group => 'redcarpet'
+
   ## bluecloth is broken
   #gem 'bluecloth', :group => 'bluecloth'
 end

data/README.de.rdoc

@@ -44,7 +44,7 @@ definiert. Jeder dieser Routen wird ein Ruby-Block zugeordnet:
   end
   
   options '/' do
-    .. lege etwas fest ..
+    .. zeige, was wir können ..
   end
 
 Die Routen werden in der Reihenfolge durchlaufen, in der sie definiert wurden.
@@ -78,6 +78,12 @@ Routen-Muster können auch mit Splat- oder Wildcard-Parametern über das
     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
@@ -221,420 +227,213 @@ 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.
-
-=== Haml-Templates
-
-Das +haml+-Gem wird benötigt, um Haml-Templates rendern zu können:
-
-  # haml muss eingebunden werden
-  require 'haml'
-
-  get '/' do
-    haml :index
-  end
-
-Dieser Code rendert <tt>./views/index.haml</tt>.
-
-{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.
-
-  set :haml, :format => :html5 # Standard-Haml-Format ist :xhtml
-
-  get '/' do
-    haml :index, :format => :html4 # überschrieben
-  end
-
-=== Erb-Templates
-
-  # erb muss eingebunden werden
-  require 'erb'
-
-  get '/' do
-    erb :index
-  end
-
-Dieser Code rendert <tt>./views/index.erb</tt>.
-
-=== Erubis
-
-Das +erubis+-Gem wird benötigt, um Erubis-Templates rendern zu können:
-
-  # erbubis muss eingebunden werden
-  require 'erubis'
-
-  get '/' do
-    erubis :index
-  end
-
-Dieser Code rendert <tt>./views/index.erubis</tt>.
-
-Es ist auch möglich, Erb durch Erubis zu ersetzen:
-
-  require 'erubis'
-  Tilt.register :erb, Tilt[:erubis]
-  
-  get '/' do
-    erb :index
-  end
-
-Dieser Code rendert ebenfalls <tt>./views/index.erb</tt>.
-
-=== Builder-Templates
+Es ist zu beachten, dass immer mit Symbolen auf Templates verwiesen werden 
+muss, auch dann, wenn sie sich in einem Unterordner befinden:
 
-Das +builder+-Gem wird benötigt, um Builder-Templates rendern zu können:
+  haml :'unterverzeichnis/template'
 
-  # builder muss eingebunden werden
-  require 'builder'
-
-  get '/' do
-    builder :index
-  end
-
-Dieser Code rendert <tt>./views/index.builder</tt>.
-
-=== Nokogiri-Templates
-
-Das +nokogiri+-Gem wird benötigt, um Nokogiri-Templates rendern zu können:
-
-  # nokogiri muss eingebunden werden
-  require 'nokogiri'
-
-  get '/' do
-    nokogiri :index
-  end
-
-Dieser Code rendert <tt>./views/index.nokogiri</tt>.
-
-=== Sass-Templates
-
-Das +haml+- oder +sass+-Gem wird benötigt, um Sass-Templates rendern zu können:
-
-  # sass muss eingebunden werden
-  require 'sass'
-
-  get '/stylesheet.css' do
-    sass :stylesheet
-  end
-
-Dieser Code rendert <tt>./views/stylesheet.sass</tt>.
-
-{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.
-
-  set :sass, :style => :compact # Standard Sass-Style ist :nested
-
-  get '/stylesheet.css' do
-    sass :stylesheet, :style => :expanded # überschrieben
-  end
-
-=== SCSS-Templates
-
-Das +haml+- oder +sass+-Gem wird benötigt, um SCSS-Templates rendern zu können:
-
-  # sass muss eingebunden werden
-  require 'sass'
-
-  get '/stylesheet.css' do
-    scss :stylesheet
-  end
-
-Dieser Code rendert <tt>./views/stylesheet.scss</tt>.
-
-{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.
-
-  set :scss, :style => :compact # Standard-SCSS-Style ist :nested
-
-  get '/stylesheet.css' do
-    scss :stylesheet, :style => :expanded # überschrieben
-  end
-
-=== Less-Templates
-
-Das +less+-Gem wird benötigt, um Less-Templates rendern zu können:
-
-  # less muss eingebunden werden
-  require 'less'
-
-  get '/stylesheet.css' do
-    less :stylesheet
-  end
-
-Dieser Code rendert <tt>./views/stylesheet.less</tt>.
-
-=== Liquid-Templates
-
-Das +liquid+-Gem wird benötigt, um Liquid-Templates rendern zu können:
-
-  # liquid muss eingebunden werden
-  require 'liquid'
-
-  get '/' do
-    liquid :index
-  end
-
-Dieser Code rendert <tt>./views/index.liquid</tt>.
-
-Da aus Liquid-Templates heraus keine Methoden (abgesehen von +yield+) 
-aufgerufen werden können, ist es möglich, +locals+ zu übergeben:
-
-  liquid :index, :locals => { :key => 'value' }
-
-=== Markdown-Templates
-
-Das +rdiscount+-Gem wird benötigt, um Markdown-Templates rendern zu können:
-
-  # rdiscount muss eingebunden werden
-  require "rdiscount"
-
-  get '/' do
-    markdown :index
-  end
-
-Dieser Code rendert <tt>./views/index.markdown</tt> (+md+ und +mkd+ sind
-ebenfalls zulässige Dateiendungen).
-
-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:
+Rendering-Methoden rendern jeden String direkt.
 
-  # redcloth muss eingebunden werden
-  require "redcloth"
+=== Verfügbare Templatesprachen
 
-  get '/' do
-    textile :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.textile</tt>.
+  require 'rdiscount' # oder require 'bluecloth'
+  get('/') { markdown :index }
 
-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:
+=== Haml Templates
 
-  erb :overview, :locals => { :text => textile(:introduction) }
+Abhängigkeit::        {haml}[http://haml-lang.com/]
+Dateierweiterungs::   <tt>.haml</tt>
+Beispiel::           <tt>haml :index, :format => :html5</tt>
 
-Es ist auch möglich, die +textile+-Methode aus anderen Templates heraus
-aufzurufen:
+=== Erb Templates
 
-  %h1 Hallo von Haml!
-  %p= textile(:greetings)
+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>
 
-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:
+=== Builder Templates
 
-  get '/' do
-    textile :index, :layout_engine => :erb
-  end
+Abhängigkeit::        {builder}[http://builder.rubyforge.org/]
+Dateierweiterungs::   <tt>.builder</tt>
+Beispiel::           <tt>builder { |xml| xml.em "Hallo" }</tt>
 
-Das wird <tt>./views/index.textile</tt> mit <tt>./views/layout.erb</tt> als 
-Layout rendern.
+Nimmt ebenso einen Block für Inline-Templates entgegen (siehe Beispiel).
 
-Denk daran, dass solche Einstellungen auch global gesetzt werden können:
+=== Nokogiri Templates
 
-  set :textile, :layout_engine => :haml, :layout => :post
+Abhängigkeit::        {nokogiri}[http://nokogiri.org/]
+Dateierweiterungs::   <tt>.nokogiri</tt>
+Beispiel::           <tt>nokogiri { |xml| xml.em "Hallo" }</tt>
 
-  get '/' do
-    textile :index
-  end
+Nimmt ebenso einen Block für Inline-Templates entgegen (siehe Beispiel).
 
-Das wird <tt>./views/index.textile</tt> (und jedes andere Markdown-Template)
-mit <tt>./views/post.haml</tt> als Layout rendern.
+=== Sass Templates
 
-=== RDoc-Templates
+Abhängigkeit::        {sass}[http://sass-lang.com/]
+Dateierweiterungs::   <tt>.sass</tt>
+Beispiel::           <tt>sass :stylesheet, :style => :expanded</tt>
 
-Das +rdoc+-Gem wird benötigt, um RDoc-Templates rendern zu können:
+=== SCSS Templates
 
-  # rdoc/markup/to_html muss eingebunden werden
-  require "rdoc/markup/to_html"
+Abhängigkeit::        {sass}[http://sass-lang.com/]
+Dateierweiterungs::   <tt>.scss</tt>
+Beispiel::           <tt>scss :stylesheet, :style => :expanded</tt>
 
-  get '/' do
-    rdoc :index
-  end
+=== Less Templates
 
-Dieser Code rendert <tt>./views/index.rdoc</tt>.
+Abhängigkeit::        {less}[http://www.lesscss.org/]
+Dateierweiterungs::   <tt>.less</tt>
+Beispiel::           <tt>less :stylesheet</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:
+=== Liquid Templates
 
-  erb :overview, :locals => { :text => rdoc(:introduction) }
+Abhängigkeit::        {liquid}[http://www.liquidmarkup.org/]
+Dateierweiterungs::   <tt>.liquid</tt>
+Beispiel::           <tt>liquid :index, :locals => { :key => 'Wert' }</tt>
 
-Es ist auch möglich, die +rdoc+-Methode aus anderen Templates heraus
-aufzurufen:
+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.
 
-  %h1 Hallo von Haml!
-  %p= rdoc(:greetings)
+=== Markdown Templates
 
-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:
+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>
 
-  get '/' do
-    rdoc :index, :layout_engine => :erb
-  end
+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:
 
-Das wird <tt>./views/index.rdoc</tt> mit <tt>./views/layout.erb</tt> als Layout
-rendern.
+  erb :overview, :locals => { :text => markdown(:einfuehrung) }
 
-Denk daran, dass solche Einstellungen auch global gesetzt werden können:
+Beachte, dass man die +markdown+-Methode auch aus anderen Templates heraus
+aufrufen kann:
 
-  set :rdoc, :layout_engine => :haml, :layout => :post
+  %h1 Gruß von Haml!
+  %p= markdown(:Grüsse)
 
-  get '/' do
-    rdoc :index
-  end
+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 wird <tt>./views/index.rdoc</tt> (und jedes andere Markdown-Template) mit
-<tt>./views/post.haml</tt> als Layout rendern.
+=== Textile Templates
 
-=== Radius-Templates
+Abhängigkeit::        {RedCloth}[http://redcloth.org/]
+Dateierweiterungs::   <tt>.textile</tt>
+Beispiel::           <tt>textile :index, :layout_engine => :erb</tt>
 
-Das +radius+-Gem wird benötigt, um Radius-Templates rendern zu können:
+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:
 
-  # radius muss eingebunden werden
-  require 'radius'
+  erb :overview, :locals => { :text => textile(:einfuehrung) }
 
-  get '/' do
-    radius :index
-  end
+Beachte, dass man die +textile+-Methode auch aus anderen Templates heraus
+aufrufen kann:
 
-Dieser Code rendert <tt>./views/index.radius</tt>.
+  %h1 Gruß von Haml!
+  %p= textile(:Grüsse)
 
-Da aus Radius-Templates heraus keine Methoden (abgesehen von +yield+) 
-aufgerufen werden können, es es möglich, +locals+ zu übergeben:
+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.
 
-  radius :index, :locals => { :key => 'value' }
+=== RDoc Templates
 
-=== Markaby-Templates
+Abhängigkeit::        {rdoc}[http://rdoc.rubyforge.org/]
+Dateierweiterungs::   <tt>.rdoc</tt>
+Beispiel::           <tt>textile :README, :layout_engine => :erb</tt>
 
-Das +markaby+-Gem wird benötigt, um Markaby-Templates rendern zu können:
+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:
 
-  # markaby muss eingebunden werden
-  require 'markaby'
+  erb :overview, :locals => { :text => rdoc(:einfuehrung) }
 
-  get '/' do
-    markaby :index
-  end
+Beachte, dass man die +rdoc+-Methode auch aus anderen Templates heraus
+aufrufen kann:
 
-Dieser Code rendert <tt>./views/index.mab</tt>.
+  %h1 Gruß von Haml!
+  %p= rdoc(:Grüße)
 
-=== Slim-Templates
+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.
 
-Das +slim+-Gem wird benötigt, um Slim-Templates rendern zu können:
+=== Radius Templates
 
-  # slim muss eingebunden werden
-  require 'slim'
+Abhängigkeit::        {radius}[http://radius.rubyforge.org/]
+Dateierweiterungs::   <tt>.radius</tt>
+Beispiel::           <tt>radius :index, :locals => { :key => 'Wert' }</tt>
 
-  get '/' do
-    slim :index
-  end
+Da man aus dem Radius-Template heraus keine Ruby-Methoden aufrufen kann, wird
+man üblicherweise locals verwenden wollen, mit denen man Variablen weitergibt.
 
-Dieser Code rendert <tt>./views/index.slim</tt>.
+=== Markaby Templates
 
-=== Creole-Templates
+Abhängigkeit::        {markaby}[http://markaby.github.com/]
+Dateierweiterungs::   <tt>.mab</tt>
+Beispiel::           <tt>markaby { h1 "Willkommen!" }</tt>
 
-Das +creole+-Gem wird benötigt, um Creole-Templates rendern zu können:
+Nimmt ebenso einen Block für Inline-Templates entgegen (siehe Beispiel).
 
-  # creole muss eingebunden werden
-  require 'creole'
+=== Slim Templates
 
-  get '/' do
-    creole :index
-  end
+Abhängigkeit::        {slim}[http://slim-lang.com/]
+Dateierweiterungs::   <tt>.slim</tt>
+Beispiel::           <tt>slim :index</tt>
 
-Dieser Code rendert <tt>./views/index.creole</tt>.
+=== Creole Templates
 
-=== CoffeeScript-Templates
+Abhängigkeit::        {creole}[https://github.com/minad/creole]
+Dateierweiterungs::   <tt>.creole</tt>
+Beispiel::           <tt>creole :wiki, :layout_engine => :erb</tt>
 
-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:
+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:
 
-* +node+ (von Node.js) befindet sich im Pfad
-* du bist unter OS X
-* +therubyracer+ gem/library
+  erb :overview, :locals => { :text => creole(:einfuehrung) }
 
-Siehe auch http://github.com/josh/ruby-coffee-script für eine vollständige
-Liste aller Optionen.
+Beachte, dass man die +creole+-Methode auch aus anderen Templates heraus
+aufrufen kann:
 
-Nun können CoffeeScript-Templates in der Applikation gerendert werden:
+  %h1 Gruß von Haml!
+  %p= creole(:Grüße)
 
-  # coffee-script muss eingebunden werden
-  require 'coffee-script'
+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.
 
-  get '/application.js' do
-    coffee :application
-  end
+=== CoffeeScript Templates
 
-Dieser Code rendert <tt>./views/application.coffee</tt>.
+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>
 
-=== Inline-Templates
+=== Eingebettete Templates
 
   get '/' do
     haml '%div.title Hallo Welt'
   end
 
-Rendert den Inline-Template-String.
+Rendert den eingebetteten Template-String.
 
 === Auf Variablen in Templates zugreifen
 
@@ -650,7 +449,7 @@ 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
@@ -702,7 +501,7 @@ 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
@@ -968,8 +767,10 @@ 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
@@ -1478,10 +1279,17 @@ 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'
@@ -1510,9 +1318,6 @@ werden. {Rack::Test}[http://gitrdoc.com/brynary/rack-test] wird empfohlen:
     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 
@@ -1521,9 +1326,9 @@ 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'
 
@@ -1543,15 +1348,15 @@ 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
@@ -1581,7 +1386,7 @@ 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
@@ -1610,7 +1415,7 @@ 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:
@@ -1630,7 +1435,7 @@ Schreibe eine Anwendungsdatei:
 
 sowie eine dazugehörige <tt>config.ru</tt>-Datei:
 
-  require 'app'
+  require './app'
   run Sinatra::Application
 
 === Wann sollte eine config.ru-Datei verwendet werden?
@@ -1663,7 +1468,7 @@ andere Sinatra-Anwendung handeln, es kann jede andere Rack-Anwendung sein
     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'
@@ -1688,7 +1493,7 @@ andere Sinatra-Anwendung handeln, es kann jede andere Rack-Anwendung sein
 
 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" } }
@@ -1731,12 +1536,13 @@ 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:
 
@@ -1848,24 +1654,25 @@ Die folgenden Versionen werden offiziell unterstützt:
   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 
@@ -1964,14 +1771,15 @@ SemVer und SemVerTag.
 
 * {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
-