sinatra 1.3.0.a → 1.3.0.b

data/CHANGES

@@ -15,11 +15,37 @@
    classic style) than `Sinatra::Application` by setting `Delegator.target`.
    This was mainly introduced to ease testing. (Konstantin Haase)
 
+ * Added `request.accept?` and `request.preferred_type` to ease dealing with
+   `Accept` headers. (Konstantin Haase)
+
 = 1.2.2 / Not Yet Released
 
+ * The `:provides => :js` condition now matches both `application/javascript`
+   and `text/javascript`. The `:provides => :xml` condition now matches both
+   `application/xml` and `text/xml`. The `Content-Type` header is set
+   accordingly. If the client accepts both, the `application/*` version is
+   preferred, since the `text/*` versions are deprecated. (Konstantin Haase)
+
+ * The `provides` condition now handles wildcards in `Accept` headers correctly.
+   Thus `:provides => :html` matches `text/html`, `text/*` and `*/*`.
+   (Konstantin Haase)
+
+ * When parsing `Accept` headers, `Content-Type` preferences are honored
+   according to RFC 2616 section 14.1. (Konstantin Haase)
+
  * URIs passed to the `url` helper or `redirect` may now use any schema to be
    identified as absolute URIs, not only `http` or `https`. (Konstantin Haase)
 
+ * Handles `Content-Type` strings that already contain parameters correctly in
+   `content_type` (example: `content_type "text/plain; charset=utf-16"`).
+   (Konstantin Haase)
+
+ * If a route with an empty pattern is defined (`get("") { ... }`) requests with
+   an empty path info match this route instead of "/". (Konstantin Haase)
+
+ * In development environment, when running under a nested path, the image URIs
+   on the error pages are set properly. (Konstantin Haase)
+
 = 1.2.1 / 2011-03-17
 
  * Use a generated session secret when using `enable :sessions`. (Konstantin

data/Gemfile

@@ -39,4 +39,5 @@ platforms :mri_18 do
   # bundler platforms are broken
   next if RUBY_ENGINE != 'ruby' or RUBY_VERSION > "1.8"
   gem 'rcov', :group => 'rcov'
+  gem 'therubyracer', :group => 'coffee-script'
 end

data/README.de.rdoc

@@ -851,6 +851,11 @@ teilen:
 
   set :session_secret, 'super secret'
 
+Zur weiteren Konfiguration kann man einen Hash mit Optionen in den +sessions+
+Einstellungen ablegen.
+
+  set :sessions, :domain => 'foo.com'
+
 
 == Anhalten
 
@@ -955,6 +960,31 @@ Vergleichbar mit +body+ lassen sich auch Status-Code und Header setzen:
 Genau wie bei +body+ liest ein Aufrufen von +headers+ oder +status+ ohne
 Argumente den aktuellen Wert aus.
 
+=== Logger
+
+Im Geltungsbereich eines Request stellt die +logger+ Helfer-Methode eine
++Logger+ Instanz zur Verfügung:
+
+  get '/' do
+    logger.info "es passiert gerade etwas"
+    # ...
+  end
+
+Der Logger übernimmt dabei automatisch alle im Rack-Handler eingestellten Log-
+Vorgaben. Ist Loggen ausgeschaltet, gibt die Methode ein Leerobjekt zurück.
+In den Routen und Filtern muss man sich also nicht weiter darum kümmern.
+
+
+Beachte, dass das Loggen standardmäßig nur für <tt>Sinatra::Application</tt>
+voreingestellt ist. Wird über <tt>Sinatra::Base</tt> vererbt, muss es erst
+aktiviert werden:
+
+  class MyApp < Sinatra::Base
+    configure(:production, :development) do
+      enable :logging
+    end
+  end
+
 
 == Mime-Types
 
@@ -1073,29 +1103,33 @@ zugegriffen werden:
 
   # App läuft unter http://example.com/example
   get '/foo' do
-    request.body              # Request-Body des Clients (siehe unten)
-    request.scheme            # "http"
-    request.script_name       # "/example"
-    request.path_info         # "/foo"
-    request.port              # 80
-    request.request_method    # "GET"
-    request.query_string      # ""
-    request.content_length    # Länge von request.body
-    request.media_type        # Media-Type von request.body
-    request.host              # "example.com"
-    request.get?              # true (ähnliche Methoden für andere Verben)
-    request.form_data?        # false
-    request["SOME_HEADER"]    # Wert des SOME_HEADER-Headers
-    request.referrer          # der Referrer des Clients oder '/'
-    request.user_agent        # User-Agent (genutzt von :agent-Bedingung)
-    request.cookies           # Hash der Cookies
-    request.xhr?              # Ist dies eine Ajax-Anfrage?
-    request.url               # "http://example.com/example/foo"
-    request.path              # "/example/foo"
-    request.ip                # Client-IP-Addresse
-    request.secure?           # false (wäre true bei SSL)
-    request.forwarded?        # true (wenn hinter Reverse-Proxy)
-    requuest.env              # env-Hash, den Rack durchreicht
+    t = %w[text/css text/html application/javascript]
+    request.accept              # ['text/html', '*/*']
+    request.accept? 'text/xml'  # true
+    request.preferred_type(t)   # 'text/html'
+    request.body                # Request-Body des Client (siehe unten)
+    request.scheme              # "http"
+    request.script_name         # "/example"
+    request.path_info           # "/foo"
+    request.port                # 80
+    request.request_method      # "GET"
+    request.query_string        # ""
+    request.content_length      # Länge des request.body
+    request.media_type          # Medientypus von request.body
+    request.host                # "example.com"
+    request.get?                # true (ähnliche Methoden für andere Verben)
+    request.form_data?          # false
+    request["IRGENDEIN_HEADER"] # Wert von IRGENDEIN_HEADER header
+    request.referrer            # Der Referrer des Clients oder '/'
+    request.user_agent          # User-Agent (verwendet in der :agent Bedingung)
+    request.cookies             # Hash des Browser-Cookies
+    request.xhr?                # Ist das hier ein Ajax-Request?
+    request.url                 # "http://example.com/example/foo"
+    request.path                # "/example/foo"
+    request.ip                  # IP-Adresse des Clients
+    request.secure?             # false (true wenn SSL)
+    request.forwarded?          # true (Wenn es hinter einem Reverse-Proxy verwendet wird)
+    request.env                 # vollständiger env-Hash von Rack übergeben
   end
 
 Manche Optionen, wie etwa <tt>script_name</tt> oder <tt>path_info</tt>, sind
@@ -1292,10 +1326,7 @@ Diese Einstellungen sind über +settings+ erreichbar:
 [public]              Das öffentliche Verzeichnis, aus dem Daten zur Verfügung
                       gestellt werden können.
 
-[reload_templates]    Entscheidet, ob Templates zwischen Anfragen neu geladen
-                      werden sollen oder nicht. Unter Ruby 1.8.6 ist es im
-                      Entwicklungsmodus eingeschaltet (um einen Fehler in Ruby
-                      auszugleichen, der ein Speicherleck verursacht).
+[reload_templates]    Im development-Modus aktiviert.
 
 [root]                Wurzelverzeichnis des Projekts.
 
@@ -1638,6 +1669,47 @@ andere Sinatra-Anwendung handeln, es kann jede andere Rack-Anwendung sein
     get('/') { "Hallo #{session['user_name']}." }
   end
 
+=== Dynamische Applikationserstellung
+
+Manche Situationen erfordern die Erstellung neuer Applikationen zur Laufzeit,
+ohne dass sie einer Konstanten zugeordnet werden. Dies lässt sich mit 
+`Sinatra.new` erreichen:
+
+  require 'sinatra/base'
+  my_app = Sinatra.new { get('/') { "hallo" } }
+  my_app.run!
+
+
+Die Applikation kann mit Hilfe eines optionalen Parameters erstellt werden:
+
+  require 'sinatra/base'
+
+  controller = Sinatra.new do
+    enable :logging
+    helpers MyHelpers
+  end
+
+  map('/a') do
+    run Sinatra.new(controller) { get('/') { 'a' } }
+  end
+
+  map('/b') do
+    run Sinatra.new(controller) { get('/') { 'b' } }
+  end
+
+Das ist besonders dann interessant, wenn Sinatra-Erweiterungen getestet werden
+oder Sinatra in einer Bibliothek Verwendung findet.
+
+Ebenso lassen sich damit hervorragend Sinatra-Middlewares erstellen:
+
+  require 'sinatra/base'
+
+  use Sinatra do
+    get('/') { ... }
+  end
+
+  run RailsProject::Application
+
 
 == Geltungsbereich und Bindung
 
@@ -1672,6 +1744,7 @@ Im Anwendungs-Scope befindet man sich:
 * In Methoden, die von Erweiterungen definiert werden.
 * Im Block, der an +helpers+ übergeben wird.
 * In Procs und Blöcken, die an +set+ übergeben werden.
+* Der an <tt>Sinatra.new</tt> übergebene Block
 
 Auf das Scope-Objekt (die Klasse) kann wie folgt zugegriffen werden:
 
@@ -1751,20 +1824,8 @@ Die Optionen sind:
 
 == 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 Einbußen 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.
@@ -1786,6 +1847,8 @@ Die folgenden Versionen werden offiziell unterstützt:
   Unterstützung für C-Erweiterungen sind zur Zeit noch experimenteller Natur,
   betrifft im Moment aber nur RDiscount.
 
+<b>Ruby 1.8.6 wird nicht weiter unterstützt.</b>
+
 Weiterhin werden wir auf kommende Ruby-Versionen ein Auge haben.
 
 Die nachfolgend aufgeführten Ruby-Implementationen werden offiziell nicht von 
@@ -1794,6 +1857,7 @@ 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 

data/README.es.rdoc

@@ -1129,29 +1129,33 @@ petición (filtros, rutas y manejadores de errores) a través del método
 
   # app corriendo en http://ejemplo.com/ejemplo
   get '/foo' do
-    request.body              # cuerpo de la petición enviado por el cliente (ver más abajo)
-    request.scheme            # "http"
-    request.script_name       # "/ejemplo"
-    request.path_info         # "/foo"
-    request.port              # 80
-    request.request_method    # "GET"
-    request.query_string      # ""
-    request.content_length    # longitud de request.body
-    request.media_type        # tipo de medio de request.body
-    request.host              # "ejemplo.com"
-    request.get?              # verdadero (hay métodos análogos para los otros verbos)
-    request.form_data?        # falso
-    request["UNA_CABECERA"]   # valor de la cabecera UNA_CABECERA
-    request.referrer          # la referencia del cliente o '/'
-    request.user_agent        # user agent (usado por la condición :agent)
-    request.cookies           # hash de las cookies del browser
-    request.xhr?              # es una petición ajax?
-    request.url               # "http://ejemplo.com/ejemplo/foo"
-    request.path              # "/ejemplo/foo"
-    request.ip                # dirección IP del cliente
-    request.secure?           # falso (sería verdadero sobre ssl)
-    request.forwarded?        # verdadero (si se está corriendo atrás de un proxy inverso)
-    requuest.env              # hash de entorno directamente entregado por Rack
+    t = %w[text/css text/html application/javascript]
+    request.accept              # ['text/html', '*/*']
+    request.accept? 'text/xml'  # true
+    request.preferred_type(t)   # 'text/html'
+    request.body                # cuerpo de la petición enviado por el cliente (ver más abajo)
+    request.scheme              # "http"
+    request.script_name         # "/ejemplo"
+    request.path_info           # "/foo"
+    request.port                # 80
+    request.request_method      # "GET"
+    request.query_string        # ""
+    request.content_length      # longitud de request.body
+    request.media_type          # tipo de medio de request.body
+    request.host                # "ejemplo.com"
+    request.get?                # true (hay métodos análogos para los otros verbos)
+    request.form_data?          # false
+    request["UNA_CABECERA"]     # valor de la cabecera UNA_CABECERA
+    request.referrer            # la referencia del cliente o '/'
+    request.user_agent          # user agent (usado por la condición :agent)
+    request.cookies             # hash de las cookies del browser
+    request.xhr?                # es una petición ajax?
+    request.url                 # "http://ejemplo.com/ejemplo/foo"
+    request.path                # "/ejemplo/foo"
+    request.ip                  # dirección IP del cliente
+    request.secure?             # false (sería true sobre ssl)
+    request.forwarded?          # true (si se está corriendo atrás de un proxy inverso)
+    requuest.env                # hash de entorno directamente entregado por Rack
   end
 
 Algunas opciones, como <tt>script_name</tt> o <tt>path_info</tt> pueden
@@ -1661,6 +1665,48 @@ aplicación basada en Rack (Rails/Ramaze/Camping/...):
     get('/') { "Hola #{session['nombre_de_usuario']}." }
   end
 
+=== Creación Dinámica de Aplicaciones
+
+Puede que en algunas ocasiones quieras crear nuevas aplicaciones en
+tiempo de ejecución sin tener que asignarlas a una constante.  Para
+esto tenés `Sinatra.new`:
+
+  require 'sinatra/base'
+  mi_app = Sinatra.new { get('/') { "hola" } }
+  mi_app.run!
+
+Acepta como argumento opcional una aplicación desde la que se
+heredará:
+
+  require 'sinatra/base'
+
+  controller = Sinatra.new do
+    enable :logging
+    helpers MisHelpers
+  end
+
+  map('/a') do
+    run Sinatra.new(controller) { get('/') { 'a' } }
+  end
+
+  map('/b') do
+    run Sinatra.new(controller) { get('/') { 'b' } }
+  end
+
+Construir aplicaciones de esta forma resulta especialmente útil para
+testear extensiones Sinatra o para usar Sinatra en tus librerías.
+
+Por otro lado, hace extremadamente sencillo usar Sinatra como
+middleware:
+
+  require 'sinatra/base'
+
+  use Sinatra do
+    get('/') { ... }
+  end
+
+  run ProyectoRails::Application
+
 == Ámbitos y Ligaduras
 
 El ámbito en el que te encontrás determina que métodos y variables están

data/README.fr.rdoc

@@ -36,6 +36,10 @@ Chaque route est associée à un bloc:
   end
 
   put '/' do
+    .. remplacer quelque chose ..
+  end
+
+  patch '/' do
     .. changer quelque chose ..
   end
 
@@ -842,6 +846,19 @@ choix comme vous le feriez pour n'importe quel autre +middleware+ :
     session[:valeur] = params[:valeur]
   end
 
+Pour renforcer la sécurité, les données de session dans le cookie sont signées
+avec une clé secrète de session. Une clé secrète est générée pour vous au
+hasard par Sinatra. Toutefois, comme cette clé change à chaque démarrage de
+votre application, vous pouvez définir cette clé vous-même afin que toutes
+les instances de votre application la partage:
+
+  set :session_secret, 'super secret'
+
+Si vous souhaitez avoir plus de contrôle, vous pouvez également enregistrer un
++hash+ avec des options lors de la configuration de +sessions+:
+
+  set :sessions, :domain => 'foo.com'
+
 == Halt
 
 Pour arrêter immédiatement la requête dans un filtre ou un gestionnaire de
@@ -948,6 +965,31 @@ retour et les entêtes :
 Comme +body+, +headers+ et +status+ peuvent être utilisés sans arguments
 pour accéder à leurs valeurs.
 
+=== Journalisation (Logging)
+
+Dans le contexte de la requête, la méthode utilitaire +logger+ expose une
+instance de +logger+:
+
+  get '/' do
+    logger.info "chargement des données"
+    # ...
+  end
+
+Ce +logger+ va automatiquement prendre en compte les paramètres de
+configuration pour la journalisation de votre gestionnaire Rack. Si la
+journalisation est désactivée, cette méthode renverra un objet factice et
+vous n'avez pas à vous en inquiéter dans vos routes en le filtrant.
+
+Notez que la journalisation est seulement activée par défaut pour
+<tt>Sinatra::Application</tt>, donc si vous héritez de <tt>Sinatra::Base</tt>,
+vous aurez à l'activer vous-même:
+
+  class MonApp < Sinatra::Base
+    configure(:production, :development) do
+      enable :logging
+    end
+  end
+
 === Types Mime
 
 Quand vous utilisez <tt>send_file</tt> ou des fichiers statiques, vous
@@ -1121,32 +1163,36 @@ de la requête (filtres, routes, gestionnaires d'erreur) au moyen de la méthode
 
   # 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.scheme            # "http"
-    request.script_name       # "/exemple"
-    request.path_info         # "/foo"
-    request.port              # 80
-    request.request_method    # "GET"
-    request.query_string      # ""
-    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.form_data?        # false
-    request["UN_ENTETE"]      # valeur de l'entête UN_ENTETE
-    request.referer           # référant du client ou '/'
-    request.user_agent        # user agent (utilisé par la condition :agent)
-    request.cookies           # tableau contenant les cookies du navigateur
-    request.xhr?              # requête AJAX ?
-    request.url               # "http://exemple.com/exemple/foo"
-    request.path              # "/exemple/foo"
-    request.ip                # adresse IP du client
-    request.secure?           # false
-    request.forwarded?        # vrai (si on est derrière un proxy inverse)
-    request.env               # tableau brut de l'environnement fourni par
-                              # Rack
+    t = %w[text/css text/html application/javascript]
+    request.accept              # ['text/html', '*/*']
+    request.accept? 'text/xml'  # true
+    request.preferred_type(t)   # 'text/html'
+    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"
+    request.port                # 80
+    request.request_method      # "GET"
+    request.query_string        # ""
+    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.form_data?          # false
+    request["UN_ENTETE"]        # valeur de l'entête UN_ENTETE
+    request.referer             # référant du client ou '/'
+    request.user_agent          # user agent (utilisé par la condition :agent)
+    request.cookies             # tableau contenant les cookies du navigateur
+    request.xhr?                # requête AJAX ?
+    request.url                 # "http://exemple.com/exemple/foo"
+    request.path                # "/exemple/foo"
+    request.ip                  # adresse IP du client
+    request.secure?             # false
+    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>
@@ -1339,9 +1385,7 @@ Vous pouvez accéder à ces paramètres via <tt>settings</tt> :
 [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).
+                      entre les requêtes. Activé en mode développement.
 
 [root]                dossier racine du projet.
 
@@ -1669,6 +1713,46 @@ application Sinatra, ou n'importe quelle application basée sur Rack
     get('/') { "Bonjour #{session['nom_utilisateur']}." }
   end
 
+=== Création dynamique d'applications
+
+Il se peut que vous ayez besoin de créer une nouvelle application à l'exécution
+sans avoir à les assigner à une constante, vous pouvez le faire grâce à
+`Sinatra.new`:
+
+  require 'sinatra/base'
+  mon_app = Sinatra.new { get('/') { "salut" } }
+  mon_app.run!
+
+L'application dont elle hérite peut être passé en argument optionnel:
+
+  require 'sinatra/base'
+
+  controleur = Sinatra.new do
+    enable :logging
+    helpers MyHelpers
+  end
+
+  map('/a') do
+    run Sinatra.new(controleur) { get('/') { 'a' } }
+  end
+
+  map('/b') do
+    run Sinatra.new(controleur) { get('/') { 'b' } }
+  end
+
+C'est notamment utile pour tester des extensions à Sinatra ou bien pour
+utiliser Sinatra dans votre propre bibliothèque.
+
+Cela permet également d'utiliser très facilement Sinatra comme middleware:
+
+  require 'sinatra/base'
+
+  use Sinatra do
+    get('/') { ... }
+  end
+
+  run RailsProject::Application
+
 == Contextes et Binding
 
 Le contexte dans lequel vous êtes détermine les méthodes et variables
@@ -1702,6 +1786,7 @@ Vous avez le binding du contexte de l'application dans:
 * Les méthodes définies par les extensions
 * Le bloc passé à `helpers`
 * Les procs/blocs utilisés comme argument pour `set`
+* Le bloc passé à <tt>Sinatra.new</tt>
 
 Vous pouvez atteindre ce contexte (donc la classe) de la façon suivante:
 
@@ -1776,21 +1861,8 @@ Les options sont:
 
 == 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.
@@ -1801,14 +1873,18 @@ Les versions suivantes de Ruby sont officiellement supportées :
   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.
+  Rubinius est officiellement supporté (Rubinius >= 1.2.3), tout fonctionne,
+  y compris tous les langages de template.
 
 [ JRuby ]
-  JRuby est officiellement supporté (JRuby >= 1.5.6). Aucune anomalie avec
+  JRuby est officiellement supporté (JRuby >= 1.6.0). 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.
+  le serveur Thin n'est pas complètement supporté par JRuby. Le support des
+  extensions C dans JRuby est encore expérimental, ce qui n'affecte que
+  RDiscount.
+
+<b>Ruby 1.8.6 n'est plus supporté.</b>
 
 Nous gardons également un oeil sur les versions Ruby à venir.
 
@@ -1816,15 +1892,18 @@ 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
+* MacRuby, Maglev, IronRuby
 * Ruby 1.9.0 et 1.9.1
+* Ruby 1.8.6 avec {backports}[https://github.com/marcandre/backports/#readme]
 
 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.
 
+Nous faisons également notre intégration continue (CI) avec ruby-head (la
+future 1.9.3), mais nous ne pouvons rien garantir étant donné que c'est
+constant mouvement. Vous pouvez vous attendre à ce que 1.9.3p0 soit supporté.
+
 Sinatra devrait fonctionner sur n'importe quel système d'exploitation
 supportant l'implémentation Ruby choisie.