sinatra 1.2.0 → 1.2.1

data/AUTHORS

@@ -54,3 +54,5 @@ and last but not least:
 
 * Frank Sinatra (chairman of the board) for having so much class he
   deserves a web-framework named after him.
+
+For a complete list of all contributors to Sinatra itself, run `rake authors`.

data/CHANGES

@@ -1,3 +1,16 @@
+= 1.2.1 / 2011-03-17
+
+ * Use a generated session secret when using `enable :sessions`. (Konstantin
+   Haase)
+
+ * Fixed a bug where the wrong content type was used if no content type was set
+   and a template engine was used with a different engine for the layout with
+   different default content types, say Less embedded in Slim. (Konstantin
+   Haase)
+
+ * README translations improved (Gabriel Andretta, burningTyger, Sylvain Desvé,
+   Gregor Schmidt)
+
 = 1.2.0 / 2011-03-03
 
  * Added `slim` rendering method for rendering Slim templates. (Steve

data/Gemfile

@@ -21,6 +21,7 @@ gem 'less', :group => 'less'
 gem 'liquid', :group => 'liquid'
 gem 'nokogiri', :group => 'nokogiri'
 gem 'slim', :group => 'slim'
+gem 'RedCloth', :group => 'redcloth'
 
 
 if RUBY_VERSION > '1.8.6'
@@ -40,12 +41,6 @@ platforms :ruby_18, :jruby do
   gem 'radius', :group => 'radius'
 end
 
-platforms :mri do
-  # bundler platforms are broken
-  next unless RUBY_ENGINE == 'ruby'
-  gem 'RedCloth', :group => 'redcloth'
-end
-
 platforms :mri_18 do
   # bundler platforms are broken
   next unless RUBY_ENGINE == 'ruby'

data/README.de.rdoc

@@ -18,10 +18,13 @@ Einfach via +rubygems+ installieren und starten:
 
 Die Seite kann nun unter http://localhost:4567 betrachtet werden.
 
+Es wird empfohlen den Thin Server via <tt>gem install thin</tt> zu installieren,
+den Sinatra, soweit vorhanden, dann automatisch verwendet.
+
 == Routen
 
 In Sinatra wird eine Route durch eine HTTP-Methode und ein URL-Muster
-definiert. Jeder dieser Routen wird ein Ruby-Block zugeordnet.
+definiert. Jeder dieser Routen wird ein Ruby-Block zugeordnet:
 
   get '/' do
     .. zeige etwas ..
@@ -62,7 +65,7 @@ Man kann auf diese auch mit Blockparametern zugreifen:
   end
 
 Routenmuster können auch mit Splat- oder Wildcardparametern über das
-<tt>params[:splat]</tt> Array angesprochen werden.
+<tt>params[:splat]</tt> Array angesprochen werden:
 
   get '/sag/*/zu/*' do
     # passt auf /sag/hallo/zu/welt
@@ -156,6 +159,46 @@ Damit lässt sich relativ einfach Streaming implementieren:
 
     get('/') { Stream.new }
 
+===Eigene Routenmuster 
+Wie oben schon beschrieben, ist Sinatra von Haus aus mit Unterstützung für 
+String Muster und Reguläre Ausdrücke zum Abgleichen von Routen ausgestattet.
+Das muss aber noch nicht alles sein, man kann ohne größeren Aufwand auch 
+eigene Routenmuster erstellen:
+
+  class AllButPattern
+    Match = Struct.new(:captures)
+
+    def initialize(except)
+      @except   = except
+      @captures = Match.new([])
+    end
+
+    def match(str)
+      @captures unless @except === str
+    end
+  end
+
+  def all_but(pattern)
+    AllButPattern.new(pattern)
+  end
+
+  get all_but("/index") do
+    # ...
+  end
+
+Beachte, dass das obige Beispiel etwas übertrieben wirkt. Es geht auch leichter:
+
+  get // do
+    pass if request.path_info == "/index"
+    # ...
+  end
+
+Oder unter Verwendung eines negativen look ahead:
+
+  get %r{^(?!/index$)} do
+    # ...
+  end
+
 == Statische Dateien
 
 Statische Dateien werden aus dem <tt>./public</tt> Ordner ausgeliefert. Es ist
@@ -407,6 +450,7 @@ Ebenso ist es möglich Markdown mit BlueCloth anstelle von RDiscount zu parsen:
   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:
@@ -460,7 +504,7 @@ mit <tt>./views/post.haml</tt> als Layout rendern.
 
 Das +rdoc+ gem wird benötigt, um RDoc-Templates rendern zu können:
 
-  # RDoc muss eingebunden werden
+  # rdoc/markup/to_html muss eingebunden werden
   require "rdoc/markup/to_html"
 
   get '/' do
@@ -643,13 +687,13 @@ werden:
   end
 
 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.
+verwendet. Durch <tt>:layout => false</tt> kann das Ausführen verhindert werden:
 
   get '/' do
     haml :index, :layout => !request.xhr?
   end
 
-=== Datieendungen zuordnen
+=== Dateiendungen zuordnen
 
 Um eine Dateiendung einer Template Engine zuzuordnen, benutzt man am besten
 <tt>Tilt.register</tt>. Wenn man zum Beispiel die Dateiendung +tt+ für Textile
@@ -673,7 +717,8 @@ Rendering-Methode erstellen:
   end
 
 Dieser Code rendert <tt>./views/application.mtt</tt>. Siehe
-https://github.com/rtomayko/tilt um mehr über Tilt zu lernen.
+github.com/rtomayko/tilt[https://github.com/rtomayko/tilt], 
+um mehr über Tilt zu lernen.
 
 == Filter
 
@@ -736,6 +781,44 @@ definiert, die in Routen und Templates verwendet werden können:
     bar(params[:name])
   end
 
+===Sessions verwenden
+Sessions werden verwendet, um Zustände zwischen den Requests zu speichern.
+Sind sie aktiviert, hat man einen Session Hash pro Benutzer Session:
+
+  enable :sessions
+
+  get '/' do
+    "value = " << session[:value].inspect
+  end
+
+  get '/:value' do
+    session[:value] = params[:value]
+  end
+
+Beachte, dass <tt>enable :sessions</tt> alle Daten in einem Cookie speichert.
+Unter Umständen kann dies negative Effekte haben, z.B. verursachen viele Daten
+höheren, teilweise überflüssigen Traffic. Um das zu vermeiden, kann man eine
+Rack Session Middleware verwenden. Dann aber *nicht* <tt>enable :sessions</tt>
+aufrufen, sondern die Middleware wie üblich in das Programm einbinden:
+
+  use Rack::Session::Pool, :expire_after => 2592000
+
+  get '/' do
+    "value = " << session[:value].inspect
+  end
+
+  get '/:value' do
+    session[:value] = params[:value]
+  end
+
+Um die Sicherheit zu erhöhen, werden Cookies, die Session-Daten führen, mit
+einem sogenannten Session Secret signiert. Da sich jedoch dieses Geheimwort
+bei jedem Neustart der Applikation automatisch ändert, ist es sinnvoll selber
+eins zu wählen, damit alle Instanzen der Applikation sich das gleiche Session
+Secret teilen:
+
+  set :session_secret, 'super secret'
+
 == Anhalten
 
 Zum sofortigen stoppen eines Request in einem Filter oder einer Route:
@@ -758,6 +841,10 @@ Sogar mit Headers:
 
   halt 402, {'Content-Type' => 'text/plain'}, 'Rache'
 
+Natürlich ist es auch möglich ein Template mit +halt+ zu verwenden:
+
+  halt erb(:error)
+
 == Weiterspringen
 
 Eine Route kann mittels <tt>pass</tt> zu der nächsten passenden Route springen:
@@ -868,7 +955,7 @@ werden:
     redirect to('/bar')
   end
 
-Weitere Parameter werden wie Argumente der +halt+ Methode behandelt:+:
+Weitere Parameter werden wie Argumente der +halt+ Methode behandelt:
 
   redirect to('/bar'), 303
   redirect 'http://google.com', 'Hier bist Du falsch'
@@ -987,6 +1074,23 @@ Der <tt>request.body</tt> ist einn IO- oder StringIO-Objekt:
     "Hallo #{daten['name']}!"
   end
 
+=== Anhänge
+
+Damit der Browser erkennt, dass ein Response gespeichert werden soll und nicht
+im Browser angezeigt wird, kann der +attachment+ Helfer verwendet werden:
+
+  get '/' do
+    attachment
+    "Speichern!"
+  end
+
+Ebenso kann man einen Dateinamen als Parameter hinzufügen:
+
+  get '/' do
+    attachment "info.txt"
+    "Speichern!"
+  end
+
 
 === Nachschlagen von Template Dateien
 
@@ -1232,7 +1336,7 @@ Alternativ kann ein Error Handler auch für Statuscode definiert werden:
 Oder ein Statuscode-Bereich:
 
   error 400..510 do
-    'Boom'
+    'Bums'
   end
 
 Sinatra setzt verschiedene <tt>not_found</tt> und <tt>error</tt>
@@ -1448,7 +1552,7 @@ Es ist nicht nur möglich andere Rack-Middleware mit Sinatra zu nutzen, man
 kann außerdem jede Sinatra-Anwendung selbst als Middlware vor jeden beliebigen
 Rack-Endpunkt hängen. Bei diesem Endpunkt muss es sich nicht um eine andere
 Sinatra-Anwendung handen, es kann jede andere Rack-Anwendung sein
-(Rails/Ramaze/Camping/...).
+(Rails/Ramaze/Camping/...):
 
   require 'sinatra/base'
 
@@ -1525,7 +1629,7 @@ Für jede eingehende Anfrage wird eine neue Instanz der Anwendungsklasse
 erstellt und alle Handlers werden in diesem Scope ausgeführt. Aus diesem Scope
 heraus kann man auf +request+ oder +session+ zugreifen und Methoden wie +erb+
 oder +haml+ aufrufen. Man kann mit der +settings+ Methode außerdem auf den
-Anwengungsscope zugreifen.
+Anwengungsscope zugreifen:
 
   class MyApp < Sinatra::Base
     # Hey, ich bin im Anwendungsscope!
@@ -1562,7 +1666,8 @@ anderes +self+). Man kann mit <tt>Sinatra::Delegator.delegate
 Im Delegation-Scop befindet man sich:
 
 * Im Top-Level, wenn man <tt>require 'sinatra'</tt> aufgerufen hat.
-* In einem Objekt, dass mit dem <tt>Sinatra::Delegator</tt> mixin erweitert wurde.
+* In einem Objekt, dass mit dem <tt>Sinatra::Delegator</tt> mixin erweitert 
+  wurde.
 
 Schau am besten im Code nach: Hier ist
 {Sinatra::Delegator mixin}[http://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L1064]
@@ -1584,6 +1689,59 @@ Die Optionen sind:
   -s # Rack Server/Handler setzen (Standard ist thin)
   -x # Mutex lock einschalten (Standard ist off)
 
+== Systemanforderungen
+
+Es wird empfohlen Sinatra unter Ruby 1.8.7, 1.9.2, JRuby oder Rubinius zu
+installieren.
+
+Die folgenden Versionen werden offiziell unterstützt:
+
+[ Ruby 1.8.6 ]
+  Es wird nicht empfohlen 1.8.6 für Sinatra einzusetzen. Trotzdem wird es
+  offiziell bis Sinatra 1.3.0 unterstützt werden. RDoc und CoffeeScript 
+  Templates werden in dieser Version nicht unterstützt. 1.8.6 hat ein größeres
+  Speicherleck in seiner Hash Implementation, das von Sinatra Versionen vor 
+  1.1.1 ausgelöst wird. Die aktuelle Version verhindert das zwar explizit, aber 
+  unter Einbussen in der Performance. Ebenso muss Sinatra mit Rack 1.1.x laufen,
+  da Rack >= 1.2 Ruby 1.8.6 nicht mehr unterstützt.
+
+[ Ruby 1.8.7 ]
+  1.8.7 wird vollständig unterstützt, aber solange nichts dagegen spricht, 
+  wird ein Update auf 1.9.2 oder ein Umstieg auf JRuby/Rubinius empfohlen.
+
+[ Ruby 1.9.2 ]
+  1.9.2 wird unterstützt und empfohlen. Beachte, dass Markaby und Radius
+  momentan noch nicht kompatibel sind mit 1.9. Version 1.9.0p0 sollte nicht
+  verwendet werden, da unter Sinatra immer wieder Segfaults auftreten.
+
+[ Rubinius ]
+  Rubinius (rbx >= 1.2.2) wird offiziell unter Ausnahme von Textile 
+  Templates unterstützt.
+
+[ JRuby ]
+  Jruby wird offiziell unterstützt (JRuby >= 1.5.6). 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 kommen – 
+  der Thin Web Server wird bisher noch nicht unterstütz.
+
+Weiterhin werden wir auf kommende Ruby Versionen ein Auge haben.
+
+Die nachfolgend aufgeführten Ruby Implementationen 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
+
+Nicht offiziell unterstützt bedeutet, dass wenn Sachen nicht funktionieren, 
+dann gehen wir davon aus, dass es nicht an Sinatra, sondern an der jeweiligen 
+Implentierung liegt.
+
+Sinatra sollte auf jedem Betriebssystem laufen, dass den gewählten Ruby 
+Interpreter unterstützt.
+
 == Der neueste Stand (The Bleeding Edge)
 Um auf dem neusten Stand zu bleiben, kannst Du den Master Branch verwenden. Er
 sollte recht stabil sein. Ebenso gibt es von Zeit zu Zeit prerelease Gems, die
@@ -1657,7 +1815,10 @@ so lauten:
 
   sudo rake install
 
+== Versionsverfahren
 
+Sinatra folgt dem sog. {Semantic Versioning}[http://semver.org/], d.h. SemVer 
+und SemVerTag.
 
 == Mehr
 
@@ -1669,3 +1830,4 @@ Fehler gefunden? Brauchst du Hilfe? Hast du einen Patch?
 * {Twitter}[http://twitter.com/sinatra]
 * {Mailingliste}[http://groups.google.com/group/sinatrarb]
 * {IRC: #sinatra}[irc://chat.freenode.net/#sinatra] auf http://freenode.net
+

data/README.es.rdoc

@@ -66,7 +66,7 @@ También podés acceder a los parámetros nombrados usando parámetros de bloque
   end
 
 Los patrones de ruta también pueden incluir parámetros splat (o wildcard),
-accesibles a través del arreglo <tt>params[:splat]</tt>.
+accesibles a través del arreglo <tt>params[:splat]</tt>:
 
   get '/decir/*/al/*' do
     # coincide con /decir/hola/al/mundo
@@ -165,11 +165,11 @@ definir tus propios comparadores muy fácilmente:
 
     def initialize(excepto)
       @excepto  = excepto
-      @caputras = Match.new([])
+      @capturas = Match.new([])
     end
 
     def match(str)
-      @caputras unless @excepto === str
+      @capturas unless @excepto === str
     end
   end
 
@@ -687,7 +687,7 @@ Las plantillas también pueden ser definidas usando el método top-level
 Si existe una plantilla con el nombre "layout", va a ser usada cada vez que
 una plantilla es renderizada. Podés desactivar los layouts individualmente
 pasando <tt>:layout => false</tt> o globalmente con
-<tt>set :haml, :layout => false</tt>.
+<tt>set :haml, :layout => false</tt>:
 
   get '/' do
     haml :index, :layout => !request.xhr?
@@ -816,6 +816,15 @@ pero con la salvedad de que *no* tenés que llamar a <tt>enable :sessions</tt>:
     session[:valor] = params[:valor]
   end
 
+Para incrementar la seguridad, los datos de la sesión almacenados en
+la cookie son firmados con un secreto de sesión.  Este secreto, es
+generado aleatoriamente por Sinatra.  De cualquier manera, hay que
+tener en cuenta que cada vez que inicies la aplicación se va a generar
+uno nuevo.  Así, si querés que todas las instancias de tu aplicación
+compartan un único secreto, tenés que definirlo vos:
+
+  set :session_secret, 'super secreto'
+
 === Interrupción
 
 Para detener inmediatamente una petición dentro de un filtro o una ruta usá:
@@ -997,7 +1006,7 @@ Podés asignar el encabezado Cache-Control fácilmente:
     "cachealo!"
   end
 
-Pro tip: configurar el cacheo en un filtro +before+.
+Pro tip: configurar el cacheo en un filtro +before+:
 
   before do
     cache_control :public, :must_revalidate, :max_age => 60
@@ -1013,7 +1022,7 @@ Si estás usando el helper +expires+ para definir el encabezado correspondiente,
 Para usar cachés adecuadamente, deberías considerar usar +etag+ y
 +last_modified+.  Es recomendable que llames a estos helpers *antes* de hacer
 cualquier trabajo pesado, ya que van a enviar la respuesta inmediatamente si
-el cliente ya tiene la versión actual en su caché.
+el cliente ya tiene la versión actual en su caché:
 
   get '/articulo/:id' do
     @articulo = Articulo.find params[:id]
@@ -1131,7 +1140,7 @@ El objeto <tt>request.body</tt> es una instancia de IO o StringIO:
 === Archivos Adjuntos
 
 Podés usar el método helper +attachment+ para indicarle al navegador que
-almacene la respuesta en el disco en lugar de mostrarla en pantalla.
+almacene la respuesta en el disco en lugar de mostrarla en pantalla:
 
   get '/' do
     attachment
@@ -1589,7 +1598,7 @@ iniciarla con <tt>config.ru</tt>.</b>
 Sinatra no solo es capaz de usar otro Rack middleware, sino que a su vez,
 cualquier aplicación Sinatra puede ser agregada delante de un endpoint Rack
 como middleware. Este endpoint puede ser otra aplicación Sinatra, o cualquier
-aplicación basada en Rack (Rails/Ramaze/Camping/...).
+aplicación basada en Rack (Rails/Ramaze/Camping/...):
 
   require 'sinatra/base'
 
@@ -1838,6 +1847,11 @@ Si instalás tus gems como root, el último paso debería ser
 
   sudo rake install
 
+== Versionado
+
+Sinatra utiliza el {Versionado Semántico}[http://semver.org/],
+siguiendo las especificaciones SemVer y SemVerTag.
+
 == Lecturas Recomendadas
 
 * {Sito web del proyecto}[http://www.sinatrarb.com/] - Documentación

data/README.fr.rdoc

@@ -1,5 +1,6 @@
 = Sinatra
-<i>Attention: Ce document correspond à la traduction de la version anglaise et il n'est peut être plus à jour.</i>
+<i>Attention: Ce document correspond à la traduction de la version anglaise et
+il n'est peut être plus à jour.</i>
 
 Sinatra est un DSL pour créer rapidement des applications web en Ruby et sans
 effort:
@@ -17,9 +18,13 @@ Installez le gem et lancez avec:
 
 Le résultat est visible sur: http://localhost:4567
 
+Il est également recommandé d'exécuter <tt>gem install thin</tt>, que Sinatra
+utilisera si disponible.
+
 == Routes
 
-Dans Sinatra, une route est une méthode HTTP couplée à un masque (pattern) URL.
+Dans Sinatra, une route est une méthode HTTP couplée à un masque (pattern)
+URL.
 Chaque route est associée à un bloc:
 
   get '/' do
@@ -38,11 +43,15 @@ Chaque route est associée à un bloc:
     .. effacer quelque chose ..
   end
 
-Les routes sont comparées dans l'ordre où elles ont été définies. La première route qui
-correspond à la requête est invoquée.
+  options '/' do
+    .. apaiser quelquechose ..
+  end
+
+Les routes sont comparées dans l'ordre où elles ont été définies. La première
+route qui correspond à la requête est invoquée.
 
-Les masques peuvent inclure des paramètres, accessibles par l'intermédiaire du
-hash <tt>params</tt>:
+Les masques peuvent inclure des paramètres nommés, accessibles par
+l'intermédiaire du hash <tt>params</tt>:
 
   get '/bonjour/:nom' do
     # répond aux requêtes "GET /bonjour/foo" et "GET /bonjour/bar"
@@ -50,14 +59,15 @@ hash <tt>params</tt>:
     "Bonjour #{params[:nom]}!"
   end
 
-Vous pouvez aussi les nommer directement dans les paramètres du bloc comme ceci:
+Vous pouvez aussi les nommer directement dans les paramètres du bloc comme
+ceci:
 
   get '/bonjour/:nom' do |n|
     "Bonjour #{n}!"
   end
 
-Une route peut contenir un splat (caractère joker), accessible par l'intermédiaire de
-la liste <tt>params[:splat]</tt>.
+Une route peut contenir un splat (caractère joker), accessible par
+l'intermédiaire de la liste <tt>params[:splat]</tt>:
 
   get '/dire/*/a/*' do
     # répondrait à /dire/bonjour/a/monde
@@ -83,7 +93,8 @@ Là aussi on peut utiliser les paramètres de bloc:
 
 === Conditions
 
-Les routes peuvent définir toutes sortes de conditions, comme par exemple le "user agent":
+Les routes peuvent définir toutes sortes de conditions, comme par exemple le
+"user agent":
 
   get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
     "Vous utilisez Songbird version #{params[:agent][0]}"
@@ -121,20 +132,24 @@ Vous pouvez facilement définir vos propres conditions:
 
 === Valeurs de retour
 
-La valeur de retour d'un bloc définissant une route détermine le corps de la réponse
-qui sera transmise au client HTTP ou du moins au prochain middleware dans la pile Rack.
-Le plus généralement, il s'agit d'une chaîne de caractères, comme dans les exemples
-précédents. Cependant, d'autres valeurs sont acceptées.
-
-Vous pouvez renvoyer n'importe quel objet qui soit une réponse Rack valide, un corps de
-réponse Rack ou un code retour HTTP:
-
-* Un tableau de 3 éléments: <tt>[code retour (Fixnum), entêtes (Hash), corps de réponse (répondant à #each)]</tt>
-* Un tableau de 2 élements: <tt>[code retour (Fixnum), corps de réponse (répondant à #each)]</tt>
-* Un objet qui répond à <tt>#each</tt> et qui ne transmet que des chaînes de caractères au bloc fourni
+La valeur de retour d'un bloc définissant une route détermine le corps de la
+réponse qui sera transmise au client HTTP ou du moins au prochain middleware
+dans la pile Rack. Le plus généralement, il s'agit d'une chaîne de caractères,
+comme dans les exemples précédents. Cependant, d'autres valeurs sont
+acceptées.
+
+Vous pouvez renvoyer n'importe quel objet qui soit une réponse Rack valide, un
+corps de réponse Rack ou un code retour HTTP:
+
+* Un tableau de 3 éléments: <tt>[code retour (Fixnum), entêtes (Hash), corps
+  de réponse (répondant à #each)]</tt>
+* Un tableau de 2 élements: <tt>[code retour (Fixnum), corps de réponse
+  (répondant à #each)]</tt>
+* Un objet qui répond à <tt>#each</tt> et qui ne transmet que des chaînes de
+  caractères au bloc fourni
 * Un Fixnum représentant le code retour
 
-Ainsi, on peut facilement implémenter un streaming par exemple:
+Ainsi, on peut facilement implémenter un streaming par exemple :
 
     class Stream
       def each
@@ -144,15 +159,59 @@ Ainsi, on peut facilement implémenter un streaming par exemple:
 
     get('/') { Stream.new }
 
+=== Masques de route spécifiques
+
+Comme montré plus haut, Sinatra embarque le support pour l'utilisation de
+masques utilisant des chaînes de caractères ou des expressions régulières
+pour définir les routes. Toutefois, cela ne s'arrête pas là. Vous pouvez
+facilement définir vos propres masques :
+
+  class MasqueToutSauf
+    Masque = Struct.new(:captures)
+
+    def initialize(except)
+      @except   = except
+      @captures = Masque.new([])
+    end
+
+    def match(str)
+      @caputres unless @except === str
+    end
+  end
+
+  def tout_sauf(masque)
+    MasqueToutSauf.new(masque)
+  end
+
+  get tout_sauf("/index") do
+    # ...
+  end
+
+Notez que l'exemple ci-dessus est bien trop compliqué et le même résultat
+peut être obtenu avec :
+
+  get // do
+    pass if request.path_info == "/index"
+    # ...
+  end
+
+Ou bien en utilisant la forme négative :
+
+  get %r{^(?!/index$)} do
+    # ...
+  end
+
 == Fichiers statiques
 
-Par défaut, le dossier <tt>./public</tt> est utilisé pour servir les fichiers statiques.
-Vous pouvez changer ce dossier pour un autre nom grâce à l'option <tt>:public</tt>:
+Par défaut, le dossier <tt>./public</tt> est utilisé pour servir les fichiers
+statiques. Vous pouvez changer ce dossier pour un autre nom grâce au paramètre
+<tt>:public</tt>:
 
   set :public, File.dirname(__FILE__) + '/statique'
 
-Notez que le nom du dossier public n'est pas inclus dans l'URL. Un fichier sous
-<tt>./public/css/style.css</tt> est appelé avec l'URL: <tt>http://exemple.com/css/style.css</tt>.
+Notez que le nom du dossier public n'est pas inclus dans l'URL. Un fichier
+sous <tt>./public/css/style.css</tt> est appelé avec l'URL :
+<tt>http://exemple.com/css/style.css</tt>.
 
 == Vues / Templates
 
@@ -163,13 +222,13 @@ Pour utiliser un autre dossier, il faut le déclarer:
 
 Il est important de noter que les templates sont toujours référencés
 sous forme de symboles, même s'il s'agit d'un sous-répertoire (dans ce
-cas, utilisez <tt>:'sous_repertoire/template'</tt>). Vous devez utiliser un symbole
-car les méthodes de rendu évalueront le contenu des chaînes de caractères
-au lieu de les considérer comme un chemin vers un fichier.
+cas, utilisez <tt>:'sous_repertoire/template'</tt>). Vous devez utiliser un
+symbole car les méthodes de rendu évalueront le contenu des chaînes de
+caractères au lieu de les considérer comme un chemin vers un fichier.
 
 === Templates Haml
 
-Le gem haml est nécessaire pour utiliser la fonction de rendu Haml:
+Le gem <tt>haml</tt> est nécessaire pour utiliser la fonction de rendu Haml:
 
   # Chargez la bibliothèque haml dans votre application
   require 'haml'
@@ -201,11 +260,12 @@ et supportent aussi la réécriture (surcharge) comme dans cet exemple.
     erb :index
   end
 
-Utilisera le template: <tt>./views/index.erb</tt>
+Utilisera le template: <tt>./views/index.erb</tt>.
 
-=== Erubis
+=== Templates Erubis
 
-Le gem erubis est nécessaire pour utiliser la fonction de rendu erubis:
+Le gem <tt>erubis</tt> est nécessaire pour utiliser la fonction de rendu
+erubis:
 
   # Chargez la bibliothèque erubis dans votre application
   require 'erubis'
@@ -216,9 +276,21 @@ Le gem erubis est nécessaire pour utiliser la fonction de rendu erubis:
 
 Utilisera le template: <tt>./views/index.erubis</tt>
 
+Il est également possible de remplacer Erb par Erubis:
+
+  require 'erubis'
+  Tilt.register :erb, Tilt[:erubis]
+
+  get '/' do
+    erb :index
+  end
+
+Utilisera le template <tt>./views/index.erb</tt> avec Erubis.
+
 === Templates Builder
 
-Le gem builder est nécessaire pour utiliser la fonction de rendu builder:
+Le gem <tt>builder</tt> est nécessaire pour utiliser la fonction de rendu
+builder:
 
   # Chargez la bibliothèque builder dans votre application
   require 'builder'
@@ -231,7 +303,8 @@ Utilisera le template: <tt>./views/index.builder</tt>.
 
 === Templates Nokogiri
 
-Le gem nokogiri est nécessaire pour utiliser la fonction de rendu nokogiri:
+Le gem <tt>nokogiri</tt> est nécessaire pour utiliser la fonction de rendu
+nokogiri:
 
   # Chargez la bibliothèque nokogiri dans votre application
   require 'nokogiri'
@@ -244,7 +317,8 @@ Utilisera le template: <tt>./views/index.nokogiri</tt>.
 
 === Templates Sass
 
-Le gem haml est nécessaire pour utiliser la fonction de rendu Sass:
+Le gem <tt>haml</tt> ou <tt>sass</tt> est nécessaire pour utiliser la fonction
+de rendu Sass:
 
   # Chargez la bibliothèque haml ou sass dans votre application
   require 'sass'
@@ -268,7 +342,8 @@ et supportent aussi la réécriture (surcharge) comme dans cet exemple.
 
 === Scss Templates
 
-Le gem haml est nécessaire pour utiliser la fonction de rendu Scss:
+Le gem <tt>haml</tt> ou <tt>sass</tt> est nécessaire pour utiliser la fonction
+de rendu Scss:
 
   # Chargez la bibliothèque haml ou sass dans votre application
   require 'sass'
@@ -292,7 +367,7 @@ et supportent aussi la réécriture (surcharge) comme dans cet exemple.
 
 === Templates Less
 
-Le gem less est nécessaire pour utiliser la fonction de rendu Less:
+Le gem <tt>less</tt> est nécessaire pour utiliser la fonction de rendu Less:
 
   # Chargez la bibliothèque less dans votre application
   require 'less'
@@ -305,7 +380,8 @@ Utilisera le template: <tt>./views/stylesheet.less</tt>.
 
 === Templates Liquid
 
-Le gem liquid est nécessaire pour utiliser la fonction de rendu Liquid:
+Le gem <tt>liquid</tt> est nécessaire pour utiliser la fonction de rendu
+Liquid:
 
   # Chargez la bibliothèque liquid dans votre application
   require 'liquid'
@@ -317,13 +393,15 @@ Le gem liquid est nécessaire pour utiliser la fonction de rendu Liquid:
 Utilisera <tt>./views/index.liquid</tt>.
 
 Comme vous ne pouvez pas appeler des méthodes Ruby (excepté +yield+) dans un
-template Liquid, il sera toujours nécessaire de lui passer des variables locales:
+template Liquid, il sera toujours nécessaire de lui passer des variables
+locales:
 
   liquid :index, :locals => { :key => 'value' }
 
 === Templates Markdown
 
-Le gem rdiscount est nécessaire pour utiliser la fonction de rendu Markdown:
+Le gem <tt>rdiscount</tt> est nécessaire pour utiliser la fonction de rendu
+Markdown:
 
   # Chargez la bibliothèque rdiscount dans votre application
   require "rdiscount"
@@ -332,23 +410,64 @@ Le gem rdiscount est nécessaire pour utiliser la fonction de rendu Markdown:
     markdown :index
   end
 
-Utilisera <tt>./views/index.markdown</tt> (les extensions de fichier +md+ et +mkd+
-sont également acceptées).
+Utilisera <tt>./views/index.markdown</tt> (les extensions de fichier +md+ et
++mkd+ sont également acceptées).
 
-Il n'est pas possible d'appeler des méthodes depuis markdown, ni même de lui passer des variables
-locales. Par conséquent, il sera le plus souvent utilisé en combinaison avec un autre moteur
-de rendu:
+Il n'est pas possible d'appeler des méthodes depuis markdown, ni même de lui
+passer des variables locales. Par conséquent, il sera le plus souvent utilisé
+en combinaison avec un autre moteur de rendu:
 
   erb :vuedensemble, :locals => { :texte => markdown(:introduction) }
 
-Notez que vous pouvez également appeler la méthode markdown au sein d'autres templates:
+Notez que vous pouvez également appeler la méthode +markdown+ au sein d'autres
+templates:
 
   %h1 Bonjour Depuis Haml!
   %p= markdown(:salutations)
 
+Comme vous ne pouvez pas faire d'appels Ruby au sein de Markdown, vous ne
+pouvez pas utiliser des layouts écrits en Markdown. Il est toutefois possible
+d'utiliser un autre moteur de rendu pour le layout en passant l'option
+<tt>:layout_engine</tt> :
+
+  get '/' do
+    markdown :index, :layout_engine => :erb
+  end
+
+Ceci utilisera <tt>./views/index.md</tt> avec <tt>./views/layout.erb</tt> pour
+layout.
+
+Souvenez vous que vous pouvez spécifier de telles options de rendu
+globalement :
+
+  set :markdown, :layout_engine => :haml, :layout => :post
+
+  get '/' do
+    markdown :index
+  end
+
+Ceci utilisera <tt>./views/index.md</tt> (et tout autre template Markdown)
+avec <tt>./views/post.haml</tt> pour layout.
+
+Il est également possible de traduire le Markdown avec BlueCloth plutôt que
+RDiscount :
+
+  require 'bluecloth'
+
+  Tilt.register 'markdown', BlueClothTemplate
+  Tilt.register 'mkd',      BlueClothTemplate
+  Tilt.register 'md',       BlueClothTemplate
+
+  get '/' do
+    markdown :index
+  end
+
+Utilisera <tt>./views/index.md</tt> avec BlueCloth.
+
 === Templates Textile
 
-Le gem RedCloth est nécessaire pour utiliser la fonction de rendu Textile:
+Le gem <tt>RedCloth</tt> est nécessaire pour utiliser la fonction de rendu
+Textile:
 
   # Chargez la bibliothèqye redcloth dans votre application
   require "redcloth"
@@ -359,20 +478,45 @@ Le gem RedCloth est nécessaire pour utiliser la fonction de rendu Textile:
 
 Utilisera <tt>./views/index.textile</tt>.
 
-Il n'est pas possible d'appeler des méthodes depuis textile, ni même de lui passer des variables
-locales. Par conséquent, il sera le plus souvent utilisé en combinaison avec un autre moteur
-de rendu:
+Il n'est pas possible d'appeler des méthodes depuis textile, ni même de lui
+passer des variables locales. Par conséquent, il sera le plus souvent utilisé
+en combinaison avec un autre moteur de rendu:
 
   erb :vuedensemble, :locals => { :texte => textile(:introduction) }
 
-Notez que vous pouvez également appeler la méthode textile au sein d'autres templates:
+Notez que vous pouvez également appeler la méthode +textile+ au sein d'autres
+templates:
 
   %h1 Bonjour Depuis Haml!
   %p= textile(:salutations)
 
+Comme vous ne pouvez pas faire d'appels Ruby au sein de Textile, vous ne
+pouvez pas utiliser des layouts écrits en Textile. Il est toutefois possible
+d'utiliser un autre moteur de rendu pour le layout en passant l'option
+<tt>:layout_engine</tt> :
+
+  get '/' do
+    textile :index, :layout_engine => :erb
+  end
+
+Ceci utilisera <tt>./views/index.textile</tt> avec <tt>./views/layout.erb</tt>
+pour layout.
+
+Souvenez vous que vous pouvez spécifier de telles options de rendu
+globalement :
+
+  set :textile, :layout_engine => :haml, :layout => :post
+
+  get '/' do
+    textile :index
+  end
+
+Ceci utilisera <tt>./views/index.textile</tt> (et tout autre template Textile)
+avec <tt>./views/post.haml</tt> pour layout.
+
 === Templates RDoc
 
-Le gem RDoc est nécessaire pour utiliser la fonction de rendu RDoc:
+Le gem <tt>rdoc</tt> est nécessaire pour utiliser la fonction de rendu RDoc:
 
   # Chargez la bibliothèque rdoc/markup/to_html dans votre application
   require "rdoc/markup/to_html"
@@ -383,22 +527,47 @@ Le gem RDoc est nécessaire pour utiliser la fonction de rendu RDoc:
 
 Utilisera <tt>./views/index.rdoc</tt>.
 
-Il n'est pas possible d'appeler des méthodes depuis rdoc, ni même de lui passer des variables
-locales. Par conséquent, il sera le plus souvent utilisé en combinaison avec un autre moteur
-de rendu:
+Il n'est pas possible d'appeler des méthodes depuis rdoc, ni même de lui
+passer des variables locales. Par conséquent, il sera le plus souvent utilisé
+en combinaison avec un autre moteur de rendu:
 
   erb :vuedensemble, :locals => { :texte => rdoc(:introduction) }
 
-Notez que vous pouvez également appeler la méthode rdoc au sein d'autres templates:
+Notez que vous pouvez également appeler la méthode +rdoc+ au sein d'autres
+templates:
 
   %h1 Bonjour Depuis Haml!
   %p= rdoc(:salutations)
 
+Comme vous ne pouvez pas faire d'appels Ruby au sein de RDoc, vous ne
+pouvez pas utiliser des layouts écrits en RDoc. Il est toutefois possible
+d'utiliser un autre moteur de rendu pour le layout en passant l'option
+<tt>:layout_engine</tt> :
+
+  get '/' do
+    rdoc :index, :layout_engine => :erb
+  end
+
+Ceci utilisera <tt>./views/index.rdoc</tt> avec <tt>./views/layout.erb</tt>
+pour layout.
+
+Souvenez vous que vous pouvez spécifier de telles options de rendu
+globalement :
+
+  set :rdoc, :layout_engine => :haml, :layout => :post
+
+  get '/' do
+    rdoc :index
+  end
+
+Ceci utilisera <tt>./views/index.rdoc</tt> (et tout autre template RDoc)
+avec <tt>./views/post.haml</tt> pour layout.
+
 === Templates Radius
 
 Le gem radius est nécessaire pour utiliser la fonction de rendu Radius:
 
-  # Chargez la bibliotèque radius dans votre application
+  # Chargez la bibliothèque radius dans votre application
   require 'radius'
 
   get '/' do
@@ -408,7 +577,8 @@ Le gem radius est nécessaire pour utiliser la fonction de rendu Radius:
 Utilisera <tt>./views/index.radius</tt>.
 
 Comme vous ne pouvez pas appeler des méthodes Ruby (excepté +yield+) dans un
-template Radius, il sera toujours nécessaire de lui passer des variables locales:
+template Radius, il sera toujours nécessaire de lui passer des variables
+locales:
 
   radius :index, :locals => { :key => 'value' }
 
@@ -425,6 +595,12 @@ Le gem markaby est nécessaire pour utiliser la fonction de rendu Markaby:
 
 Utilisera <tt>./views/index.mab</tt>.
 
+Vous pouvez également utiliser Markaby en ligne :
+
+  get '/' do
+    markaby { h1 "Salut !" }
+  end
+
 === Templates Slim
 
 Le gem slim est nécessaire pour utiliser la fonction de rendu Slim:
@@ -440,8 +616,17 @@ Utilisera <tt>./views/index.slim</tt>.
 
 === Templates CoffeeScript
 
-Le gem coffee-script et l'exécutable `coffee` sont nécessaires pour utiliser la
-fonction de rendu CoffeeScript:
+Le gem <tt>coffee-script</tt> est nécessaire ainsi que l'<b>une</b> des
+options suivantes permettant l'exécution de Java script :
+
+* +node+ (de Node.js) dans votre path
+* vous êtes sous OSX
+* le gem +therubyracer+
+
+Voir http://github.com/josh/ruby-coffee-script pour une liste à jour d'options
+possibles.
+
+Maintenant vous pouvez générer des templates CoffeeScript :
 
   # Chargez la bibliothèque coffee-script dans votre application
   require 'coffee-script'
@@ -452,14 +637,13 @@ fonction de rendu CoffeeScript:
 
 Utilisera <tt>./views/application.coffee</tt>.
 
-=== Templates en ligne
+=== Templates embarqués
 
   get '/' do
     haml '%div.title Bonjour Monde'
   end
 
-Utilisera le texte passé en argument pour générer la page, au lieu d'aller
-chercher le texte dans un fichier.
+Générera le template embarqué spécifié dans la chaîne de caractères.
 
 === Accéder aux variables dans un Template
 
@@ -479,14 +663,14 @@ Alternativement, on peut passer un hash contenant des variables locales:
     haml '%h1= foo.nom', :locals => { :foo => foo }
   end
 
-Ceci est généralement utilisé lorsque l'on veut utiliser un template comme partiel
-(depuis un autre template) et qu'il est donc nécessaire d'adapter les noms de variables.
+Ceci est généralement utilisé lorsque l'on veut utiliser un template comme
+partiel (depuis un autre template) et qu'il est donc nécessaire d'adapter les
+noms de variables.
 
 === Templates dans le fichier source
 
 Des templates peuvent être définis dans le fichier source comme ceci:
 
-  require 'rubygems'
   require 'sinatra'
 
   get '/' do
@@ -503,12 +687,14 @@ Des templates peuvent être définis dans le fichier source comme ceci:
   %div.title Bonjour Monde!!!!!
 
 NOTE: Les templates du fichier source qui contient <tt>require 'sinatra'</tt>
-sont automatiquement chargés. Si vous avez des templates dans d'autres fichiers source,
-il faut explicitement les déclarer via: <tt>enable :inline_templates</tt>.
+sont automatiquement chargés. Si vous avez des templates dans d'autres
+fichiers source, il faut explicitement les déclarer via:
+<tt>enable :inline_templates</tt>.
 
 === Templates nommés
 
-Les templates peuvent aussi être définis grâce à la méthode de haut niveau <tt>template</tt>:
+Les templates peuvent aussi être définis grâce à la méthode de haut niveau
+<tt>template</tt>:
 
   template :layout do
     "%html\n  =yield\n"
@@ -522,29 +708,41 @@ Les templates peuvent aussi être définis grâce à la méthode de haut niveau
     haml :index
   end
 
-Si un template nommé "layout" existe, il sera utilisé à chaque fois qu'un template
-sera affiché. Vous pouvez désactivez le layout à tout moment en passant
-<tt>:layout => false</tt>.
+Si un template nommé "layout" existe, il sera utilisé à chaque fois qu'un
+template sera affiché. Vous pouvez désactivez les layouts au cas par cas en
+passant <tt>:layout => false</tt> ou bien les désactiver par défaut au moyen
+de <tt>set :haml, :layout => false</tt>:
 
   get '/' do
     haml :index, :layout => !request.xhr?
   end
 
-== Helpers
+=== Associer des extensions de fichier
+
+Pour associer une extension de fichier avec un moteur de rendu, utilisez
+<tt>Tilt.register</tt>. Par exemple, si vous désirez utiliser l'extension
+de fichier +tt+ pour les templates Textile, vous pouvez faire comme suit :
 
-Utilisez la méthode de haut niveau <tt>helpers</tt> pour définir des routines qui
-seront accessibles dans vos gestionnaires de route et dans vos templates:
+  Tilt.register :tt, Tilt[:textile]
+
+=== Ajouter son propre moteur de rendu
+
+En premier lieu, déclarez votre moteur de rendu avec Tilt, ensuite créez
+votre méthode de rendu :
+
+  Tilt.register :monmoteur, MonMerveilleurMoteurDeRendu
 
   helpers do
-    def bar(nom)
-      "#{nom}bar"
-    end
+    def monmoteur(*args) render(:monmoteur, *args) end
   end
 
-  get '/:nom' do
-    bar(params[:nom])
+  get '/' do
+    monmoteur :index
   end
 
+Utilisera <tt>./views/index.monmoteur</tt>. Voir
+https://github.com/rtomayko/tilt pour en savoir plus sur Tilt.
+
 == Filtres
 
 Un filtre <tt>before</tt> est évalué avant n'importe quelle requête, dans le
@@ -564,13 +762,18 @@ et au template:
 
 Un filtre <tt>after</tt> est évalué après chaque requête, dans le contexte
 de celle-ci et peut également modifier la requête et/ou la réponse. Toutes les
-variables d'instance déclarées dans un filtre <tt>before</tt> et dans le gestionnaire
-de route sont accessibles dans le filtre <tt>after</tt>:
+variables d'instance déclarées dans un filtre <tt>before</tt> et dans le
+gestionnaire de route sont accessibles dans le filtre <tt>after</tt>:
 
   after do
     puts response.status
   end
 
+Note : Sauf si vous utilisez la méthode +body+ au lieu de renvoyer une chaîne
+de caractères dans vos gestionnaires de routes, le corps de la réponse ne sera
+pas disponible dans le filtre <tt>after</tt>, étant donné qu'il est généré
+plus tard.
+
 En option, on peut passer un masque au filtre, ce qui le rend actif uniquement
 si la requête correspond au masque en question:
 
@@ -582,9 +785,67 @@ si la requête correspond au masque en question:
     session[:dernier_travail] = travail
   end
 
+Tout comme les routes, les filtres acceptent également les conditions :
+
+  before :agent => /Songbird/ do
+    # ...
+  end
+
+  after '/blog/*', :host_name => 'example.com' do
+    # ...
+  end
+
+== Helpers
+
+Utilisez la méthode de haut niveau <tt>helpers</tt> pour définir des routines
+qui seront accessibles dans vos gestionnaires de route et dans vos templates :
+
+  helpers do
+    def bar(nom)
+      "#{nom}bar"
+    end
+  end
+
+  get '/:nom' do
+    bar(params[:nom])
+  end
+
+=== Utiliser les sessions
+
+Une session est utilisé pour conserver un état entre les requêtes. Une fois
+activées, vous avez un +hash+ de session par session utilisateur :
+
+  enable :sessions
+
+  get '/' do
+    "valeur = " << session[:valeur].inspect
+  end
+
+  get '/:value' do
+    session[:valeur] = params[:valeur]
+  end
+
+Notez que <tt>enable :sessions</tt> enregistre en fait toutes les données dans
+un +cookie+. Ce n'est pas toujours ce que vous voulez (enregistrer beaucoup de
+données va augmenter le traffic par exemple). Vous pouvez utiliser n'importe
+quel +middleware+ Rack de session afin d'éviter cela. N'utiliser *pas*
+<tt>enable :sessions</tt> dans ce cas mais charger le +middleware+ de votre
+choix comme vous le feriez pour n'importe quel autre +middleware+ :
+
+  use Rack::Session::Pool, :expire_after => 2592000
+
+  get '/' do
+    "valeur = " << session[:valeur].inspect
+  end
+
+  get '/:value' do
+    session[:valeur] = params[:valeur]
+  end
+
 == Halt
 
-Pour arrêter immédiatement la requête dans un filtre ou un gestionnaire de route:
+Pour arrêter immédiatement la requête dans un filtre ou un gestionnaire de
+route:
 
   halt
 
@@ -604,6 +865,10 @@ Ainsi que les entêtes ...
 
   halt 402, {'Content-Type' => 'text/plain'}, 'revanche'
 
+Bien sûr il est possible de cominer un template avec +halt+:
+
+  halt erb(:erreur)
+
 == Passer
 
 Une route peut passer le relais aux autres routes qui correspondent également
@@ -622,13 +887,242 @@ On sort donc immédiatement de ce gestionnaire et on continue à chercher,
 dans les masques suivants, le prochain qui correspond à la requête.
 Si aucun des masques suivants ne correspond, un code 404 est retourné.
 
+=== Déclencher une autre route
+
+Parfois, +pass+ n'est pas ce que vous recherchez, au lieu de cela vous
+souhaitez obtenir le résultat d'une autre route. Pour cela, utilisez
+simplement +call+ :
+
+  get '/foo' do
+    status, headers, body = call request.env.merge("PATH_INFO" => '/bar')
+    [status, body.upcase]
+  end
+
+  get '/bar' do
+    "bar"
+  end
+
+Notez que dans l'exemple ci-dessus, vous faciliterez les tests et améliorerez
+la performance en déplaçant simplement <tt>"bar"</tt> dans un +helper+
+utilisé à la fois par <tt>/foo</tt> et <tt>/bar</tt>.
+
+Si vous souhiatez que la requête soit envoyée à la même instance de
+l'application plutôt qu'à une copie, utilisez <tt>call!</tt> au lieu de
+<tt>call</tt>.
+
+Lisez la spécification Rack si vous souhaitez en savoir plus sur
+<tt>call</tt>.
+
+=== Définir le corps, le code retour et les entêtes
+
+Il est possible et recommandé de définir le code retour et le corps de la
+réponse au moyen de la valeur de retour d'un bloc définissant une route.
+Quoiqu'il en soit, dans certains cas vous pourriez avoir besoin de définir
+le coprs de la réponse à un moment arbitraire de l'exécution. Vous pouvez le
+faire au moyen de la méthode +body+. Si vous faites ainsi, vous pouvez alors
+utiliser cette même méthode pour accéder au corps de la réponse :
+
+  get '/foo' do
+    body "bar"
+  end
+
+  after do
+    puts body
+  end
+
+Il est également possible de passer un bloc à +body+, qui sera exécuté par le
+gestionnaire Rack (ceci peut être utilisé pour implémenter un +streaming+,
+voir "Valeurs de retour").
+
+Pareillement au corps de la réponse, vous pouvez également définir le code
+retour et les entêtes :
+
+  get '/foo' do
+    status 418
+    headers \
+      "Allow"   => "BREW, POST, GET, PROPFIND, WHEN"
+      "Refresh" => "Refresh: 20; http://www.ietf.org/rfc/rfc2324.txt"
+    body "I'm a tea pot!"
+  end
+
+Comme +body+, +headers+ et +status+ peuvent être utilisés sans arguments
+pour accéder à leurs valeurs.
+
+=== Types Mime
+
+Quand vous utilisez <tt>send_file</tt> ou des fichiers statiques, vous
+pouvez rencontrer des types mime que Sinatra ne connaît pas. Utilisez
++mime_type+ pour les déclarer par extension de fichier :
+
+  mime_type :foo, 'text/foo'
+
+Vous pouvez également les utiliser avec la méthode +content_type+ :
+
+  get '/' do
+    content_type :foo
+    "foo foo foo"
+  end
+
+=== Former des URLs
+
+Pour former des URLs, vous devriez utiliser la méthode +url+, par exemple en
+Haml :
+
+  %a{:href => url('/foo')} foo
+
+Cela prend en compte les proxy inverse et les routeurs Rack, s'ils existent.
+
+Cette méthode est également disponible sous l'alias +to+ (voir ci-dessous
+pour un exemple).
+
+=== Redirection du navigateur
+
+Vous pouvez déclencher une redirection du navigateur avec la méthode
++redirect+ :
+
+  get '/foo' do
+    redirect to('/bar')
+  end
+
+Tout paramètre additionnel est géré comme des arguments pour la méthode
++halt+ :
+
+  redirect to('/bar'), 303
+  redirect 'http://google.com', 'mauvais endroit mon pote'
+
+Vous pouvez aussi rediriger vers la page dont l'utilisateur venait au moyen de
+<tt>redirect back</tt>:
+
+  get '/foo' do
+    "<a href='/bar'>faire quelque chose</a>"
+  end
+
+  get '/bar' do
+    faire_quelque_chose
+    redirect back
+  end
+
+Pour passer des arguments à une redirection, ajoutez-les soit à la requête :
+
+  redirect to('/bar?sum=42')
+
+Ou bien utilisez une session :
+
+  enable :session
+
+  get '/foo' do
+    session[:secret] = 'foo'
+    redirect to('/bar')
+  end
+
+  get '/bar' do
+    session[:secret]
+  end
+
+=== Contrôle du cache
+
+Définir correctement vos entêtes à la base pour un bon cahce HTTP.
+
+Vous pouvez facilement définir l'entête Cache-Control de la manière suivante :
+
+  get '/' do
+    cache_control :public
+    "met le en cache !"
+  end
+
+Conseil de pro : définir le cache dans un filtre +before+:
+
+  before do
+    cache_control :public, :must_revalidate, :max_age => 60
+  end
+
+Si vous utilisez la méthode +expires+ pour définir l'entête correspondant,
+<tt>Cache-Control</tt> sera alors défini automatiquement :
+
+  before do
+    expires 500, :public, :must_revalidate
+  end
+
+Pour utiliser correctement les caches, vous devriez utiliser +etag+ et
++last_modified+. Il est recommandé d'utiliser ces méthodes *avant* de faire
+d'important modifications, car elles vont immédiatement déclencher la réponse
+si le client a déjà la version courante dans son cache:
+
+  get '/article/:id' do
+    @article = Article.find params[:id]
+    last_modified @article.updated_at
+    etag @article.sha1
+    erb :article
+  end
+
+Il est également possible d'utiliser un
+{weak ETag}[http://en.wikipedia.org/wiki/HTTP_ETag#Strong_and_weak_validation]:
+
+  etag @article.sha1, :weak
+
+Ces méthodes ne sont pas chargées de mettre des données en cache, mais elles
+fournissent les informations nécessaires pour votre cache. Si vous êtes à la
+recherche de solutions rapides de cache, essayez
+{rack-cache}[http://rtomayko.github.com/rack-cache/]:
+
+  require "rack/cache"
+  require "sinatra"
+
+  use Rack::Cache
+
+  get '/' do
+    cache_control :public, :max_age => 36000
+    sleep 5
+    "hello"
+  end
+
+=== Envoyer des fichiers
+
+Pour envoyer des fichiers, vous pouvez utiliser la méthode
+<tt>send_file</tt> :
+
+  get '/' do
+    send_file 'foo.png'
+  end
+
+Quelques options sont également acceptées :
+
+  send_file 'foo.png', :type => :jpg
+
+Les options sont :
+
+[filename]
+  le nom du fichier dans la réponse, par défaut le nom du fichier envoyé.
+
+[last_modified]
+  valeur pour l'entête Last-Modified, par défaut la date de modification du
+  fichier
+
+[type]
+  type de contenu à utiliser, deviné à partir de l'extension de fichier si
+  absent
+
+[disposition]
+  utilisé pour Content-Disposition, les valuers possibles étant : +nil+ (par
+  défaut), <tt>:attachment</tt> et <tt>:inline</tt>
+
+[length]
+  entête Content-Length, par défaut la taille du fichier
+
+Si le gestionnaire Rack le supporte, d'autres moyens que le +streaming+ via le
+processus Ruby seront utilisés. Si vous utilisez cette méthode, Sinatra gérera
+automatiquement les requêtes de type +range+.
+
 == Accéder à l'objet requête
 
-L'objet correspondant à la requête envoyée peut être récupéré dans le contexte de la requête (filtres, routes, gestionnaires d'erreur) au moyen de la méthode `request`:
+L'objet correspondant à la requête envoyée peut être récupéré dans le contexte
+de la requête (filtres, routes, gestionnaires d'erreur) au moyen de la méthode
+`request`:
 
   # application tournant à l'adresse http://exemple.com/exemple
   get '/foo' do
-    request.body              # corps de la requête envoyée par le client (voir ci-dessous)
+    request.body              # corps de la requête envoyée par le client
+                              # (voir ci-dessous)
     request.scheme            # "http"
     request.script_name       # "/exemple"
     request.path_info         # "/foo"
@@ -638,7 +1132,8 @@ L'objet correspondant à la requête envoyée peut être récupéré dans le con
     request.content_length    # taille de request.body
     request.media_type        # type de média pour request.body
     request.host              # "exemple.com"
-    request.get?              # true (méthodes similaires pour les autres verbes HTTP)
+    request.get?              # true (méthodes similaires pour les autres
+                              # verbes HTTP)
     request.form_data?        # false
     request["UN_ENTETE"]      # valeur de l'entête UN_ENTETE
     request.referer           # référant du client ou '/'
@@ -649,11 +1144,13 @@ L'objet correspondant à la requête envoyée peut être récupéré dans le con
     request.path              # "/exemple/foo"
     request.ip                # adresse IP du client
     request.secure?           # false
-    request.env               # tableau brut de l'environnement fourni par Rack
+    request.forwarded?        # vrai (si on est derrière un proxy inverse)
+    request.env               # tableau brut de l'environnement fourni par
+                              # Rack
   end
 
-Certaines options, telles que <tt>script_name</tt> ou <tt>path_info</tt> peuvent
-également être modifiées:
+Certaines options, telles que <tt>script_name</tt> ou <tt>path_info</tt>
+peuvent également être modifiées:
 
   before { request.path_info = "/" }
 
@@ -669,12 +1166,86 @@ Certaines options, telles que <tt>script_name</tt> ou <tt>path_info</tt> peuvent
     "Bonjour #{donnees['nom']}!"
   end
 
+=== Fichiers joints
+
+Vous pouvez utiliser la méthode +attachment+ pour indiquer au navigateur que
+la réponse devrait être stockée sur le disque plutôt qu'affichée:
+
+  get '/' do
+    attachment
+    "enregistre-le !"
+  end
+
+Vous pouvez également lui passer un nom de fichier :
+
+  get '/' do
+    attachment "info.txt"
+    "enregistre-le !"
+  end
+
+=== Chercher les fichiers de templates
+
+La méthode <tt>find_template</tt> est utilisée pour trouver les fichiers de
+templates à générer :
+
+  find_template settings.views, 'foo', Tilt[:haml] do |file|
+    puts "pourrait être #{file}"
+  end
+
+Ce n'est pas très utilise. En revanche, il est utile de pouvoir surcharger
+cette méthode afin de définir son propre mécanisme de recherche. Par exemple,
+vous pouvez utiliser plus d'un répertoire de vues :
+
+  set :views, ['views', 'templates']
+
+  helpers do
+    def find_template(views, name, engine, &block)
+      Array(views).each { |v| super(v, name, engine, &block) }
+    end
+  end
+
+Un autre exemple est d'utiliser des répertoires différents pour des moteurs
+de rendu différents :
+
+  set :views, :sass => 'views/sass', :haml => 'templates', :default => 'views'
+
+  helpers do
+    def find_template(views, name, engine, &block)
+      _, folder = views.detect { |k,v| engine == Tilt[k] }
+      folder ||= views[:default]
+      super(folder, name, engine, &block)
+    end
+  end
+
+Vous pouvez également écrire cela dans une extension et la partager avec
+d'autres !
+
+Notez que <tt>find_template</tt> ne vérifie pas que le fichier existe mais
+va plutôt exécuter le bloc pour tous les chemins possibles. Cela n'induit pas
+un problème de performance dans le sens où +render+ va utiliser +break+ dès
+qu'un fichier est trouvé. De plus, l'emplacement des templates (et leur
+contenu) est mis en cache si vous n'êtes pas en mode développement. Vous
+devriez garder cela en tête si vous écrivez une méthode vraiment dingue.
+
 == Configuration
 
 Lancé une seule fois au démarrage de tous les environnements:
 
   configure do
-    ...
+    # définir un paramètre
+    set :option, 'value'
+
+    # définir plusieurs paramètre
+    set :a => 1, :b => 2
+
+    # identique à `set :option, true`
+    enable :option
+
+    # identique à `set :option, false`
+    disable :option
+
+    # vous pouvez également avoir des paramètres dynamiques avec des blocs
+    set(:css_dir) { File.join(views, 'css') }
   end
 
 Lancé si l'environnement (variable d'environnement RACK_ENV) est défini comme
@@ -691,16 +1262,125 @@ Lancé si l'environnement est <tt>:production</tt> ou
     ...
   end
 
+Vous pouvez accéder à ces paramètres via <tt>settings</tt> :
+
+  configure do
+    set :foo, 'bar'
+  end
+
+  get '/' do
+    settings.foo? # => true
+    settings.foo  # => 'bar'
+    ...
+  end
+
+=== Paramètres disponibles
+
+[absolute_redirects]  Si désactivé, Sinatra permettra les redirections
+                      relatives. Toutefois, Sinatra ne sera plus conforme à la
+                      RFC 2616 (HTTP 1.1), qui n'autorise que les redirections
+                      absolues.
+
+                      Activez si votre application tourne derrière un proxy
+                      inverse qui n'a pas été correctement configuré. Notez
+                      que la méthode +url+ continuera de produire des URLs
+                      absolues, sauf si vous lui passez +false+ comme second
+                      argument.
+
+                      Désactivé par défaut.
+
+[add_charsets]        types mime pour lesquels la méthode
+                      <tt>content_type</tt> va automatiquement ajouter
+                      l'information du +charset+.
+
+                      Vous devriez lui ajouter des valeurs plutôt que de
+                      l'écraser :
+
+                        settings.add_charsets << "application/foobar"
+
+[app_file]            fichier de l'application principale, utilisé pour
+                      détecterla racine du projet, le dossier public et le
+                      dossier de vues ainsi que pour les templates en ligne.
+
+[bind]                adresse IP sur laquelle se brancher
+                      (par défaut: 0.0.0.0).
+                      Utiliser seulement pour le serveur intégré.
+
+[default_encoding]    encodage à utiliser si inconnu (par défaut
+                      <tt>"utf-8"</tt>).
+
+[dump_errors]         afficher les erreurs dans le +log+.
+
+[environment]         environnement courant, par défaut
+                      <tt>ENV['RACK_ENV']</tt>, ou
+                      <tt>"development"</tt> si absent.
+
+[logging]             utiliser le +logger+.
+
+[lock]                Place un +lock+ autour de chaque requête, n'exécutant
+                      donc qu'une seule requête par processus Ruby.
+
+                      Activé si votre application n'est pas +thread-safe+.
+                      Désactivé par défaut.
+
+[method_override]     utilise la magie de <tt>_method</tt> afin de permettre
+                      des formulaires put/delete dans des navigateurs qui ne
+                      le permettent pas.
+
+[port]                port à écouter. Utiliser seulement pour le serveur
+                      intégré.
+
+[prefixed_redirects]  si oui ou non <tt>request.script_name</tt> doit être
+                      inséré dans les redirections si un chemin non absolu
+                      est utilisé. Ainsi, <tt>redirect '/foo'</tt> se
+                      comportera comme <tt>redirect to('/foo')</tt>.
+                      Désactivé par défaut.
+
+[public]              dossier duquel les fichiers publics sont servis
+
+[reload_templates]    si oui ou non les templates doivent être rechargés
+                      entre les requêtes. Activé en mode développement
+                      et sur Ruby 1.8.6 (pour compenser un bug Ruby
+                      occasionnant une fuite de mémoire).
+
+[root]                dossier racine du projet.
+
+[raise_errors]        soulever les erreurs (ce qui arrêtera l'application).
+
+[run]                 si activé, Sinatra s'occupera de démarrer le serveur,
+                      ne pas activer si vous utiliser rackup ou autres.
+
+[running]             est-ce que le serveur intégré est en marche ?
+                      ne changez pas ce paramètre !
+
+[server]              serveur ou liste de serveurs à utiliser pour le serveur
+                      intégré.
+                      Par défaut ['thin', 'mongrel', 'webrick'], l'ordre
+                      indiquant la priorité.
+
+[sessions]            active l'enregistrement des sessions en utilisant les
+                      cookies.
+
+[show_exceptions]     affiche la trace de l'erreur dans le navigateur.
+
+[static]              Si oui ou non Sinatra doit s'occuper de servir les
+                      fichiers statiques.
+                      Désactivez si vous utilisez un serveur capable de le
+                      gérer lui même. Le désactiver augmentera la performance.
+                      Activé par défaut.
+
+[views]               dossier des vues.
+
 == Gérer les erreurs
 
-Les gestionnaires d'erreur s'exécutent dans le même contexte que les routes ou les
-filtres, ce qui veut dire que vous avez accès (entre autres) aux bons vieux
-<tt>haml</tt>, <tt>erb</tt>, <tt>halt</tt>, etc.
+Les gestionnaires d'erreur s'exécutent dans le même contexte que les routes ou
+les filtres, ce qui veut dire que vous avez accès (entre autres) aux bons
+vieux <tt>haml</tt>, <tt>erb</tt>, <tt>halt</tt>, etc.
 
 === Pas Trouvé
 
-Quand une exception <tt>Sinatra::NotFound</tt> est soulevée, ou que le code retour
-est 404, le gestionnaire <tt>not_found</tt> est invoqué:
+Quand une exception <tt>Sinatra::NotFound</tt> est soulevée, ou que le code
+retour est 404, le gestionnaire <tt>not_found</tt> est invoqué:
 
   not_found do
     'Pas moyen de trouver ce que vous cherchez'
@@ -708,8 +1388,9 @@ est 404, le gestionnaire <tt>not_found</tt> est invoqué:
 
 === Erreur
 
-Le gestionnaire +error+ est invoqué à chaque fois qu'une exception est soulevée dans une route
-ou un filtre. L'objet exception est accessible via la variable Rack <tt>sinatra.error</tt>:
+Le gestionnaire +error+ est invoqué à chaque fois qu'une exception est
+soulevée dans une route ou un filtre. L'objet exception est accessible via la
+variable Rack <tt>sinatra.error</tt>:
 
   error do
     'Désolé mais une méchante erreur est survenue - ' + env['sinatra.error'].name
@@ -731,7 +1412,8 @@ Vous obtenez ça:
 
   Donc il est arrivé ceci... quelque chose de mal
 
-Alternativement, vous pouvez avoir un gestionnaire d'erreur associé à un code particulier:
+Alternativement, vous pouvez avoir un gestionnaire d'erreur associé à un code
+particulier:
 
   error 403 do
     'Accès interdit'
@@ -747,27 +1429,18 @@ Ou un intervalle:
     'Boom'
   end
 
-Sinatra installe pour vous quelques gestionnaires <tt>not_found</tt> et <tt>error</tt>
-génériques lorsque vous êtes en environnement <tt>development</tt>.
-
-== Types Mime
-
-Quand vous utilisez <tt>send_file</tt> et que le fichier possède une extension que Sinatra
-ne reconnaît pas, utilisez +mime_type+ pour la déclarer:
-
-  mime_type :foo, 'text/foo'
-
-Vous pouvez aussi l'utiliser avec +content_type+:
-
-  content_type :foo
+Sinatra installe pour vous quelques gestionnaires <tt>not_found</tt> et
+<tt>error</tt> génériques lorsque vous êtes en environnement
+<tt>development</tt>.
 
 == Les Middlewares Rack
 
 Sinatra tourne avec Rack[http://rack.rubyforge.org/], une interface standard
 et minimale pour les web frameworks Ruby. Un des points forts de Rack est le
-support de ce que l'on appelle des "middlewares" -- composant qui vient se situer
-entre le serveur et votre application, et dont le but est de visualiser/manipuler la
-requête/réponse HTTP, et d'offrir diverses fonctionnalités classiques.
+support de ce que l'on appelle des "middlewares" -- composant qui vient se
+situer entre le serveur et votre application, et dont le but est de
+visualiser/manipuler la requête/réponse HTTP, et d'offrir diverses
+fonctionnalités classiques.
 
 Sinatra permet de construire facilement des middlewares Rack via la méthode de
 haut niveau +use+:
@@ -784,17 +1457,17 @@ haut niveau +use+:
 
 La sémantique de +use+ est identique à celle définie dans le DSL de
 Rack::Builder[http://rack.rubyforge.org/doc/classes/Rack/Builder.html]
-(le plus souvent utilisé dans un fichier rackup). Par exemple, la méthode +use+
-accepte divers arguments ainsi que des blocs:
+(le plus souvent utilisé dans un fichier rackup). Par exemple, la méthode
++use+ accepte divers arguments ainsi que des blocs:
 
   use Rack::Auth::Basic do |login, password|
     login == 'admin' && password == 'secret'
   end
 
-Rack est distribué avec une bonne variété de middlewares standards pour les logs,
-débuguer, faire du routage URL, de l'authentification, gérer des sessions.
-Sinatra utilise beaucoup de ces composants automatiquement via la configuration,
-donc pour ceux-ci vous n'aurez pas à utiliser la méthode +use+.
+Rack est distribué avec une bonne variété de middlewares standards pour les
+logs, débuguer, faire du routage URL, de l'authentification, gérer des
+sessions. Sinatra utilise beaucoup de ces composants automatiquement via la
+configuration, donc pour ceux-ci vous n'aurez pas à utiliser la méthode +use+.
 
 == Tester
 
@@ -803,6 +1476,7 @@ basée sur Rack. {Rack::Test}[http://gitrdoc.com/brynary/rack-test] est
 recommandé:
 
   require 'mon_application_sinatra'
+  require 'test/unit'
   require 'rack/test'
 
   class MonTest < Test::Unit::TestCase
@@ -839,8 +1513,8 @@ de créer des composants réutilisables comme des middlewares Rack, faire
 du Rails metal, ou de simples bibliothèques avec un composant serveur, ou
 même une extension pour Sinatra. Le DSL de haut niveau pollue l'espace de noms
 et est une configuration adaptée à une micro-application (un fichier unique
-pour l'application, les dossiers ./public et ./views, les logs, pages d'erreur, etc.).
-C'est là que Sinatra::Base entre en jeu:
+pour l'application, les dossiers ./public et ./views, les logs, pages
+d'erreur, etc.). C'est là que Sinatra::Base entre en jeu:
 
   require 'sinatra/base'
 
@@ -853,13 +1527,6 @@ C'est là que Sinatra::Base entre en jeu:
     end
   end
 
-La classe MonApplication est un composant Rack indépendant qui peut agir
-comme un middleware Rack, une application Rack, ou Rails metal. vous pouvez
-donc le lancer avec +run+ ou l'utiliser avec +use+ dans un fichier rackup;
-ou contrôler un composant de serveur sous forme de bibliothèque:
-
-   MonApplication.run! :host => 'localhost', :port => 9090
-
 Les méthodes disponibles dans Sinatra::Base sont exactement identiques à
 celles disponibles dans le DSL de haut niveau. La plupart des applications
 de haut niveau peuvent être converties en composant Sinatra::Base avec
@@ -871,16 +1538,107 @@ deux modifications:
 * Mettre vos gestionnaires de route, vos gestionnaires d'erreur, vos filtres
 	et options dans une sous-classe de Sinatra::Base.
 
-<tt>Sinatra::Base</tt> est plutôt épuré. La plupart des options sont désactivées par défaut,
-ceci inclus le serveur. Voir {Options et Configuration}[http://sinatra.github.com/configuration.html]
+<tt>Sinatra::Base</tt> est plutôt épuré. La plupart des options sont
+désactivées par défaut, ceci inclus le serveur. Voir {Options et
+Configuration}[http://sinatra.github.com/configuration.html]
 pour plus de détails sur les options et leur comportement.
 
+=== Style modulaire vs. style classique
+
+Contrairement aux croyanaces, le style classique n'a rien de mauvais. Si cela
+convient à votre application, vous n'avez pas à changer pour une application
+modulaire.
+
+Il n'y a que deux inconvénient au style classique comparé au style modulaire :
+
+* Vous ne pouvez avoir qu'une seule application Sinatra par processus Ruby. Si
+  vous envisagez d'en utiliser plus, passez au style modulaire
+
+* Le style classique pollue  la classe Object avec des méthodes déléguantes.
+  Si vous prévoyez de diffuser votre application dans une bibliothèque/gem,
+  passez au style modulaire.
+
+Il n'y pas d'empêchement à mélanger style classic et style modulaire.
+
+Si vous passez d'un style à l'autre, vous devriez être vigilant à quelques
+légères différences dans les paramètres :
+
+  Paramètre           Classique                     Modulaire
+
+  app_file            fichier chargeant sinatra     nil
+  run                 $0 == app_file                false
+  logging             true                          false
+  method_override     true                          false
+  inline_templates    true                          false
+
+
+=== Servir une application modulaire
+
+Il y a deux façons de faire pour démarrer une application modulaire, démarrez
+avec <tt>run!</tt> :
+
+  # my_app.rb
+  require 'sinatra/base'
+
+  class MyApp < Sinatra::Base
+    # ... code de l'application ici ...
+
+    # démarre le serveur si ce fichier est directement exécuté
+    run! if app_file == $0
+  end
+
+Démarrez ensuite avec :
+
+  ruby my_app.rb
+
+Ou alors avec un fichier <tt>config.ru</tt>, qui permet d'utiliser n'importe
+quel gestionnaire Rack :
+
+  # config.ru
+  require 'my_app'
+  run MyApp
+
+Exécutez :
+
+  rackup -p 4567
+
+=== Utiliser une application de style classique avec un fichier config.ru
+
+Ecrivez votre application :
+
+  # app.rb
+  require 'sinatra'
+
+  get '/' do
+    'Hello world!'
+  end
+
+Et un fichier <tt>config.ru</tt> correspondant :
+
+  require 'app'
+  run Sinatra::Application
+
+=== Quand utiliser un fichier config.ru ?
+
+Quelques cas où vous devriez utiliser un fichier <tt>config.ru</tt> :
+
+* Vous souhaitez déployer avec un autre gestionnaire Rack (Passenger, Unicorn,
+  Heroku, ...).
+* Vous souhaitez utiliser plus d'une sous-classe de <tt>Sinatra::Base</tt>.
+* Vous voulez utiliser Sinatra comme un +middleware+, non en tant que
+  +endpoint+.
+
+<b>Il n'est pas nécessaire de passer par un fichier <tt>config.ru</tt> pour la
+seule raison que vous êtes passé au style modulaire, et vous n'avez pas besoin
+de passer au style modulaire pour utiliser un fichier <tt>config.ru</tt>.</b>
+
 === Utiliser Sinatra comme Middleware
 
-Non seulement Sinatra peut utiliser d'autres middlewares Rack, il peut également être
-à son tour utilisé au-dessus de n'importe quel +endpoint+ Rack en tant que middleware.
-Ce +endpoint+ peut très bien être une autre application Sinatra, ou n'importe quelle
-application basée sur Rack (Rails/Ramaze/Camping/...).
+Non seulement Sinatra peut utiliser d'autres middlewares Rack, il peut
+également être à son tour utilisé au-dessus de n'importe quel +endpoint+ Rack
+en tant que middleware. Ce +endpoint+ peut très bien être une autre
+application Sinatra, ou n'importe quelle application basée sur Rack
+(Rails/Ramaze/Camping/...):
 
   require 'sinatra/base'
 
@@ -919,11 +1677,12 @@ disponibles.
 === Contexte de l'application/classe
 
 Toute application Sinatra correspond à une sous-classe de Sinatra::Base. Si
-vous utilisez le DSL haut niveau (<tt>require 'sinatra'</tt>), alors cette classe
-est Sinatra::Application, sinon il s'agit de la sous-classe que vous avez définie.
-Dans le contexte de la classe, vous avez accès aux méthodes telles que `get` ou
-`before`, mais vous n'avez pas accès aux objets `request` ou `session` car c'est la
-même classe d'application qui traitera toutes les requêtes.
+vous utilisez le DSL haut niveau (<tt>require 'sinatra'</tt>), alors cette
+classe est Sinatra::Application, sinon il s'agit de la sous-classe que vous
+avez définie. Dans le contexte de la classe, vous avez accès aux méthodes
+telles que `get` ou `before`, mais vous n'avez pas accès aux objets `request`
+ou `session` car c'est la même classe d'application qui traitera toutes les
+requêtes.
 
 Les options définies au moyen de `set` deviennent des méthodes de classe:
 
@@ -951,11 +1710,12 @@ Vous pouvez atteindre ce contexte (donc la classe) de la façon suivante:
 
 === Contexte de la requête/instance
 
-Pour tout traitement d'une requête, une nouvelle instance de votre classe d'application
-est créée et tous vos gestionnaires sont exécutés dans ce contexte. Dans ce dernier,
-vous pouvez accéder aux objets `request` et `session` et faire appel aux fonctions
-de rendu telles que `erb` ou `haml`. Vous pouvez accéder au contexte de l'application
-depuis le contexte de la requête au moyen de `settings`:
+Pour tout traitement d'une requête, une nouvelle instance de votre classe
+d'application est créée et tous vos gestionnaires sont exécutés dans ce
+contexte. Dans ce dernier, vous pouvez accéder aux objets `request` et
+`session` et faire appel aux fonctions de rendu telles que `erb` ou `haml`.
+Vous pouvez accéder au contexte de l'application depuis le contexte de la
+requête au moyen de `settings`:
 
   class MonApp < Sinatra::Base
     # Eh, je suis dans le contexte de l'application!
@@ -974,7 +1734,7 @@ depuis le contexte de la requête au moyen de `settings`:
 
 Vous avez le binding du contexte de la requête dans:
 
-* les blocs get/head/post/put/delete
+* les blocs get/head/post/put/delete/options
 * les filtres before/after
 * les méthodes utilitaires (définies au moyen de `helpers`)
 * les vues/templates
@@ -982,12 +1742,12 @@ Vous avez le binding du contexte de la requête dans:
 === Le contexte de délégation
 
 Le contexte de délégation se contente de transmettre les appels de méthodes au
-contexte de classe. Toutefois, il ne se comporte pas à 100% comme le contexte de
-classe car vous n'avez pas le binding de la classe: seules les méthodes
-spécifiquement déclarées pour délégation sont disponibles et il n'est pas possible
-de partager des variables/états avec le contexte de classe (comprenez: `self` n'est
-pas le même). Vous pouvez ajouter des délégation de méthodes en appelant
-<tt>Sinatra::Delegator.delegate :method_name</tt>.
+contexte de classe. Toutefois, il ne se comporte pas à 100% comme le contexte
+de classe car vous n'avez pas le binding de la classe: seules les méthodes
+spécifiquement déclarées pour délégation sont disponibles et il n'est pas
+possible de partager des variables/états avec le contexte de classe
+(comprenez: `self` n'est pas le même). Vous pouvez ajouter des délégation de
+méthodes en appelant <tt>Sinatra::Delegator.delegate :method_name</tt>.
 
 Vous avez le binding du contexte de délégation dans:
 
@@ -995,7 +1755,8 @@ Vous avez le binding du contexte de délégation dans:
 * Un objet qui inclut le module `Sinatra::Delegator`
 
 Jetez un oeil
-pour vous faire une idée: voici le mixin {Sinatra::Delegator}[http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/base.rb#L1128]
+pour vous faire une idée: voici le mixin
+{Sinatra::Delegator}[http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/base.rb#L1128]
 qui est {inclus dans l'espace de noms principal}[http://github.com/sinatra/sinatra/blob/ceac46f0bc129a6e994a06100aa854f606fe5992/lib/sinatra/main.rb#L28]
 
 == Ligne de commande
@@ -1013,38 +1774,138 @@ Les options sont:
   -s # déclare le serveur/gestionnaire à utiliser (thin par défaut)
   -x # active le mutex lock (off par défaut)
 
+== Configuration nécessaire
+
+Il est recommandé d'installer Sinatra sur Ruby 1.8.7, 1.9.2, JRuby ou
+Rubinius.
+
+Les versions suivantes de Ruby sont officiellement supportées :
+
+[ Ruby 1.8.6 ]
+  Il n'est pas recommandé d'utiliser 1.8.6 pour Sinatra. Toutefois, ce sera
+  officiellement supporté jusqu'à l'arrivée Sinatra 1.3.0. Les templates RDoc
+  et CoffeeScript ne sont pas supportés par cette version de Ruby. 1.8.6
+  contient un défaut majeur de fuite de mémoire dans l'implémentation de Hash,
+  qui est déclenché par les versions de Sinatra antérieure à 1.1.1. La version
+  actuelle prévient explicitement ce risque au prix de la performance. Vous
+  devrez utiliser Rack 1.1.x dans la mesure où Rack >= 1.2 ne supporte plus
+  1.8.6.
+
+[ Ruby 1.8.7 ]
+  1.8.7 est complètement supporté, toutefois si rien ne vous y retient, nous
+  vous recommandons de passer à 1.9.2 ou bien de passer à JRuby ou Rubinius.
+
+[ Ruby 1.9.2 ]
+  1.9.2 est supporté et recommandé. Notez que Radius et Markaby ne sont
+  actuellement pas compatible avec 1.9. N'utilisez pas 1.9.2p0 qui est
+  réputé causer des erreurs de segmentation lorque Sinatra est utilisé.
+
+[ Rubinius ]
+  Rubinius est officiellement supporté (Rubinius >= 1.2.2), à l'exception
+  des templates Textile.
+
+[ JRuby ]
+  JRuby est officiellement supporté (JRuby >= 1.5.6). Aucune anomalie avec
+  des bibliothèques de templates tierces ne sont connues. Toutefois, si vous
+  choisissez JRuby, alors tournez vous vers des gestionnaires Rack JRuby car
+  le serveur Thin n'est pas (encore) supporté par JRuby.
+
+Nous gardons également un oeil sur les versions Ruby à venir.
+
+Les implémentations Ruby suivantes ne sont pas officiellement supportées mais
+sont toujours connues comme permettant à Sinatra de fonctionner :
+
+* Plus anciennes versions de JRuby et Rubinius
+* MacRuby
+* Maglev
+* IronRuby
+* Ruby 1.9.0 et 1.9.1
+
+Ne pas être officiellement supporté signifie que si les choses se passent mal
+sur ces plateformes et non sur celles supportées, nous considérons que
+l'anomalie est de le ressort, pas du nôtre.
+
+Sinatra devrait fonctionner sur n'importe quel système d'exploitation
+supportant l'implémentation Ruby choisie.
+
 == Essuyer les plâtres
 
-Si vous voulez utiliser la toute dernière version de Sinatra, créez un
-clone local et lancez votre application avec le dossier <tt>sinatra/lib</tt>
-dans votre <tt>LOAD_PATH</tt>:
+Si vous voulez utiliser la toute dernière version de Sinatra, n'ayez pas peur
+de faire tourner votre application sur la branche master, cela devrait être
+stable.
 
-  cd mon_application
-  git clone git://github.com/sinatra/sinatra.git
-  ruby -Isinatra/lib mon_application.rb
+Nous publions également une gem de +prerelease+ de temps en temps donc vous
+pouvez faire la chose suivante :
 
-Alternativement, vous pouvez ajoutez le dossier <tt>sinatra/lib</tt> à votre
-<tt>LOAD_PATH</tt> à l'intérieur de votre application:
+  gem install sinatra --pre
 
-  $LOAD_PATH.unshift File.dirname(__FILE__) + '/sinatra/lib'
-  require 'rubygems'
-  require 'sinatra'
+afin d'avoir certaines des toutes dernières fonctionnalités.
 
-  get '/a_propos' do
-    "J'utilise la version " + Sinatra::VERSION
-  end
+=== Avec Bundler
+
+Si vous voulez faire tourner votre application avec le tout dernier
+Sinatra, {Bundler}[http://gembundler.com/] est recommandé.
+
+Tout d'abord, installer bundler si vous ne l'avez pas :
+
+  gem install bundler
+
+Ensuite, dans le dossier de votre projet, créez un fichier +Gemfile+ :
+
+  source :rubygems
+  gem 'sinatra', :git => "git://github.com/sinatra/sinatra.git"
+
+  # autres dépendances
+  gem 'haml'                    # par exemple, si vous utilisez haml
+  gem 'activerecord', '~> 3.0'  # peut-être que vous avez également besoin
+                                # de ActiveRecord 3.x
+
+Notez que vous aurez à lister toutes les dépendances de votre application dans
+ce fichier. Les dépendances directes de Sinatra (Rack et Tilt) seront
+automatiquement téléchargées et ajoutées par Bundler.
+
+Maintenant, vous pouvez faire tourner votre application de la façon suivante :
+
+  bundle exec ruby myapp.rb
+
+=== Faites le vous-même
 
-Pour mettre à jour les sources de Sinatra par la suite:
+Créez un clone local et démarrez votre application avec le dossier
+<tt>sinatra/lib</tt> dans le <tt>$LOAD_PATH</tt> :
 
-  cd mon_projet/sinatra
+  cd myapp
+  git clone git://github.com/sinatra/sinatra.git
+  ruby -Isinatra/lib myapp.rb
+
+A l'avenir, pour mettre à jour le code source de Sinatra :
+
+  cd myapp/sinatra
   git pull
 
+=== Installez globalement
+
+Vous pouvez construire la gem vous-même :
+
+  git clone git://github.com/sinatra/sinatra.git
+  cd sinatra
+  rake sinatra.gemspec
+  rake install
+
+Si vous installez les gems en tant que +root+, la dernière étape sera :
+
+  sudo rake install
+
+== Versions
+
+Sinatra se conforme aux {versions sémantiques}[http://semver.org/], aussi bien
+SemVer que SemVerTag.
+
 == Mais encore
 
 * {Site internet}[http://www.sinatrarb.com/] - Plus de documentation,
   de news, et des liens vers d'autres ressources.
-* {Contribuer}[http://www.sinatrarb.com/contributing] - Vous avez trouvé un bug? Besoin
-  d'aide? Vous avez un patch?
+* {Contribuer}[http://www.sinatrarb.com/contributing] - Vous avez trouvé un
+  bug? Besoin d'aide? Vous avez un patch?
 * {Suivi des problèmes}[http://github.com/sinatra/sinatra/issues]
 * {Twitter}[http://twitter.com/sinatra]
 * {Mailing List}[http://groups.google.com/group/sinatrarb/topics]