RubyGems - logstash-output-newrelic - Versions diffs - 1.2.0 → 1.2.1 - Mend

logstash-output-newrelic 1.2.0 → 1.2.1

Files changed (3962) hide show

data/vendor/bundle/jruby/2.5.0/gems/sinatra-1.4.8/README.fr.md DELETED Viewed

@@ -1,3014 +0,0 @@
-# Sinatra
-*Attention : Ce document correspond à la traduction de la version anglaise et
-il n'est peut-être plus à jour.*
-Sinatra est un [DSL](https://fr.wikipedia.org/wiki/Langage_dédié) pour
-créer rapidement et facilement des applications web en Ruby :
-```ruby
-# mon_application.rb
-require 'sinatra'
-get '/' do
-  'Bonjour le monde !'
-end
-```
-Installez la gem Sinatra :
-```shell
-gem install sinatra
-```
-Puis lancez votre programme :
-```shell
-ruby mon_application.rb
-```
-Le résultat est visible sur :
-[http://localhost:4567](http://localhost:4567)
-Il est recommandé d'exécuter également `gem install thin`, pour que
-Sinatra utilise le server Thin quand il est disponible.
-## Table des matières
-* [Sinatra](#sinatra)
-    * [Table des matières](#table-des-matières)
-    * [Routes](#routes)
-    * [Conditions](#conditions)
-    * [Valeurs de retour](#valeurs-de-retour)
-    * [Masques de route spécifiques](#masques-de-route-spécifiques)
-    * [Fichiers statiques](#fichiers-statiques)
-    * [Vues / Templates](#vues--templates)
-        * [Templates littéraux](#templates-littéraux)
-        * [Langages de template disponibles](#langages-de-template-disponibles)
-            * [Templates Haml](#templates-haml)
-            * [Templates Erb](#templates-erb)
-            * [Templates Builder](#templates-builder)
-            * [Templates Nokogiri](#templates-nokogiri)
-            * [Templates Sass](#templates-sass)
-            * [Templates SCSS](#templates-scss)
-            * [Templates Less](#templates-less)
-            * [Templates Liquid](#templates-liquid)
-            * [Templates Markdown](#templates-markdown)
-            * [Templates Textile](#templates-textile)
-            * [Templates RDoc](#templates-rdoc)
-            * [Templates Radius](#templates-radius)
-            * [Templates Markaby](#templates-markaby)
-            * [Templates RABL](#templates-rabl)
-            * [Templates Slim](#templates-slim)
-            * [Templates Creole](#templates-creole)
-            * [Templates CoffeeScript](#templates-coffeescript)
-            * [Templates Stylus](#templates-stylus)
-            * [Templates Yajl](#templates-yajl)
-            * [Templates WLang](#templates-wlang)
-        * [Accéder aux variables dans un Template](#accéder-aux-variables-dans-un-template)
-        * [Templates avec `yield` et layouts imbriqués](#templates-avec-yield-et-layouts-imbriqués)
-        * [Templates dans le fichier source](#templates-dans-le-fichier-source)
-        * [Templates nommés](#templates-nommés)
-        * [Associer des extensions de fichier](#associer-des-extensions-de-fichier)
-        * [Ajouter son propre moteur de rendu](#ajouter-son-propre-moteur-de-rendu)
-    * [Filtres](#filtres)
-    * [Helpers](#helpers)
-        * [Utiliser les sessions](#utiliser-les-sessions)
-        * [Halt](#halt)
-        * [Passer](#passer)
-        * [Déclencher une autre route](#déclencher-une-autre-route)
-        * [Définir le corps, le code retour et les en-têtes](#définir-le-corps-le-code-retour-et-les-en-têtes)
-        * [Faire du streaming](#faire-du-streaming)
-        * [Journalisation (Logging)](#journalisation-logging)
-        * [Types Mime](#types-mime)
-        * [Former des URLs](#former-des-urls)
-        * [Redirection du navigateur](#redirection-du-navigateur)
-        * [Contrôle du cache](#contrôle-du-cache)
-        * [Envoyer des fichiers](#envoyer-des-fichiers)
-        * [Accéder à l'objet requête](#accéder-à-lobjet-requête)
-        * [Fichiers joints](#fichiers-joints)
-        * [Gérer Date et Time](#gérer-date-et-time)
-        * [Chercher les fichiers de templates](#chercher-les-fichiers-de-templates)
-    * [Configuration](#configuration)
-        * [Se protéger des attaques](#se-protéger-des-attaques)
-        * [Paramètres disponibles](#paramètres-disponibles)
-    * [Environements](#environements)
-    * [Gérer les erreurs](#gérer-les-erreurs)
-        * [NotFound](#notfound)
-        * [Error](#error)
-    * [Les Middlewares Rack](#les-middlewares-rack)
-    * [Tester](#tester)
-    * [Sinatra::Base - Les Middlewares, Bibliothèques, et Applications Modulaires](#sinatrabase---les-middlewares-bibliothèques-et-applications-modulaires)
-        * [Style modulaire vs. style classique](#style-modulaire-vs-style-classique)
-        * [Servir une application modulaire](#servir-une-application-modulaire)
-        * [Utiliser une application de style classique avec un fichier config.ru](#utiliser-une-application-de-style-classique-avec-un-fichier-configru)
-        * [Quand utiliser un fichier config.ru ?](#quand-utiliser-un-fichier-configru-)
-        * [Utiliser Sinatra comme Middleware](#utiliser-sinatra-comme-middleware)
-        * [Création dynamique d'applications](#création-dynamique-dapplications)
-    * [Contextes et Binding](#contextes-et-binding)
-        * [Contexte de l'application/classe](#contexte-de-lapplicationclasse)
-        * [Contexte de la requête/instance](#contexte-de-la-requêteinstance)
-        * [Le contexte de délégation](#le-contexte-de-délégation)
-    * [Ligne de commande](#ligne-de-commande)
-        * [Multi-threading](#multi-threading)
-    * [Configuration nécessaire](#configuration-nécessaire)
-    * [Essuyer les plâtres](#essuyer-les-plâtres)
-        * [Installer avec Bundler](#installer-avec-bundler)
-        * [Faire un clone local](#faire-un-clone-local)
-        * [Installer globalement](#installer-globalement)
-    * [Versions](#versions)
-    * [Mais encore](#mais-encore)
-## Routes
-Dans Sinatra, une route est une méthode HTTP couplée à un masque (pattern)
-URL. Chaque route est associée à un bloc :
-```ruby
-get '/' do
-  .. montrer quelque chose ..
-end
-post '/' do
-  .. créer quelque chose ..
-end
-put '/' do
-  .. remplacer quelque chose ..
-end
-patch '/' do
-  .. changer quelque chose ..
-end
-delete '/' do
-  .. effacer quelque chose ..
-end
-options '/' do
-  .. paramétrer quelque chose ..
-end
-link '/' do
-  .. relier quelque chose ..
-end
-unlink '/' do
-  .. séparer quelque chose ..
-end
-```
-Les routes sont évaluées  dans l'ordre où elles ont été définies. La première
-route qui correspond à la requête est appelée.
-Les masques peuvent inclure des paramètres nommés, accessibles par
-l'intermédiaire du hash `params` :
-```ruby
-get '/bonjour/:nom' do
-  # répond aux requêtes "GET /bonjour/foo" et "GET /bonjour/bar"
-  # params['nom'] est 'foo' ou 'bar'
-  "Bonjour #{params['nom']} !"
-end
-```
-Vous pouvez aussi accéder aux paramètres nommés directement grâce aux
-paramètres du bloc comme ceci :
-```ruby
-get '/bonjour/:nom' do |n|
-  # répond aux requêtes "GET /bonjour/foo" et "GET /bonjour/bar"
-  # params['nom'] est 'foo' ou 'bar'
-  # n contient params['nom']
-  "Bonjour #{n} !"
-end
-```
-Une route peut contenir un `splat` (caractère joker), accessible par
-l'intermédiaire du tableau `params['splat']` :
-```ruby
-get '/dire/*/a/*' do
-  # répond à /dire/bonjour/a/monde
-  params['splat'] # => ["bonjour", "monde"]
-end
-get '/telecharger/*.*' do
-  # répond à /telecharger/chemin/vers/fichier.xml
-  params['splat'] # => ["chemin/vers/fichier", "xml"]
-end
-```
-Ou par l'intermédiaire des paramètres du bloc :
-```ruby
-get '/telecharger/*.*' do |chemin, ext|
-  [chemin, ext] # => ["path/to/file", "xml"]
-end
-```
-Une route peut aussi être définie par une expression régulière :
-```ruby
-get /\A\/bonjour\/([\w]+)\z/ do
-  "Bonjour, #{params['captures'].first} !"
-end
-```
-Là encore on peut utiliser les paramètres de bloc :
-```ruby
-get %r{/bonjour/([\w]+)} do |c|
-  # répond à "GET /meta/bonjour/monde", "GET /bonjour/monde/1234" etc.
-  "Bonjour, #{c} !"
-end
-```
-Les routes peuvent aussi comporter des paramètres optionnels :
-```ruby
-get '/articles/:format?' do
-  # répond à "GET /articles/" ou avec une extension "GET /articles/json", "GET /articles/xml" etc...
-end
-```
-Ainsi que des paramètres d'URL :
-```ruby
-get '/articles' do
-  # répond à "GET /articles?titre=foo&auteur=bar"
-  titre = params['titre']
-  auteur = params['auteur']
-  # utilise les variables titre et auteur qui sont des paramètres d'URL optionnels pour la route /articles
-end
-```
-A ce propos, à moins d'avoir désactivé la protection contre les attaques par
-"path transversal" (voir plus loin), l'URL demandée peut avoir été modifiée
-avant d'être comparée à vos routes.
-## Conditions
-Les routes peuvent définir toutes sortes de conditions, comme par exemple le
-"user agent" :
-```ruby
-get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
-  "Vous utilisez Songbird version #{params['agent'][0]}"
-end
-get '/foo' do
-  # Correspond à tous les autres navigateurs
-end
-```
-Les autres conditions disponibles sont `host_name` et `provides` :
-```ruby
-get '/', :host_name => /^admin\./ do
-  "Zone Administrateur, Accès refusé !"
-end
-get '/', :provides => 'html' do
-  haml :index
-end
-get '/', :provides => ['rss', 'atom', 'xml'] do
-  builder :feed
-end
-```
-`provides` se base sur l'en-tête `Accept` de la requête.
-Vous pouvez facilement définir vos propres conditions :
-```ruby
-set(:chance) { |valeur| condition { rand <= valeur } }
-get '/gagner_une_voiture', :chance => 0.1 do
-  "Vous avez gagné !"
-end
-get '/gagner_une_voiture' do
-  "Désolé, vous avez perdu."
-end
-```
-Utilisez un `splat` (caractère joker) dans le cas d'une condition qui prend
-plusieurs valeurs :
-```ruby
-set(:auth) do |*roles|   # <- ici on utilise un splat
-  condition do
-    unless logged_in? && roles.any? {|role| current_user.in_role? role }
-      redirect "/login/", 303
-    end
-  end
-end
-get "/mon/compte/", :auth => [:user, :admin] do
-  "Informations sur votre compte"
-end
-get "/reserve/aux/admins/", :auth => :admin do
-  "Seuls les administrateurs sont acceptés ici !"
-end
-```
-## Valeurs de retour
-La valeur renvoyée par le bloc correspondant à une route constitue le corps de
-la réponse qui sera transmise au client HTTP ou du moins au prochain `middleware`
-dans la pile Rack. Le plus souvent, 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 qu'il s'agisse d'une réponse Rack
-valide, d'un corps de réponse Rack ou d'un code statut HTTP :
-* Un tableau de 3 éléments : `[code statut (Fixnum), en-têtes (Hash), corps
-  de la réponse (répondant à #each)]`
-* Un tableau de 2 élements : `[code statut (Fixnum), corps de la réponse
-  (répondant à #each)]`
-* Un objet qui répond à `#each` et qui ne transmet que des chaînes de
-  caractères au bloc fourni
-* Un Fixnum représentant le code statut
-Ainsi, on peut facilement implémenter un exemple de streaming :
-```ruby
-class Stream
-  def each
-    100.times { |i| yield "#{i}\n" }
-  end
-end
-get('/') { Stream.new }
-```
-Vous pouvez aussi utiliser le helper `stream` (présenté un peu plus loin) pour
-éviter les répétitions et intégrer le traitement relatif au streaming dans le bloc
-de code de la route.
-## Masques de route spécifiques
-Comme cela a été vu auparavant, Sinatra offre la possibilité d'utiliser des
-masques sous forme de chaines de caractères ou des expressions régulières
-pour définir les routes. Mais il est possible de faire bien plus. Vous pouvez
-facilement définir vos propres masques :
-```ruby
-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 plus compliqué qu'il ne devrait et peut être implémenté de la façon suivante :
-```ruby
-get // do
-  pass if request.path_info == "/index"
-  # ...
-end
-```
-Ou bien en utilisant cette expression regulière :
-```ruby
-get %r{^(?!/index$)} do
-  # ...
-end
-```
-## Fichiers statiques
-Les fichiers du dossier `./public` sont servis de façon statique. Vous pouvez spécifier un autre dossier avec le paramètre `:public_folder` :
-```ruby
-set :public_folder, File.dirname(__FILE__) + '/statique'
-```
-Notez que le nom du dossier public n'apparait pas dans l'URL. Le fichier
-`./public/css/style.css` sera accessible à l'URL :
-`http://exemple.com/css/style.css`.
-Utilisez le paramètre `:static_cache_control` pour ajouter l'information
-d'en-tête `Cache-Control` (voir plus bas).
-## Vues / Templates
-Chaque langage de template est disponible via sa propre méthode de rendu,
-lesquelles renvoient tout simplement une chaîne de caractères.
-```ruby
-get '/' do
-  erb :index
-end
-```
-Ceci génère la vue `views/index.erb`.
-Plutôt que d'utiliser le nom d'un template, vous pouvez directement passer
-le contenu du template :
-```ruby
-get '/' do
-  code = "<%= Time.now %>"
-  erb code
-end
-```
-Les méthodes de templates acceptent un hash d'options comme second argument :
-```ruby
-get '/' do
-  erb :index, :layout => :post
-end
-```
-Ceci génèrera la vue `views/index.erb` en l'intégrant au *layout* `views/post.erb` (`views/layout.erb` est la valeur par défaut si ce fichier existe).
-Toute option que Sinatra ne comprend pas sera passée au moteur de rendu :
-```ruby
-get '/' do
-  haml :index, :format => :html5
-end
-```
-Vous pouvez également définir les options de chaque langage de template de façon
-générale :
-```ruby
-set :haml, :format => html5
-get '/' do
-  haml :index
-end
-```
-Les arguments passés à la méthode de rendu prennent le pas sur les options définies au moyen de `set`.
-Options disponibles :
-<dl>
-  <dt>locals</dt>
-  <dd>
-    Liste de variables locales passées au document. Pratique pour les vues
-    partielles.
-    Exemple : <tt>erb "<%= foo %>", :locals => {:foo => "bar"}</tt>.
-  </dd>
-  <dt>default_encoding</dt>
-  <dd>
-    Encodage de caractères à utiliser en cas d'incertitude. Par défaut
-    <tt>settings.default_encoding</tt>.
-  </dd>
-  <dt>views</dt>
-  <dd>
-    Dossier de vues dans lequel chercher les templates. Par défaut
-    <tt>settings.views</tt>.
-  </dd>
-  <dt>layout</dt>
-  <dd>
-    S'il faut ou non utiliser un layout (<tt>true</tt> ou <tt>false</tt>).
-    Ou indique le template à utiliser lorsque c'est un symbole. Exemple :
-    <tt>erb :index, :layout => !request.xhr?</tt>.
-  </dd>
-  <dt>content_type</dt>
-  <dd>
-    Content-Type que le template génère. La valeur par défaut dépend du langage de template.
-  </dd>
-  <dt>scope</dt>
-  <dd>
-    Contexte dans lequel effectuer le rendu du template. Par défaut il s'agit
-    de l'instance de l'application. Si vous changez cela, les variables
-    d'instance et les méthodes utilitaires ne seront pas disponibles.
-  </dd>
-  <dt>layout_engine</dt>
-  <dd>
-    Moteur de rendu à utiliser pour le layout. Utile pour les langages ne
-    supportant pas les layouts. Il s'agit par défaut du moteur utilisé pour
-    le rendu du template. Exemple : <tt>set :rdoc, :layout_engine => :erb</tt>
-  </dd>
-  <dt>layout_options</dt>
-  <dd>
-    Options spécifiques à la génération du layout. Exemple : <tt>set :rdoc,
-    :layout_options => { :views => 'views/layouts' }</tt>
-  </dd>
-</dl>
-Les templates sont supposés se trouver directement dans le dossier
-`./views`. Pour utiliser un dossier de vues différent :
-```ruby
-set :views, settings.root + '/templates'
-```
-Il est important de se souvenir que les templates sont toujours référencés
-sous forme de symboles, même lorsqu'ils sont dans un sous-répertoire (dans
-ce cas, utilisez `:'sous_repertoire/template'`). Il faut utiliser
-un symbole car les méthodes de rendu évaluent le contenu des chaînes de
-caractères au lieu de les considérer comme un chemin vers un fichier.
-### Templates littéraux
-```ruby
-get '/' do
-  haml '%div.title Bonjour le monde'
-end
-```
-Utilisera la chaine de caractères comme template pour générer la réponse.
-### Langages de template disponibles
-Certains langages ont plusieurs implémentations. Pour préciser l'implémentation
-à utiliser (et garantir l'aspect thread-safe), vous devez simplement l'avoir
-chargée au préalable :
-```ruby
-require 'rdiscount' # ou require 'bluecloth'
-get('/') { markdown :index }
-```
-#### Templates Haml
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://haml.info/" title="haml">haml</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.haml</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>haml :index, :format => :html5</tt></td>
-  </tr>
-</table>
-#### Templates Erb
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td>
-      <a href="http://www.kuwata-lab.com/erubis/" title="erubis">erubis</a>
-      ou erb (inclus avec Ruby)
-    </td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.erb</tt>, <tt>.rhtml</tt> ou <tt>.erubis</tt> (Erubis seulement)</td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>erb :index</tt></td>
-  </tr>
-</table>
-#### Templates Builder
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td>
-      <a href="https://github.com/jimweirich/builder" title="builder">builder</a>
-    </td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.builder</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>builder { |xml| xml.em "salut" }</tt></td>
-  </tr>
-</table>
-Ce moteur accepte également un bloc pour des templates en ligne (voir
-exemple).
-#### Templates Nokogiri
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://www.nokogiri.org/" title="nokogiri">nokogiri</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.nokogiri</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>nokogiri { |xml| xml.em "salut" }</tt>
-    </td>
-  </tr>
-</table>
-Ce moteur accepte également un bloc pour des templates en ligne (voir
-exemple).
-#### Templates Sass
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://sass-lang.com/" title="sass">sass</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.sass</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>sass :stylesheet, :style => :expanded</tt></td>
-  </tr>
-</table>
-#### Templates SCSS
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://sass-lang.com/" title="sass">sass</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.scss</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>scss :stylesheet, :style => :expanded</tt></p>
-    </td>
-  </tr>
-</table>
-#### Templates Less
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://lesscss.org/" title="less">less</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.less</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>less :stylesheet</tt>
-    </td>
-  </tr>
-</table>
-#### Templates Liquid
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://liquidmarkup.org/" title="liquid">liquid</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.liquid</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>liquid :index, :locals => { :key => 'value' }</tt></td>
-  </tr>
-</table>
-Comme vous ne pouvez appeler de méthodes Ruby (autres que `yield`)
-dans un template Liquid, vous aurez sûrement à lui passer des variables
-locales.
-#### Templates Markdown
-<table>
-  <tr>
-    <td><p>Dépendances</p></td>
-    <td>
-      Au choix :
-      <a href="https://github.com/davidfstr/rdiscount" title="RDiscount">RDiscount</a>,
-      <a href="https://github.com/vmg/redcarpet" title="RedCarpet">RedCarpet</a>,
-      <a href="http://deveiate.org/projects/BlueCloth" title="BlueCloth">BlueCloth</a>,
-      <a href="http://kramdown.gettalong.org/" title="kramdown">kramdown</a>,
-      <a href="https://github.com/bhollis/maruku" title="maruku">maruku</a>
-    </td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.markdown</tt>, <tt>.mkd</tt> et <tt>.md</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>markdown :index, :layout_engine => :erb</tt></td>
-  </tr>
-</table>
-Il n’est pas possible d’appeler des méthodes depuis markdown, ni de
-lui passer de variables locales. Par conséquent, il sera souvent utilisé
-en combinaison avec un autre moteur de rendu :
-```ruby
-erb :accueil, :locals => { :text => markdown(:introduction) }
-```
-Notez que vous pouvez également appeler la méthode `markdown` depuis un autre template :
-```ruby
-%h1 Bonjour depuis Haml !
-%p= markdown(:bienvenue)
-```
-Comme vous ne pouvez pas appeler de méthode Ruby depuis Markdown, vous ne
-pouvez pas utiliser de layouts écrits en Markdown. Toutefois, il
-est possible d’utiliser un moteur de rendu différent pour le template et
-pour le layout en utilisant l’option `:layout_engine`.
-#### Templates Textile
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://redcloth.org/" title="RedCloth">RedCloth</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.textile</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>textile :index, :layout_engine => :erb</tt></td>
-  </tr>
-</table>
-Il n’est pas possible d’appeler de méthodes depuis textile, ni de lui
-passer de variables locales. Par conséquent, il sera souvent utilisé en
-combinaison avec un autre moteur de rendu :
-```ruby
-erb :accueil, :locals => { :text => textile(:introduction) }
-```
-Notez que vous pouvez également appeler la méthode `textile` depuis un autre template :
-```ruby
-%h1 Bonjour depuis Haml !
-%p= textile(:bienvenue)
-```
-Comme vous ne pouvez pas appeler de méthode Ruby depuis Textile, vous ne pouvez
-pas utiliser de layouts écrits en Textile. Toutefois, il est
-possible d’utiliser un moteur de rendu différent pour le template et
-pour le layout en utilisant l’option `:layout_engine`.
-#### Templates RDoc
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://rdoc.sourceforge.net/" title="RDoc">RDoc</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.rdoc</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>rdoc :README, :layout_engine => :erb</tt></td>
-  </tr>
-</table>
-Il n’est pas possible d’appeler de méthodes Ruby depuis rdoc, ni de lui
-passer de variables locales. Par conséquent, il sera souvent utilisé en
-combinaison avec un autre moteur de rendu :
-```ruby
-erb :accueil, :locals => { :text => rdoc(:introduction) }
-```
-Notez que vous pouvez également appeler la méthode `rdoc` depuis un autre template :
-```ruby
-%h1 Bonjour depuis Haml !
-%p= rdoc(:bienvenue)
-```
-Comme vous ne pouvez pas appeler de méthodes Ruby depuis RDoc, vous ne pouvez
-pas utiliser de layouts écrits en RDoc. Toutefois, il est
-possible d’utiliser un moteur de rendu différent pour le template et
-pour le layout en utilisant l’option `:layout_engine`.
-#### Templates Radius
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="https://github.com/jlong/radius" title="Radius">Radius</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.radius</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>radius :index, :locals => { :key => 'value' }</tt></td>
-  </tr>
-</table>
-Comme vous ne pouvez pas appeler de méthodes Ruby depuis un template
-Radius, vous aurez sûrement à lui passer des variables locales.
-#### Templates Markaby
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://markaby.github.io/" title="Markaby">Markaby</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.mab</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>markaby { h1 "Bienvenue !" }</tt></td>
-  </tr>
-</table>
-Ce moteur accepte également un bloc pour des templates en ligne (voir
-exemple).
-#### Templates RABL
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="https://github.com/nesquena/rabl" title="Rabl">Rabl</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.rabl</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>rabl :index</tt></td>
-  </tr>
-</table>
-#### Templates Slim
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="http://slim-lang.com/" title="Slim Lang">Slim Lang</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.slim</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>slim :index</tt></td>
-  </tr>
-</table>
-#### Templates Creole
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="https://github.com/minad/creole" title="Creole">Creole</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.creole</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>creole :wiki, :layout_engine => :erb</tt></td>
-  </tr>
-</table>
-Il n'est pas possible d'appeler de méthodes Ruby depuis creole, ni de lui
-passer de variables locales. Par conséquent, il sera souvent utilisé en
-combinaison avec un autre moteur de rendu :
-```ruby
-erb :accueil, :locals => { :text => markdown(:introduction) }
-```
-Notez que vous pouvez également appeler la méthode `creole` depuis un autre template :
-```ruby
-%h1 Bonjour depuis Haml !
-%p= creole(:bienvenue)
-```
-Comme vous ne pouvez pas appeler de méthodes Ruby depuis Creole, vous ne pouvez
-pas utiliser de layouts écrits en Creole. Toutefois, il est possible
-d'utiliser un moteur de rendu différent pour le template et pour le layout
-en utilisant l'option `:layout_engine`.
-#### Templates CoffeeScript
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td>
-      <a href="https://github.com/josh/ruby-coffee-script" title="Ruby CoffeeScript">
-        CoffeeScript
-      </a>
-      et un
-      <a href="https://github.com/sstephenson/execjs/blob/master/README.md#readme" title="ExecJS">
-        moyen d'exécuter javascript
-      </a>
-    </td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.coffee</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>coffee :index</tt></td>
-  </tr>
-</table>
-#### Templates Stylus
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td>
-      <a href="https://github.com/forgecrafted/ruby-stylus" title="Ruby Stylus">
-        Stylus
-      </a>
-      et un
-      <a href="https://github.com/sstephenson/execjs/blob/master/README.md#readme" title="ExecJS">
-        moyen d'exécuter javascript
-      </a>
-    </td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.styl</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>stylus :index</tt></td>
-  </tr>
-</table>
-Avant de pouvoir utiliser des templates Stylus, vous devez auparavant charger
-`stylus` et `stylus/tilt` :
-```ruby
-require 'sinatra'
-require 'stylus'
-require 'stylus/tilt'
-get '/' do
-  stylus :exemple
-end
-```
-#### Templates Yajl
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td>
-      <a href="https://github.com/brianmario/yajl-ruby" title="yajl-ruby">yajl-ruby</a>
-    </td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.yajl</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'ressource'</tt></p>
-    </td>
-  </tr>
-</table>
-La source du template est évaluée en tant que chaine Ruby, puis la
-variable json obtenue est convertie avec #to_json.
-```ruby
-json = { :foo => 'bar' }
-json[:baz] = key
-```
-Les options `:callback` et `:variable` peuvent être utilisées pour décorer
-l’objet retourné.
-```ruby
-var ressource = {"foo":"bar","baz":"qux"}; present(ressource);</pre>
-```
-#### Templates WLang
-<table>
-  <tr>
-    <td>Dépendances</td>
-    <td><a href="https://github.com/blambeau/wlang/" title="wlang">wlang</a></td>
-  </tr>
-  <tr>
-    <td>Extensions de fichier</td>
-    <td><tt>.wlang</tt></td>
-  </tr>
-  <tr>
-    <td>Exemple</td>
-    <td><tt>wlang :index, :locals => { :key => 'value' }</tt></td>
-  </tr>
-</table>
-L’appel de code ruby au sein des templates n’est pas idiomatique en wlang.
-L’écriture de templates sans logique est encouragée, via le passage de variables
-locales. Il est néanmoins possible d’écrire un layout en wlang et d’y utiliser
-`yield`.
-### Accéder aux variables dans un Template
-Un template est évalué dans le même contexte que l'endroit d'où il a été
-appelé (gestionnaire de route). Les variables d'instance déclarées dans le
-gestionnaire de route sont directement accessibles dans le template :
-```ruby
-get '/:id' do
-  @foo = Foo.find(params['id'])
-  haml '%h1= @foo.nom'
-end
-```
-Alternativement, on peut passer un hash contenant des variables locales :
-```ruby
-get '/:id' do
-  foo = Foo.find(params['id'])
-  haml '%h1= foo.nom', :locals => { :foo => foo }
-end
-```
-Ceci est généralement nécessaire lorsque l'on veut utiliser un template depuis un autre template (partiel) et qu'il faut donc adapter le nom des variables.
-### Templates avec `yield` et layouts imbriqués
-En général, un layout est un simple template qui appelle `yield`. Ce genre de
-template peut s'utiliser via l'option `:template`  comme décrit précédemment ou
-peut être rendu depuis un bloc :
-```ruby
-erb :post, :layout => false do
-  erb :index
-end
-```
-Ce code est plus ou moins équivalent à `erb :index, :layout => :post`.
-Le fait de passer des blocs aux méthodes de rendu est particulièrement utile
-pour gérer des templates imbriqués :
-```ruby
-erb :layout_principal, :layout => false do
-  erb :layout_admin do
-    erb :utilisateur
-  end
-end
-```
-Ou plus brièvement :
-```ruby
-erb :layout_admin, :layout => :layout_principal do
-  erb :utilisateur
-end
-```
-Actuellement, les méthodes de rendu qui acceptent un bloc sont : `erb`, `haml`,
-`liquid`, `slim ` et `wlang`. La méthode générale `render` accepte elle aussi
-un bloc.
-### Templates dans le fichier source
-Des templates peuvent être définis dans le fichier source comme ceci :
-```ruby
-require 'sinatra'
-get '/' do
-  haml :index
-end
-__END__
-@@ layout
-%html
-  = yield
-@@ index
-%div.title Bonjour le monde !
-```
-NOTE : Les templates du fichier source qui contient `require 'sinatra'`
-sont automatiquement chargés. Si vous avez des templates dans d'autres
-fichiers source, il faut explicitement les déclarer avec
-`enable :inline_templates`.
-### Templates nommés
-Les templates peuvent aussi être définis grâce à la méthode de haut niveau `template` :
-```ruby
-template :layout do
-  "%html\n  =yield\n"
-end
-template :index do
-  '%div.title Bonjour le monde !'
-end
-get '/' do
-  haml :index
-end
-```
-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 `:layout => false` ou bien les désactiver par défaut au moyen
-de `set :haml, :layout => false` :
-```ruby
-get '/' do
-  haml :index, :layout => !request.xhr?
-end
-```
-### Associer des extensions de fichier
-Pour associer une extension de fichier avec un moteur de rendu, utilisez
-`Tilt.register`. Par exemple, si vous désirez utiliser l'extension
-de fichier `tt` pour les templates Textile, vous pouvez faire comme suit :
-```ruby
-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 :
-```ruby
-Tilt.register :monmoteur, MonMerveilleuxMoteurDeRendu
-helpers do
-  def monmoteur(*args) render(:monmoteur, *args) end
-end
-get '/' do
-  monmoteur :index
-end
-```
-Utilisera `./views/index.monmoteur`. Voir [le projet Github](https://github.com/rtomayko/tilt) pour en savoir plus sur Tilt.
-## Filtres
-Les filtres `before` sont exécutés avant chaque requête, dans le même contexte
-que les routes, et permettent de modifier la requête et sa réponse. Les
-variables d'instance déclarées dans les filtres sont accessibles au niveau
-des routes et des templates :
-```ruby
-before do
-  @note = 'Coucou !'
-  request.path_info = '/foo/bar/baz'
-end
-get '/foo/*' do
-  @note #=> 'Coucou !'
-  params['splat'] #=> 'bar/baz'
-end
-```
-Les filtres `after` sont exécutés après chaque requête à l'intérieur du même
-contexte et permettent de modifier la requête et sa réponse. Les variables
-d'instance déclarées dans les filtres `before` ou les routes sont accessibles
-au niveau des filtres `after` :
-```ruby
-after do
-  puts response.status
-end
-```
-Note : Le corps de la réponse n'est pas disponible au niveau du filtre `after`
-car il ne sera généré que plus tard (sauf dans le cas où vous utilisez la
-méthode `body` au lieu de simplement renvoyer une chaine depuis vos routes).
-Les filtres peuvent être associés à un masque, ce qui permet de limiter leur
-exécution aux cas où la requête correspond à ce masque :
-```ruby
-before '/secret/*' do
-  authentification!
-end
-after '/faire/:travail' do |travail|
-  session['dernier_travail'] = travail
-end
-```
-Tout comme les routes, les filtres acceptent également des conditions :
-```ruby
-before :agent => /Songbird/ do
-  # ...
-end
-after '/blog/*', :host_name => 'example.com' do
-  # ...
-end
-```
-## Helpers
-Utilisez la méthode de haut niveau `helpers` pour définir des méthodes
-qui seront accessibles dans vos gestionnaires de route et dans vos templates :
-```ruby
-helpers do
-  def bar(nom)
-    "#{nom}bar"
-  end
-end
-get '/:nom' do
-  bar(params['nom'])
-end
-```
-Vous pouvez aussi définir les méthodes helper dans un module séparé :
-```ruby
-module FooUtils
-  def foo(nom) "#{nom}foo" end
-end
-module BarUtils
-  def bar(nom) "#{nom}bar" end
-end
-helpers FooUtils, BarUtils
-```
-Cela a le même résultat que d'inclure les modules dans la classe de
-l'application.
-### Utiliser les sessions
-Les sessions sont utilisées pour conserver un état entre les requêtes. Une fois
-activées, vous avez un hash de session par session utilisateur :
-```ruby
-enable :sessions
-get '/' do
-  "valeur = " << session['valeur'].inspect
-end
-get '/:valeur' do
-  session['valeur'] = params['valeur']
-end
-```
-Notez que `enable :sessions` 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'utilisez **pas**
-`enable :sessions` dans ce cas mais chargez le middleware de votre
-choix comme vous le feriez pour n'importe quel autre middleware :
-```ruby
-use Rack::Session::Pool, :expire_after => 2592000
-get '/' do
-  "valeur = " << session['valeur'].inspect
-end
-get '/:valeur' do
-  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 :
-```ruby
-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` :
-```ruby
-set :sessions, :domain => 'foo.com'
-```
-Pour que les différents sous-domaines de foo.com puissent partager une session,
-vous devez précéder le domaine d'un *.* (point) :
-```ruby
-set :sessions, :domain => '.foo.com'
-```
-### Halt
-Pour arrêter immédiatement la requête dans un filtre ou un gestionnaire de
-route :
-```ruby
-halt
-```
-Vous pouvez aussi passer le code retour ...
-```ruby
-halt 410
-```
-Ou le texte ...
-```ruby
-halt 'Ceci est le texte'
-```
-Ou les deux ...
-```ruby
-halt 401, 'Partez !'
-```
-Ainsi que les en-têtes ...
-```ruby
-halt 402, {'Content-Type' => 'text/plain'}, 'revanche'
-```
-Bien sûr il est possible de combiner un template avec `halt` :
-```ruby
-halt erb(:erreur)
-```
-### Passer
-Une route peut passer le relais aux autres routes qui correspondent également
-avec `pass` :
-```ruby
-get '/devine/:qui' do
-  pass unless params['qui'] == 'Frank'
-  "Tu m'as eu !"
-end
-get '/devine/*' do
-  'Manqué !'
-end
-```
-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` :
-```ruby
-get '/foo' do
-  status, headers, body = call env.merge("PATH_INFO" => '/bar')
-  [status, headers, body.map(&: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 `"bar"` dans un helper
-utilisé à la fois par `/foo` et `/bar`.
-Si vous souhaitez que la requête soit envoyée à la même instance de
-l'application plutôt qu'à une copie, utilisez `call!` au lieu de
-`call`.
-Lisez la spécification Rack si vous souhaitez en savoir plus sur
-`call`.
-### Définir le corps, le code retour et les en-tê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 :
-```ruby
-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 en-têtes :
-```ruby
-get '/foo' do
-  status 418
-  headers \
-    "Allow"   => "BREW, POST, GET, PROPFIND, WHEN",
-    "Refresh" => "Refresh: 20; http://www.ietf.org/rfc/rfc2324.txt"
-  body "Je suis une théière !"
-end
-```
-Comme pour `body`, `headers` et `status` peuvent être utilisés sans arguments
-pour accéder à leurs valeurs.
-### Faire du streaming
-Il y a des cas où vous voulez commencer à renvoyer des données pendant que
-vous êtes en train de générer le reste de la réponse. Dans les cas les plus
-extrèmes, vous souhaitez continuer à envoyer des données tant que le client
-n'abandonne pas la connexion. Vous pouvez alors utiliser le helper `stream`
-pour éviter de créer votre propre système :
-```ruby
-get '/' do
-  stream do |out|
-    out << "Ca va être hallu -\n"
-    sleep 0.5
-    out << " (attends la suite) \n"
-    sleep 1
-    out << "- cinant !\n"
-  end
-end
-```
-Cela permet d'implémenter des API de streaming ou de
-[Server Sent Events](https://w3c.github.io/eventsource/) et peut servir de
-base pour des [WebSockets](https://en.wikipedia.org/wiki/WebSocket). Vous
-pouvez aussi l'employer pour augmenter le débit quand une partie du contenu
-provient d'une ressource lente.
-Le fonctionnement du streaming, notamment le nombre de requêtes simultanées,
-dépend énormément du serveur web utilisé. Certains ne prennent pas du tout en
-charge le streaming. Lorsque le serveur ne gère pas le streaming, la partie
-body de la réponse sera envoyée au client en une seule fois, après
-l'exécution du bloc passé au helper `stream`. Le streaming ne
-fonctionne pas du tout avec Shotgun.
-En utilisant le helper `stream` avec le paramètre `keep_open`, il n'appelera
-pas la méthode `close` du flux, vous laissant la possibilité de le fermer à
-tout moment au cours de l'exécution. Ceci ne fonctionne qu'avec les serveurs
-evented (ie non threadés) tels que Thin et Rainbows. Les autres serveurs
-fermeront malgré tout le flux :
-```ruby
-# interrogation prolongée
-set :server, :thin
-connexions = []
-get '/souscrire' do
-  # abonne un client aux évènements du serveur
-  stream(:keep_open) do |out|
-    connexions << out
-    # purge les connexions abandonnées
-    connexions.reject!(&:closed?)
-  end
-end
-post '/message' do
-  connexions.each do |out|
-    # prévient le client qu'un nouveau message est arrivé
-    out << params['message'] << "\n"
-    # indique au client de se connecter à nouveau
-    out.close
-  end
-  # compte-rendu
-  "message reçu"
-end
-```
-### Journalisation (Logging)
-Dans le contexte de la requête, la méthode utilitaire `logger` expose une
-instance de `Logger` :
-```ruby
-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
-`Sinatra::Application`, donc si vous héritez de `>Sinatra::Base`,
-vous aurez à l'activer vous-même :
-```ruby
-class MonApp < Sinatra::Base
-  configure :production, :development do
-    enable :logging
-  end
-end
-```
-Si vous souhaitez utiliser votre propre logger, vous devez définir le paramètre
-`logging` à `nil` pour être certain qu'aucun middleware de logging ne sera
-installé (notez toutefois que `logger` renverra alors `nil`). Dans ce cas,
-Sinatra utilisera ce qui sera présent dans `env['rack.logger']`.
-### Types Mime
-Quand vous utilisez `send_file` 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 :
-```ruby
-configure do
-  mime_type :foo, 'text/foo'
-end
-```
-Vous pouvez également les utiliser avec la méthode `content_type` :
-```ruby
-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 :
-```ruby
-%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` :
-```ruby
-get '/foo' do
-  redirect to('/bar')
-end
-```
-Tout paramètre additionnel sera utilisé comme argument pour la méthode
-`halt` :
-```ruby
-redirect to('/bar'), 303
-redirect 'http://www.google.com/', 'mauvais endroit mon pote'
-```
-Vous pouvez aussi rediriger vers la page dont l'utilisateur venait au moyen de
-`redirect back` :
-```ruby
-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 :
-```ruby
-redirect to('/bar?sum=42')
-```
-Ou bien utilisez une session :
-```ruby
-enable :sessions
-get '/foo' do
-  session['secret'] = 'foo'
-  redirect to('/bar')
-end
-get '/bar' do
-  session['secret']
-end
-```
-### Contrôle du cache
-Définissez correctement vos en-têtes à la base pour un bon cache HTTP.
-Vous pouvez facilement définir l'en-tête Cache-Control de la manière suivante :
-```ruby
-get '/' do
-  cache_control :public
-  "met le en cache !"
-end
-```
-Conseil de pro : définir le cache dans un filtre before :
-```ruby
-before do
-  cache_control :public, :must_revalidate, :max_age => 60
-end
-```
-Si vous utilisez la méthode `expires` pour définir l'en-tête correspondant,
-`Cache-Control` sera alors défini automatiquement :
-```ruby
-before do
-  expires 500, :public, :must_revalidate
-end
-```
-Pour utiliser correctement le cache, vous devriez utiliser `etag` ou
-`last_modified`. Il est recommandé d'utiliser ces méthodes *avant* de faire
-d'importantes modifications, car elles vont immédiatement déclencher la réponse
-si le client a déjà la version courante dans son cache :
-```ruby
-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](https://en.wikipedia.org/wiki/HTTP_ETag#Strong_and_weak_validation) :
-```ruby
-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 le cache de votre navigateur. Si vous êtes à la
-recherche d'une solution rapide pour un reverse-proxy de cache, essayez
-[rack-cache](https://github.com/rtomayko/rack-cache) :
-```ruby
-require "rack/cache"
-require "sinatra"
-use Rack::Cache
-get '/' do
-  cache_control :public, :max_age => 36000
-  sleep 5
-  "hello"
-end
-```
-Utilisez le paramètre `:static_cache_control` pour ajouter l'information
-d'en-tête `Cache-Control` (voir plus loin).
-D'après la RFC 2616, votre application devrait se comporter différement lorsque
-l'en-tête If-Match ou If-None-Match est défini à `*` en tenant compte du
-fait que la ressource demandée existe déjà ou pas. Sinatra considère que les
-requêtes portant sur des ressources sûres (tel que get) ou idempotentes (tel que
-put) existent déjà et pour les autres ressources (par exemple dans le cas
-de requêtes post) qu'il s'agit de nouvelles ressources. Vous pouvez modifier ce
-comportement en passant une option `:new_resource` :
-```ruby
-get '/create' do
-  etag '', :new_resource => true
-  Article.create
-  erb :nouvel_article
-end
-```
-Si vous souhaitez avoir un ETag faible, utilisez l'option `:kind` :
-```ruby
-etag '', :new_resource => true, :kind => :weak
-```
-### Envoyer des fichiers
-Pour envoyer des fichiers, vous pouvez utiliser la méthode `send_file` :
-```ruby
-get '/' do
-  send_file 'foo.png'
-end
-```
-Quelques options sont également acceptées :
-```ruby
-send_file 'foo.png', :type => :jpg
-```
-Les options sont :
-<dl>
-  <dt>filename</dt>
-  <dd>
-    le nom du fichier dans la réponse, par défaut le nom du fichier envoyé.
-  </dd>
-  <dt>last_modified</dt>
-  <dd>
-    valeur pour l’en-tête Last-Modified, par défaut la date de modification du
-    fichier.
-  </dd>
-  <dt>type</dt>
-  <dd>
-    type de contenu à utiliser, deviné à partir de l’extension de fichier si
-    absent
-  </dd>
-  <dt>disposition</dt>
-  <dd>
-    utilisé pour Content-Disposition, les valeurs possibles étant : <tt>nil</tt>
-    (par défaut), <tt>:attachment</tt> et <tt>:inline</tt>
-  </dd>
-  <dt>length</dt>
-  <dd>en-tête Content-Length, par défaut la taille du fichier</dd>
-  <dt>status</dt>
-  <dd>
-    code état à renvoyer. Utile quand un fichier statique sert de page d’erreur.
-    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.
-  </dd>
-</dl>
-### 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` :
-```ruby
-# application tournant à l'adresse http://exemple.com/exemple
-get '/foo' do
-  t = %w[text/css text/html application/javascript]
-  request.accept              # ['text/html', '*/*']
-  request.accept? 'text/xml'  # vrai
-  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?                # vrai (méthodes similaires pour les autres
-                              # verbes HTTP)
-  request.form_data?          # faux
-  request["UN_ENTETE"]        # valeur de l'en-tête UN_ENTETE
-  request.referrer            # 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?             # faux
-  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 `script_name` ou `path_info`
-peuvent également être modifiées :
-```ruby
-before { request.path_info = "/" }
-get "/" do
-  "toutes les requêtes arrivent ici"
-end
-```
-`request.body` est un objet IO ou StringIO :
-```ruby
-post "/api" do
-  request.body.rewind  # au cas où il a déjà été lu
-  donnees = JSON.parse request.body.read
-  "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 :
-```ruby
-get '/' do
-  attachment
-  "enregistre-le !"
-end
-```
-Vous pouvez également lui passer un nom de fichier :
-```ruby
-get '/' do
-  attachment "info.txt"
-  "enregistre-le !"
-end
-```
-### Gérer Date et Time
-Sinatra fourni un helper `time_for` pour convertir une valeur donnée en
-objet `Time`. Il peut aussi faire la conversion à partir d'objets `DateTime`,
-`Date` ou de classes similaires :
-```ruby
-get '/' do
-  pass if Time.now > time_for('Dec 23, 2012')
-  "encore temps"
-end
-```
-Cette méthode est utilisée en interne par `expires`, `last_modified` et
-consorts. Par conséquent, vous pouvez très facilement étendre le
-fonctionnement de ces méthodes en surchargeant le helper `time_for` dans
-votre application :
-```ruby
-helpers do
-  def time_for(value)
-    case value
-    when :yesterday then Time.now - 24*60*60
-    when :tomorrow  then Time.now + 24*60*60
-    else super
-    end
-  end
-end
-get '/' do
-  last_modified :yesterday
-  expires :tomorrow
-  "salut"
-end
-```
-### Chercher les fichiers de templates
-La méthode `find_template` est utilisée pour trouver les fichiers de
-templates à générer :
-```ruby
-find_template settings.views, 'foo', Tilt[:haml] do |file|
-  puts "pourrait être #{file}"
-end
-```
-Ce n'est pas très utile. 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 :
-```ruby
-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 :
-```ruby
-set :views, :sass => 'views/sass', :haml => 'templates', :default => 'views'
-helpers do
-  def find_template(vues, nom, moteur, &bloc)
-    _, dossier = vues.detect { |k,v| moteur == Tilt[k] }
-    dossier ||= vues[:default]
-    super(dossier, nom, moteur, &bloc)
-  end
-end
-```
-Vous pouvez également écrire cela dans une extension et la partager avec
-d'autres !
-Notez que `find_template` 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
-de problème de performance dans le sens où `render` va utiliser `break` dès
-qu'un fichier sera trouvé. De plus, l'emplacement des templates (et leur
-contenu) est mis en cache si vous n'êtes pas en mode développement. Vous
-devez 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 :
-```ruby
-configure do
-  # définir un paramètre
-  set :option, 'valeur'
-  # définir plusieurs paramètres
-  set :a => 1, :b => 2
-  # équivalent à "set :option, true"
-  enable :option
-  # équivalent à "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 `:production` :
-```ruby
-  configure :production do
-    ...
-  end
-```
-Lancé si l'environnement est `:production` ou `:test` :
-```ruby
-  configure :production, :test do
-    ...
-  end
-```
-Vous pouvez accéder à ces paramètres via `settings` :
-```ruby
-configure do
-  set :foo, 'bar'
-end
-get '/' do
-  settings.foo? # => true
-  settings.foo  # => 'bar'
-  ...
-end
-```
-### Se protéger des attaques
-Sinatra utilise [Rack::Protection](https://github.com/sinatra/rack-protection#readme)
-pour protéger votre application contre les principales attaques opportunistes.
-Vous pouvez très simplement désactiver cette fonctionnalité (ce qui exposera
-votre application à beaucoup de vulnerabilités courantes) :
-```ruby
-disable :protection
-```
-Pour désactiver seulement un type de protection, vous pouvez définir `protection`
-avec un hash d'options :
-```ruby
-set :protection, :except => :path_traversal
-```
-Vous pouvez également lui passer un tableau pour désactiver plusieurs types de
-protection :
-```ruby
-set :protection, :except => [:path_traversal, :session_hijacking]
-```
-Par défaut, il faut que `:sessions` soit activé pour que Sinatra mette en place
-un système de protection au niveau de la session. Dans le cas où vous gérez
-vous même les sessions, vous devez utiliser l'option `:session` pour que cela
-soit le cas :
-```ruby
-use Rack::Session::Pool
-set :protection, :session => true
-```
-### Paramètres disponibles
-<dl>
-  <dt>absolute_redirects</dt>
-  <dd>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.</p>
-  Activez si votre application tourne derrière un proxy inverse qui n’a
-  pas été correctement configuré. Notez que la méthode <tt>url</tt>
-  continuera de produire des URLs absolues, sauf si vous lui passez
-  <tt>false</tt> comme second argument.</p>
-  <p>Désactivé par défaut.</p></dd>
-  <dt>add_charset</dt>
-  <dd><p>types mime pour lesquels la méthode <tt>content_type</tt> va
-  automatiquement ajouter l’information du <tt>charset</tt>.</p>
-  <p>Vous devriez lui ajouter des valeurs plutôt que de l’écraser :</p>
-  <pre>settings.add_charset >> "application/foobar"</pre></dd>
-  <dt>app_file</dt>
-  <dd><p>chemin pour le fichier de l’application principale, utilisé pour
-  détecter la racine du projet, les dossiers public et vues, et les
-  templates en ligne.</p></dd>
-  <dt>bind</dt>
-  <dd>adresse IP sur laquelle se brancher (par défaut : 0.0.0.0). Utiliser
-  seulement pour le serveur intégré.</dd>
-  <dt>default_encoding</dt>
-  <dd>encodage à utiliser si inconnu (par défaut <tt>"utf-8"</tt>)</dd>
-  <dt>dump_errors</dt>
-  <dd>afficher les erreurs dans le <tt>log</tt>.
-  </dd>
-  <dt>environment</dt>
-  <dd>environnement courant, par défaut <tt>ENV['RACK_ENV']</tt>, ou
-  <tt>"development"</tt> si absent.</dd>
-  <dt>logging</dt>
-  <dd>utiliser le <tt>logger</tt>.</dd>
-  <dt>lock</dt>
-  <dd><p>Place un <tt>lock</tt> autour de chaque requête, n’exécutant donc
-  qu’une seule requête par processus Ruby.</p>
-  <p>Activé si votre application n’est pas <tt>thread-safe</tt>. Désactivé
-  par défaut.</p></dd>
-  <dt>method_override</dt>
-  <dd>utilise la magie de <tt>_method</tt> afin de permettre des formulaires
-  put/delete dans des navigateurs qui ne le permettent pas.
-  </dd>
-  <dt>port</dt>
-  <dd>port à écouter. Utiliser seulement pour le serveur intégré.</dd>
-  <dt>prefixed_redirects</dt>
-  <dd>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.</dd>
-  <dt>protection</dt>
-  <dd>défini s’il faut activer ou non la protection contre les attaques web.
-  Voir la section protection précédente.</dd>
-  <dt>public_dir</dt>
-  <dd>alias pour <tt>public_folder</tt>. Voir ci-dessous.</dd>
-  <dt>public_folder</dt>
-  <dd>chemin pour le dossier à partir duquel les fichiers publics sont servis.
-  Utilisé seulement si les fichiers statiques doivent être servis (voir le
-  paramètre <tt>static</tt>). Si non défini, il découle du paramètre
-  <tt>app_file</tt>.</dd>
-  <dt>reload_templates</dt>
-  <dd>si oui ou non les templates doivent être rechargés entre les requêtes.
-  Activé en mode développement.</dd>
-  <dt>root</dt>
-  <dd>chemin pour le dossier racine du projet. Si non défini, il découle du
-  paramètre <tt>app_file</tt>.</dd>
-  <dt>raise_errors</dt>
-  <dd>soulever les erreurs (ce qui arrêtera l’application). Désactivé par
-  défaut sauf lorsque <tt>environment</tt> est défini à
-  <tt>"test"</tt>.</dd>
-  <dt>run</dt>
-  <dd>si activé, Sinatra s’occupera de démarrer le serveur, ne pas activer si
-  vous utiliser rackup ou autres.</dd>
-  <dt>running</dt>
-  <dd>est-ce que le serveur intégré est en marche ? ne changez pas ce
-  paramètre !</dd>
-  <dt>server</dt>
-  <dd>serveur ou liste de serveurs à utiliser pour le serveur intégré. Par
-  défaut [‘thin’, ‘mongrel’, ‘webrick’], l’ordre indiquant la
-  priorité.</dd>
-  <dt>sessions</dt>
-  <dd>active le support des sessions basées sur les cookies, en utilisant
-  <tt>Rack::Session::Cookie</tt>. Reportez-vous à la section ‘Utiliser les
-  sessions’ pour plus d’informations.</dd>
-  <dt>show_exceptions</dt>
-  <dd>affiche la trace de l’erreur dans le navigateur lorsqu’une exception se
-  produit. Désactivé par défaut sauf lorsque <tt>environment</tt> est
-  défini à <tt>"development"</tt>.</dd>
-  <dt>static</dt>
-  <dd>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 pour le style
-  classique, désactivé pour le style modulaire.</dd>
-  <dt>static_cache_control</dt>
-  <dd>A définir quand Sinatra rend des fichiers statiques pour ajouter les
-  en-têtes <tt>Cache-Control</tt>. Utilise le helper <tt>cache_control</tt>.
-  Désactivé par défaut. Utiliser un array explicite pour définir des
-  plusieurs valeurs : <tt>set :static_cache_control, [:public, :max_age =>
-  300]</tt></dd>
-  <dt>threaded</dt>
-  <dd>à définir à <tt>true</tt> pour indiquer à Thin d’utiliser
-  <tt>EventMachine.defer</tt> pour traiter la requête.</dd>
-  <dt>views</dt>
-  <dd>chemin pour le dossier des vues. Si non défini, il découle du paramètre
-  <tt>app_file</tt>.</dd>
-  <dt>x_cascade</dt>
-  <dd>
-    Indique s'il faut ou non définir le header X-Cascade lorsqu'aucune route
-    ne correspond. Défini à <tt>true</tt> par défaut.
-  </dd>
-</dl>
-## Environements
-Il existe trois environnements prédéfinis : `"development"`,
-`"production"` et `"test"`. Les environements peuvent être
-sélectionné via la variable d'environnement `RACK_ENV`. Sa valeur par défaut
-est `"development"`. Dans ce mode, tous les templates sont rechargés à
-chaque requête. Des handlers spécifiques pour `not_found` et
-`error` sont installés pour vous permettre d'avoir une pile de trace
-dans votre navigateur. En mode `"production"` et `"test"` les
-templates sont mis en cache par défaut.
-Pour exécuter votre application dans un environnement différent, définissez la
-variable d'environnement `RACK_ENV` :
-```shell
-RACK_ENV=production ruby my_app.rb
-```
-Vous pouvez utiliser une des méthodes `development?`, `test?` et `production?`
-pour déterminer quel est l'environnement en cours :
-```ruby
-get '/' do
-  if settings.development?
-    "développement !"
-  else
-    "pas en développement !"
-  end
-end
-```
-## 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 `haml`, `erb`, `halt`, etc.
-### NotFound
-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é :
-```ruby
-not_found do
-  'Pas moyen de trouver ce que vous cherchez'
-end
-```
-### Error
-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 `sinatra.error` :
-```ruby
-error do
-  'Désolé mais une méchante erreur est survenue - ' + env['sinatra.error'].message
-end
-```
-Erreur sur mesure :
-```ruby
-error MonErreurSurMesure do
-  'Oups ! Il est arrivé...' + env['sinatra.error'].message
-end
-```
-Donc si cette erreur est soulevée :
-```ruby
-get '/' do
-  raise MonErreurSurMesure, 'quelque chose de mal'
-end
-```
-La réponse sera :
-```
-Oups ! Il est arrivé... quelque chose de mal
-```
-Alternativement, vous pouvez avoir un gestionnaire d'erreur associé à un code
-particulier :
-```ruby
-error 403 do
-  'Accès interdit'
-end
-get '/secret' do
-  403
-end
-```
-Ou un intervalle :
-```ruby
-error 400..510 do
-  'Boom'
-end
-```
-Sinatra installe pour vous quelques gestionnaires `not_found` et
-`error` génériques lorsque vous êtes en environnement de
-`development`.
-## Les Middlewares Rack
-Sinatra fonctionne avec [Rack](http://rack.github.io/), 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" -- composants qui viennent 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 d'utiliser facilement des middlewares Rack via la méthode de
-haut niveau `use` :
-```ruby
-require 'sinatra'
-require 'mon_middleware_perso'
-use Rack::Lint
-use MonMiddlewarePerso
-get '/bonjour' do
-  'Bonjour le monde'
-end
-```
-La sémantique de `use` est identique à celle définie dans le DSL de
-[Rack::Builder](http://www.rubydoc.info/github/rack/rack/master/Rack/Builder)
-(le plus souvent utilisé dans un fichier `rackup`). Par exemple, la méthode
-`use` accepte divers arguments ainsi que des blocs :
-```ruby
-use Rack::Auth::Basic do |identifiant, mot_de_passe|
-  identifiant == 'admin' && mot_de_passe == 'secret'
-end
-```
-Rack est distribué avec de nombreux middlewares standards pour loguer, débuguer,
-faire du routage URL, de l'authentification ou gérer des sessions. Sinatra gère
-plusieurs de ces composants automatiquement via son système de configuration, ce
-qui vous dispense de faire un `use` pour ces derniers.
-Vous trouverez d'autres middlewares intéressants sur
-[rack](https://github.com/rack/rack/tree/master/lib/rack),
-[rack-contrib](https://github.com/rack/rack-contrib#readm),
-ou en consultant le [wiki de Rack](https://github.com/rack/rack/wiki/List-of-Middleware).
-## Tester
-Les tests pour Sinatra peuvent être écrit avec n'importe quelle bibliothèque
-basée sur Rack. [Rack::Test](http://gitrdoc.com/brynary/rack-test) est
-recommandé :
-```ruby
-require 'mon_application_sinatra'
-require 'minitest/autorun'
-require 'rack/test'
-class MonTest < Minitest::Test
-  include Rack::Test::Methods
-  def app
-    Sinatra::Application
-  end
-  def test_ma_racine
-    get '/'
-    assert_equal 'Bonjour le monde !', last_response.body
-  end
-  def test_avec_des_parametres
-    get '/rencontrer', :nom => 'Frank'
-    assert_equal 'Salut Frank !', last_response.body
-  end
-  def test_avec_rack_env
-    get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
-    assert_equal "Vous utilisez Songbird !", last_response.body
-  end
-end
-```
-## Sinatra::Base - Les Middlewares, Bibliothèques, et Applications Modulaires
-Définir votre application au niveau supérieur fonctionne bien dans le cas des
-micro-applications mais présente pas mal d'inconvénients pour créer des
-composants réutilisables sous forme de middlewares Rack, de Rails metal, de
-simples librairies avec un composant serveur ou même d'extensions Sinatra. Le
-niveau supérieur suppose une configuration dans le style des micro-applications
-(une application d'un seul fichier, des répertoires `./public` et
-`./views`, des logs, une page d'erreur, etc...). C'est là que
-`Sinatra::Base` prend tout son intérêt :
-```ruby
-require 'sinatra/base'
-class MonApplication < Sinatra::Base
-  set :sessions, true
-  set :foo, 'bar'
-  get '/' do
-    'Bonjour le monde !'
-  end
-end
-```
-Les méthodes de la classe `Sinatra::Base` sont parfaitement identiques à
-celles disponibles via le DSL de haut niveau. Il suffit de deux modifications
-pour transformer la plupart des applications de haut niveau en un composant
-`Sinatra::Base` :
-* Votre fichier doit charger `sinatra/base` au lieu de `sinatra`, sinon toutes
-  les méthodes du DSL Sinatra seront importées dans l'espace de nom principal.
-* Les gestionnaires de routes, la gestion d'erreur, les filtres et les options
-  doivent être placés dans une classe héritant de `Sinatra::Base`.
-`Sinatra::Base` est une page blanche. La plupart des options sont
-désactivées par défaut, y compris le serveur intégré. Reportez-vous à
-[Options et Configuration](http://www.sinatrarb.com/configuration.html)
-pour plus d'informations sur les options et leur fonctionnement. Si vous
-souhaitez un comportement plus proche de celui obtenu lorsque vous définissez
-votre application au niveau supérieur (aussi connu sous le nom de style
-Classique), vous pouvez créer une classe héritant de `Sinatra::Application`.
-```ruby
-require 'sinatra/base'
-class MyApp < Sinatra::Application
-  get '/' do
-    'Bonjour le monde !'
-  end
-end
-```
-### Style modulaire vs. style classique
-Contrairement aux idées reçues, il n'y a rien de mal à utiliser le style
-classique. Si c'est ce qui convient pour votre application, vous n'avez
-aucune raison de passer à une application modulaire.
-Le principal inconvénient du style classique sur le style modulaire est que vous
-ne pouvez avoir qu'une application par processus Ruby. Si vous pensez en
-utiliser plus, passez au style modulaire. Et rien ne vous empêche de mixer style
-classique et style modulaire.
-Si vous passez d'un style à l'autre, souvenez-vous des quelques différences
-mineures en ce qui concerne les paramètres par défaut :
-<table>
-  <tr>
-    <th>Paramètre</th>
-    <th>Classique</th>
-    <th>Modulaire</th>
-    <th>Modulaire</th>
-  </tr>
-  <tr>
-    <td>app_file</td>
-    <td>fichier chargeant sinatra</td>
-    <td>fichier héritant de Sinatra::Base</td>
-    <td>fichier héritant de Sinatra::Application</td>
-  </tr>
-  <tr>
-    <td>run</td>
-    <td>$0 == app_file</td>
-    <td>false</td>
-    <td>false</td>
-  </tr>
-  <tr>
-    <td>logging</td>
-    <td>true</td>
-    <td>false</td>
-    <td>true</td>
-  </tr>
-  <tr>
-    <td>method_override</td>
-    <td>true</td>
-    <td>false</td>
-    <td>true</td>
-  </tr>
-  <tr>
-    <td>inline_templates</td>
-    <td>true</td>
-    <td>false</td>
-    <td>true</td>
-  </tr>
-  <tr>
-    <td>static</td>
-    <td>true</td>
-    <td>File.exist?(public_folder)</td>
-    <td>true</td>
-  </tr>
-</table>
-### Servir une application modulaire
-Il y a deux façons de faire pour démarrer une application modulaire, démarrez
-avec `run!` :
-```ruby
-# 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 :
-```shell
-ruby my_app.rb
-```
-Ou alors avec un fichier `config.ru`, qui permet d'utiliser n'importe
-quel gestionnaire Rack :
-```ruby
-# config.ru
-require './my_app'
-run MyApp
-```
-Exécutez :
-```shell
-rackup -p 4567
-```
-### Utiliser une application de style classique avec un fichier config.ru
-Ecrivez votre application :
-```ruby
-# app.rb
-require 'sinatra'
-get '/' do
-  'Bonjour le monde !'
-end
-```
-Et un fichier `config.ru` correspondant :
-```ruby
-require './app'
-run Sinatra::Application
-```
-### Quand utiliser un fichier config.ru ?
-Quelques cas où vous devriez utiliser un fichier `config.ru` :
-* Vous souhaitez déployer avec un autre gestionnaire Rack (Passenger, Unicorn,
-  Heroku, ...).
-* Vous souhaitez utiliser plus d'une sous-classe de `Sinatra::Base`.
-* Vous voulez utiliser Sinatra comme un middleware, non en tant que
-  endpoint.
-**Il n'est pas nécessaire de passer par un fichier `config.ru` 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 `config.ru`.**
-### 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. Cet endpoint peut très bien être une autre
-application Sinatra, ou n'importe quelle application basée sur Rack
-(Rails/Ramaze/Camping/...) :
-```ruby
-require 'sinatra/base'
-class EcranDeConnexion < Sinatra::Base
-  enable :sessions
-  get('/connexion') { haml :connexion }
-  post('/connexion') do
-    if params['nom'] = 'admin' && params['motdepasse'] = 'admin'
-      session['nom_utilisateur'] = params['nom']
-    else
-      redirect '/connexion'
-    end
-  end
-end
-class MonApp < Sinatra::Base
-  # le middleware sera appelé avant les filtres
-  use EcranDeConnexion
-  before do
-    unless session['nom_utilisateur']
-      halt "Accès refusé, merci de vous <a href='/connexion'>connecter</a>."
-    end
-  end
-  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` :
-```ruby
-require 'sinatra/base'
-mon_app = Sinatra.new { get('/') { "salut" } }
-mon_app.run!
-```
-L'application dont elle hérite peut être passé en argument optionnel :
-```ruby
-# config.ru
-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 pour Sinatra ou bien pour
-utiliser Sinatra dans votre propre bibliothèque.
-Cela permet également d'utiliser très facilement Sinatra comme middleware :
-```ruby
-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
-disponibles.
-### Contexte de l'application/classe
-Une application Sinatra correspond à une sous-classe de `Sinatra::Base`. Il
-s'agit de `Sinatra::Application` si vous utilisez le DSL de haut niveau
-(`require 'sinatra'`). Sinon c'est la sous-classe que vous avez définie. Dans
-le contexte de cette classe, vous avez accès aux méthodes telles que `get` ou
-`before`, mais pas aux objets `request` ou `session` étant donné que toutes
-les requêtes sont traitées par une seule classe d'application.
-Les options définies au moyen de `set` deviennent des méthodes de classe :
-```ruby
-class MonApp < Sinatra::Base
-  # Eh, je suis dans le contexte de l'application !
-  set :foo, 42
-  foo # => 42
-  get '/foo' do
-    # Eh, je ne suis plus dans le contexte de l'application !
-  end
-end
-```
-Vous avez le binding du contexte de l'application dans :
-* Le corps de la classe d'application
-* Les méthodes définies par les extensions
-* Le bloc passé à `helpers`
-* Les procs/blocs utilisés comme argument pour `set`
-* Le bloc passé à `Sinatra.new`
-Vous pouvez atteindre ce contexte (donc la classe) de la façon suivante :
-* Via l'objet passé dans les blocs `configure` (`configure { |c| ... }`)
-* En utilisant `settings` dans le contexte de la requête
-### Contexte de la requête/instance
-Pour chaque requête traitée, une nouvelle instance de votre classe
-d'application est créée et tous vos gestionnaires sont exécutés dans ce
-contexte. Depuis celui-ci, vous pouvez accéder aux objets `request` et
-`session` ou 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` :
-```ruby
-class MonApp < Sinatra::Base
-  # Eh, je suis dans le contexte de l'application !
-  get '/ajouter_route/:nom' do
-    # Contexte de la requête pour '/ajouter_route/:nom'
-    @value = 42
-    settings.get("/#{params['nom']}") do
-      # Contexte de la requête pour "/#{params['nom']}"
-      @value # => nil (on est pas au sein de la même requête)
-    end
-    "Route ajoutée !"
-  end
-end
-```
-Vous avez le binding du contexte de la requête dans :
-* les blocs get, head, post, put, delete, options, patch, link et unlink
-* les filtres before et after
-* les méthodes utilitaires (définies au moyen de `helpers`)
-* les vues et templates
-### 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 de variables/états avec le contexte de classe
-(comprenez : `self` n'est pas le même). Vous pouvez ajouter des délégations de
-méthode en appelant `Sinatra::Delegator.delegate :method_name`.
-Vous avez le binding du contexte de délégation dans :
-* Le binding de haut niveau, si vous avez utilisé `require "sinatra"`
-* Un objet qui inclut le module `Sinatra::Delegator`
-Pour vous faire une idée, vous pouvez jeter un coup d'oeil au
-[mixin Sinatra::Delegator](https://github.com/sinatra/sinatra/blob/ca06364/lib/sinatra/base.rb#L1609-1633)
-qui [étend l'objet principal](https://github.com/sinatra/sinatra/blob/ca06364/lib/sinatra/main.rb#L28-30).
-## Ligne de commande
-Les applications Sinatra peuvent être lancées directement :
-```shell
-ruby mon_application.rb [-h] [-x] [-e ENVIRONNEMENT] [-p PORT] [-o HOTE] [-s SERVEUR]
-```
-Avec les options :
-```
--h # aide
--p # déclare le port (4567 par défaut)
--o # déclare l'hôte (0.0.0.0 par défaut)
--e # déclare l'environnement (development par défaut)
--s # déclare le serveur/gestionnaire à utiliser (thin par défaut)
--x # active le mutex lock (off par défaut)
-```
-### Multi-threading
-_Cette partie est basée sur [une réponse StackOverflow][so-answer] de Konstantin._
-Sinatra n'impose pas de modèle de concurrence. Sinatra est thread-safe, vous pouvez
-donc utiliser n'importe quel gestionnaire Rack, comme Thin, Puma ou WEBrick en mode
-multi-threaded.
-Cela signifie néanmoins qu'il vous faudra spécifier les paramètres correspondant au
-gestionnaire Rack utilisé lors du démarrage du serveur.
-L'exemple ci-dessous montre comment vous pouvez exécuter un serveur Thin de manière
-multi-threaded:
-```
-# app.rb
-require 'sinatra/base'
-classe App < Sinatra::Base
-  get '/' do
-    'Bonjour le monde !'
-  end
-end
-App.run!
-```
-Pour démarrer le serveur, exécuter la commande suivante:
-```
-thin --threaded start
-```
-[so-answer]: http://stackoverflow.com/questions/6278817/is-sinatra-multi-threaded/6282999#6282999)
-## Configuration nécessaire
-Les versions suivantes de Ruby sont officiellement supportées :
-<dl>
-  <dt>Ruby 1.8.7</dt>
-  <dd>
-    1.8.7 est complètement supporté, toutefois si rien ne vous en empêche,
-    nous vous recommandons de faire une mise à jour ou bien de passer à JRuby
-    ou Rubinius. Le support de Ruby 1.8.7 ne sera pas supprimé avant la sortie
-    de Sinatra 2.0. Ruby 1.8.6 n’est plus supporté.
-  </dd>
-  <dt>Ruby 1.9.2</dt>
-  <dd>
-    1.9.2 est totalement supporté. N’utilisez pas 1.9.2p0 car il provoque des
-    erreurs de segmentation à l’exécution de Sinatra. Son support continuera
-    au minimum jusqu’à la sortie de Sinatra 1.5.
-  </dd>
-  <dt>Ruby 1.9.3</dt>
-  <dd>
-    1.9.3 est totalement supporté et recommandé. Nous vous rappelons que passer
-    à 1.9.3 depuis une version précédente annulera toutes les sessions. 1.9.3
-    sera supporté jusqu'à la sortie de Sinatra 2.0.
-  </dd>
-  <dt>Ruby 2.0.0</dt>
-  <dd>
-    2.0.0 est totalement supporté et recommandé. L'abandon de son support
-    officiel n'est pas à l'ordre du jour.
-  </dd>
-  <dt>Rubinius</dt>
-  <dd>
-    Rubinius est officiellement supporté (Rubinius >= 2.x). Un <tt>gem install
-    puma</tt> est recommandé.
-  </dd>
-  <dt>JRuby</dt>
-  <dd>
-    La dernière version stable de JRuby est officiellement supportée. Il est
-    déconseillé d'utiliser des extensions C avec JRuby. Un <tt>gem install
-    trinidad</tt> est recommandé.
-  </dd>
-</dl>
-Nous gardons également un oeil sur les versions Ruby à venir.
-Les implémentations Ruby suivantes ne sont pas officiellement supportées mais
-sont malgré tout connues pour permettre de faire fonctionner Sinatra :
-* Versions plus anciennes de JRuby et Rubinius
-* Ruby Enterprise Edition
-* MacRuby, Maglev, IronRuby
-* Ruby 1.9.0 et 1.9.1 (mais nous déconseillons leur utilisation)
-Le fait de ne pas être officiellement supporté signifie que si quelque chose
-ne fonctionne pas sur cette plateforme uniquement alors c'est un problème de la
-plateforme et pas un bug de Sinatra.
-Nous lançons également notre intégration continue (CI) avec ruby-head (la
-future 2.1.0), mais nous ne pouvont rien garantir étant donné les évolutions
-continuelles. La version 2.1.0 devrait être totalement supportée.
-Sinatra devrait fonctionner sur n'importe quel système d'exploitation
-supporté par l'implémentation Ruby choisie.
-Si vous utilisez MacRuby, vous devriez `gem install control_tower`.
-Il n'est pas possible d'utiliser Sinatra sur Cardinal, SmallRuby, BlueRuby ou
-toute version de Ruby antérieure à 1.8.7 à l'heure actuelle.
-## Essuyer les plâtres
-Si vous souhaitez tester la toute dernière version de Sinatra, n'hésitez pas
-à faire tourner votre application sur la branche master, celle-ci devrait être
-stable.
-Pour cela, la méthode la plus simple est d'installer une gem de prerelease que
-nous publions de temps en temps :
-```shell
-gem install sinatra --pre
-```
-Ce qui permet de bénéficier des toutes dernières fonctionnalités.
-### Installer avec Bundler
-Il est cependant conseillé de passer par [Bundler](http://bundler.io) pour
-faire tourner votre application avec la dernière version de Sinatra.
-Pour commencer, installez bundler si nécessaire :
-```shell
-gem install bundler
-```
-Ensuite, créez un fichier `Gemfile` dans le dossier de votre projet :
-```ruby
-source 'https://rubygems.org'
-gem 'sinatra', :github => "sinatra/sinatra"
-# autres dépendances
-gem 'haml'                    # si par exemple vous utilisez haml
-gem 'activerecord', '~> 3.0'  # au cas où vous auriez besoin de ActiveRecord 3.x
-```
-Notez que vous devez lister toutes les dépendances de votre application dans
-ce fichier `Gemfile`. Les dépendances directes de Sinatra (Rack et Tilt) seront
-automatiquement téléchargées et ajoutées par Bundler.
-Vous pouvez alors lancer votre application de la façon suivante :
-```shell
-bundle exec ruby myapp.rb
-```
-### Faire un clone local
-Si vous ne souhaitez pas employer Bundler, vous pouvez cloner Sinatra en local
-dans votre projet et démarrez votre application avec le dossier `sinatra/lib`
-dans le `$LOAD_PATH` :
-```shell
-cd myapp
-git clone git://github.com/sinatra/sinatra.git
-ruby -I sinatra/lib myapp.rb
-```
-Et de temps en temps, vous devrez récupérer la dernière version du code source
-de Sinatra :
-```shell
-cd myapp/sinatra
-git pull
-```
-### Installer globalement
-Une dernière méthode consiste à construire la gem vous-même :
-```shell
-git clone git://github.com/sinatra/sinatra.git
-cd sinatra
-rake sinatra.gemspec
-rake install
-```
-Si vous installez les gems en tant que root, vous devez encore faire un :
-```shell
-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 ?
-* [Suivi des problèmes](https://github.com/sinatra/sinatra/issues)
-* [Twitter](https://twitter.com/sinatra)
-* [Mailing List](http://groups.google.com/group/sinatrarb/topics)
-* IRC : [#sinatra](irc://chat.freenode.net/#sinatra) sur http://freenode.net
-* [Sinatra Book](https://github.com/sinatra/sinatra-book/) Tutoriels et recettes
-* [Sinatra Recipes](http://recipes.sinatrarb.com/) trucs et astuces rédigés par
-  la communauté
-* Documentation API de la [dernière version](http://www.rubydoc.info/gems/sinatra)
-  ou du [HEAD courant](http://www.rubydoc.info/github/sinatra/sinatra) sur
-  http://www.rubydoc.info/
-* [CI server](https://travis-ci.org/sinatra/sinatra)