Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Merge pull request #1016 from mig-hub/french-readme

French readme
commit f9446dfc0234f2bcc9f046599ce2a977a049eaa2 2 parents c1ed18e + b10e266
@kytrinyx kytrinyx authored
Showing with 157 additions and 168 deletions.
  1. +157 −168 README.fr.md
View
325 README.fr.md
@@ -1,6 +1,6 @@
# Sinatra
*Attention : Ce document correspond à la traduction de la version anglaise et
-il n'est peut être plus à jour.*
+il n'est peut-être plus à jour.*
Sinatra est un [DSL](http://fr.wikipedia.org/wiki/Langage_dédié) pour
créer rapidement et facilement des applications web en Ruby :
@@ -75,7 +75,7 @@ Sinatra utilise le server Thin quand il est disponible.
* [Halt](#halt)
* [Passer](#passer)
* [Déclencher une autre route](#déclencher-une-autre-route)
- * [Définir le corps, le code retour et les entêtes](#définir-le-corps-le-code-retour-et-les-entêtes)
+ * [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)
@@ -182,7 +182,7 @@ get '/bonjour/:nom' do |n|
end
```
-Une route peut contenir un splat (caractère joker), accessible par
+Une route peut contenir un `splat` (caractère joker), accessible par
l'intermédiaire du tableau `params['splat']` :
``` ruby
@@ -217,6 +217,7 @@ 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
```
@@ -224,19 +225,19 @@ end
Les routes peuvent aussi comporter des paramètres optionnels :
``` ruby
-get '/posts.?:format?' do
- # répond à "GET /posts" et aussi à "GET /posts.json", "GET /posts.xml" etc...
+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 '/posts' do
- # répond à "GET /posts?titre=foo&auteur=bar"
+get '/articles' do
+ # répond à "GET /articles?titre=foo&auteur=bar"
titre = params['titre']
auteur = params['auteur']
- # utilise les variables titre et auteur, ces paramètres d'URL sont optionnels pour la route /posts
+ # utilise les variables titre et auteur qui sont des paramètres d'URL optionnels pour la route /articles
end
```
@@ -274,13 +275,14 @@ 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(:probability) { |value| condition { rand <= value } }
+set(:chance) { |valeur| condition { rand <= valeur } }
-get '/gagner_une_voiture', :probability => 0.1 do
+get '/gagner_une_voiture', :chance => 0.1 do
"Vous avez gagné !"
end
@@ -289,7 +291,7 @@ get '/gagner_une_voiture' do
end
```
-Utilisez un splat (caractère joker) dans le cas d'une condition qui prend
+Utilisez un `splat` (caractère joker) dans le cas d'une condition qui prend
plusieurs valeurs :
``` ruby
@@ -313,7 +315,7 @@ 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
+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.
@@ -321,7 +323,7 @@ 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), entêtes (Hash), corps
+* 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)]`
@@ -329,7 +331,7 @@ valide, d'un corps de réponse Rack ou d'un code statut HTTP :
caractères au bloc fourni
* Un Fixnum représentant le code statut
-Avec cela, on peut facilement implémenter un streaming par exemple :
+Ainsi, on peut facilement implémenter un exemple de streaming :
``` ruby
class Stream
@@ -342,7 +344,7 @@ get('/') { Stream.new }
```
Vous pouvez aussi utiliser le helper `stream` (présenté un peu plus loin) pour
-éviter la surcharge et intégrer le traitement relatif au streaming dans le bloc
+é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
@@ -375,8 +377,7 @@ get tout_sauf("/index") do
end
```
-Notez que l'exemple ci-dessus est bien trop compliqué et que le même résultat
-peut être obtenu avec :
+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
@@ -385,7 +386,7 @@ get // do
end
```
-Ou bien en utilisant la forme négative :
+Ou bien en utilisant cette expression regulière :
``` ruby
get %r{^(?!/index$)} do
@@ -395,24 +396,22 @@ end
## Fichiers statiques
-Les fichiers du dossier `./public` sont servis de façon statique. Vous
-avez la possibilité d'utiliser un autre répertoire en définissant le paramètre
-`:public_folder` :
+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 appelé via l'URL :
+`./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 <tt>Cache-Control</tt> (voir plus loin).
+d'en-tête `Cache-Control` (voir plus bas).
## Vues / Templates
-Chaqie langage de template est disponible via sa propre méthode de rendu,
+Chaque langage de template est disponible via sa propre méthode de rendu,
lesquelles renvoient tout simplement une chaîne de caractères.
``` ruby
@@ -421,7 +420,7 @@ get '/' do
end
```
-Ceci effectue le rendu de la vue `views/index.erb`.
+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 :
@@ -433,7 +432,7 @@ get '/' do
end
```
-Les méthodes de templates acceptent un second paramètre, un hash d'options :
+Les méthodes de templates acceptent un hash d'options comme second argument :
``` ruby
get '/' do
@@ -441,9 +440,7 @@ get '/' do
end
```
-Ceci effectuera le rendu de la vue `views/index.erb` en l'intégrant
-au *layout* `views/post.erb` (les vues Erb sont intégrées par défaut
-au *layout* `views/layout.erb` quand ce fichier existe).
+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 :
@@ -453,7 +450,7 @@ get '/' do
end
```
-Vous pouvez également définir des options par langage de template de façon
+Vous pouvez également définir les options de chaque langage de template de façon
générale :
``` ruby
@@ -464,8 +461,7 @@ get '/' do
end
```
-Les options passées à la méthode de rendu prennent le pas sur les options
-définies au moyen de `set`.
+Les arguments passés à la méthode de rendu prennent le pas sur les options définies au moyen de `set`.
Options disponibles :
@@ -479,7 +475,7 @@ Options disponibles :
<dt>default_encoding</dt>
<dd>
- Encodage de caractères à utiliser en cas d'incertitude. Par défaut, c'est
+ Encodage de caractères à utiliser en cas d'incertitude. Par défaut
<tt>settings.default_encoding</tt>.
</dd>
@@ -492,19 +488,18 @@ Options disponibles :
<dt>layout</dt>
<dd>
S'il faut ou non utiliser un layout (<tt>true</tt> ou <tt>false</tt>).
- Indique le template à utiliser lorsque c'est un symbole. Exemple :
+ 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 produit, dépend par défaut du langage de
- template.
+ 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 sous lequel effectuer le rendu du template. Par défaut il s'agit
+ 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>
@@ -518,7 +513,7 @@ Options disponibles :
<dt>layout_options</dt>
<dd>
- Options spécifiques destinées au moteur de rendu. Exemple : <tt>set :rdoc,
+ Options spécifiques à la génération du layout. Exemple : <tt>set :rdoc,
:layout_options => { :views => 'views/layouts' }</tt>
</dd>
</dl>
@@ -544,7 +539,7 @@ get '/' do
end
```
-Générera le code du template spécifié dans la chaîne de caractères.
+Utilisera la chaine de caractères comme template pour générer la réponse.
### Langages de template disponibles
@@ -737,22 +732,21 @@ locales.
</table>
Il n’est pas possible d’appeler des méthodes depuis markdown, ni de
-lui passer des variables locales. Par conséquent, il sera souvent utilisé
+lui passer de variables locales. Par conséquent, il sera souvent utilisé
en combinaison avec un autre moteur de rendu :
``` ruby
-erb :overview, :locals => { :text => markdown(:introduction) }
+erb :accueil, :locals => { :text => markdown(:introduction) }
```
-Notez que vous pouvez également appeler la méthode `markdown` au
-sein d’autres templates :
+Notez que vous pouvez également appeler la méthode `markdown` depuis un autre template :
``` ruby
-%h1 Hello From Haml !
-%p= markdown(:greetings)
+%h1 Bonjour depuis Haml !
+%p= markdown(:bienvenue)
```
-Comme vous ne pouvez pas appeler de Ruby au sein de Markdown, vous ne
+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`.
@@ -774,23 +768,22 @@ pour le layout en utilisant l’option `:layout_engine`.
</tr>
</table>
-Il n’est pas possible d’appeler des méthodes depuis textile, ni de lui
-passer des variables locales. Par conséquent, il sera souvent utilisé en
+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 :overview, :locals => { :text => textile(:introduction) }
+erb :accueil, :locals => { :text => textile(:introduction) }
```
-Notez que vous pouvez également appeler la méthode `textile` au
-sein d’autres templates :
+Notez que vous pouvez également appeler la méthode `textile` depuis un autre template :
``` ruby
-%h1 Hello From Haml !
-%p= textile(:greetings)
+%h1 Bonjour depuis Haml !
+%p= textile(:bienvenue)
```
-Comme vous ne pouvez pas appeler de Ruby au sein de Textile, vous ne pouvez
+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`.
@@ -812,23 +805,22 @@ pour le layout en utilisant l’option `:layout_engine`.
</tr>
</table>
-Il n’est pas possible d’appeler des méthodes depuis rdoc, ni de lui
-passer des variables locales. Par conséquent, il sera souvent utilisé en
+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 :overview, :locals => { :text => rdoc(:introduction) }
+erb :accueil, :locals => { :text => rdoc(:introduction) }
```
-Notez que vous pouvez également appeler la méthode `rdoc` au sein
-d’autres templates :
+Notez que vous pouvez également appeler la méthode `rdoc` depuis un autre template :
``` ruby
-%h1 Hello From Haml !
-%p= rdoc(:greetings)
+%h1 Bonjour depuis Haml !
+%p= rdoc(:bienvenue)
```
-Comme vous ne pouvez pas appeler de Ruby au sein de RDoc, vous ne pouvez
+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`.
@@ -923,23 +915,22 @@ exemple).
</tr>
</table>
-Il n'est pas possible d'appeler des méthodes depuis creole, ni de lui
-passer des variables locales. Par conséquent, il sera souvent utilisé en
+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 :overview, :locals => { :text => markdown(:introduction) }
+erb :accueil, :locals => { :text => markdown(:introduction) }
```
-Notez que vous pouvez également appeler la méthode `creole` au sein d'autres
-templates :
+Notez que vous pouvez également appeler la méthode `creole` depuis un autre template :
``` ruby
-%h1 Hello From Haml !
-%p= creole(:greetings)
+%h1 Bonjour depuis Haml !
+%p= creole(:bienvenue)
```
-Comme vous ne pouvez pas appeler de Ruby au sein de Creole, vous ne pouvez
+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`.
@@ -1022,12 +1013,12 @@ end
</tr>
<tr>
<td>Exemple</td>
- <td><tt>yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource'</tt></p>
+ <td><tt>yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'ressource'</tt></p>
</td>
</tr>
</table>
-Le source du template est évalué en tant que chaine Ruby, puis la
+La source du template est évaluée en tant que chaine Ruby, puis la
variable json obtenue est convertie avec #to_json.
``` ruby
@@ -1039,7 +1030,7 @@ Les options `:callback` et `:variable` peuvent être utilisées pour décorer
l’objet retourné.
``` ruby
-var resource = {"foo":"bar","baz":"qux"}; present(resource);</pre>
+var ressource = {"foo":"bar","baz":"qux"}; present(ressource);</pre>
```
#### Templates WLang
@@ -1060,7 +1051,7 @@ var resource = {"foo":"bar","baz":"qux"}; present(resource);</pre>
</table>
L’appel de code ruby au sein des templates n’est pas idiomatique en wlang.
-L’écriture de templates sans logique est encouragé, via le passage de variables
+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`.
@@ -1086,10 +1077,7 @@ get '/:id' do
end
```
-Ceci est généralement utilisé lorsque l'on veut utiliser un template comme
-partiel (depuis un autre template) et qu'il est donc nécessaire d'adapter les
-noms de variables.
-
+Ceci est généralement 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
@@ -1103,24 +1091,24 @@ erb :post, :layout => false do
end
```
-Ce code est à globalement équivalent à `erb :index, :layout => :post`.
+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 :main_layout, :layout => false do
- erb :admin_layout do
- erb :user
+erb :layout_principal, :layout => false do
+ erb :layout_admin do
+ erb :utilisateur
end
end
```
-Ce qui peut aussi être fait avec un peu moins de code :
+Ou plus brièvement :
``` ruby
-erb :admin_layout, :layout => :main_layout do
- erb :user
+erb :layout_admin, :layout => :layout_principal do
+ erb :utilisateur
end
```
@@ -1201,7 +1189,7 @@ En premier lieu, déclarez votre moteur de rendu avec Tilt, ensuite créez
votre méthode de rendu :
``` ruby
-Tilt.register :monmoteur, MonMerveilleurMoteurDeRendu
+Tilt.register :monmoteur, MonMerveilleuxMoteurDeRendu
helpers do
def monmoteur(*args) render(:monmoteur, *args) end
@@ -1212,11 +1200,11 @@ get '/' do
end
```
-Utilisera `./views/index.monmoteur`. Voir [le dépôt Github](https://github.com/rtomayko/tilt) pour en savoir plus sur Tilt.
+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
+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 :
@@ -1233,10 +1221,10 @@ get '/foo/*' do
end
```
-Les filtres after sont exécutés après chaque requête à l'intérieur du même
+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 :
+d'instance déclarées dans les filtres `before` ou les routes sont accessibles
+au niveau des filtres `after` :
``` ruby
after do
@@ -1244,7 +1232,7 @@ after do
end
```
-Note : Le corps de la réponse n'est pas disponible au niveau du filtre after
+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).
@@ -1275,7 +1263,7 @@ end
## Helpers
-Utilisez la méthode de haut niveau `helpers` pour définir des routines
+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
@@ -1309,7 +1297,7 @@ l'application.
### Utiliser les sessions
-Une session est utilisée pour conserver un état entre les requêtes. Une fois
+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
@@ -1319,7 +1307,7 @@ get '/' do
"valeur = " << session['valeur'].inspect
end
-get '/:value' do
+get '/:valeur' do
session['valeur'] = params['valeur']
end
```
@@ -1338,7 +1326,7 @@ get '/' do
"valeur = " << session['valeur'].inspect
end
-get '/:value' do
+get '/:valeur' do
session['valeur'] = params['valeur']
end
```
@@ -1360,8 +1348,8 @@ hash avec des options lors de la configuration de `sessions` :
set :sessions, :domain => 'foo.com'
```
-Pour que les différents sous-domaines de foo.com puisse partager une session,
-vous devez préfixer le domaine par *.* :
+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'
@@ -1395,7 +1383,7 @@ Ou les deux ...
halt 401, 'Partez !'
```
-Ainsi que les entêtes ...
+Ainsi que les en-têtes ...
``` ruby
halt 402, {'Content-Type' => 'text/plain'}, 'revanche'
@@ -1448,14 +1436,14 @@ 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 souhiatez que la requête soit envoyée à la même instance de
+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 entêtes
+### 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.
@@ -1479,7 +1467,7 @@ gestionnaire Rack (ceci peut être utilisé pour implémenter un streaming,
voir "Valeurs de retour").
Pareillement au corps de la réponse, vous pouvez également définir le code
-retour et les entêtes :
+retour et les en-têtes :
``` ruby
get '/foo' do
@@ -1491,7 +1479,7 @@ get '/foo' do
end
```
-Comme `body` `headers` et `status` peuvent être utilisés sans arguments
+Comme pour `body`, `headers` et `status` peuvent être utilisés sans arguments
pour accéder à leurs valeurs.
### Faire du streaming
@@ -1499,7 +1487,7 @@ pour accéder à leurs valeurs.
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 connection. Vous pouvez alors utiliser le helper `stream`
+n'abandonne pas la connexion. Vous pouvez alors utiliser le helper `stream`
pour éviter de créer votre propre système :
``` ruby
@@ -1518,16 +1506,16 @@ Cela permet d'implémenter des API de streaming ou de
[Server Sent Events](http://dev.w3.org/html5/eventsource/) et peut servir de
base pour des [WebSockets](http://en.wikipedia.org/wiki/WebSocket). Vous
pouvez aussi l'employer pour augmenter le débit quand une partie du contenu
-provient d'une resource lente.
+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 que
-l'exécution du bloc passé au helper `stream` sera terminée. Le streaming ne
+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
+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
@@ -1642,7 +1630,7 @@ get '/foo' do
end
```
-Tout paramètre additionnel est géré comme des arguments pour la méthode
+Tout paramètre additionnel sera utilisé comme argument pour la méthode
`halt` :
``` ruby
@@ -1687,9 +1675,9 @@ end
### Contrôle du cache
-Définir correctement vos entêtes à la base pour un bon cache HTTP.
+Définissez correctement vos en-têtes à la base pour un bon cache HTTP.
-Vous pouvez facilement définir l'entête Cache-Control de la manière suivante :
+Vous pouvez facilement définir l'en-tête Cache-Control de la manière suivante :
``` ruby
get '/' do
@@ -1706,7 +1694,7 @@ before do
end
```
-Si vous utilisez la méthode `expires` pour définir l'entête correspondant,
+Si vous utilisez la méthode `expires` pour définir l'en-tête correspondant,
`Cache-Control` sera alors défini automatiquement :
``` ruby
@@ -1715,7 +1703,7 @@ before do
end
```
-Pour utiliser correctement les caches, vous devriez utiliser `etag` ou
+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 :
@@ -1737,8 +1725,8 @@ etag @article.sha1, :weak
```
Ces méthodes ne sont pas chargées de mettre des données en cache, mais elles
-fournissent les informations nécessaires pour votre cache. Si vous êtes à la
-recherche de solutions rapides pour un reverse-proxy de cache, essayez
+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
@@ -1759,21 +1747,21 @@ 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 resource demandée existe déjà ou pas. Sinatra considère que les
-requêtes portant sur des resources sûres (tel que get) ou idempotentes (tel que
-put) existent déjà et pour les autres resources (par exemple dans le cas
-de requêtes post) qu'il s'agit de nouvelles resources. Vous pouvez modifier ce
+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 :new_article
+ erb :nouvel_article
end
```
-Si vous souhaitez utilisez un ETag faible, utilisez l'option <tt>:kind</tt> :
+Si vous souhaitez avoir un ETag faible, utilisez l'option `:kind` :
``` ruby
etag '', :new_resource => true, :kind => :weak
@@ -1805,8 +1793,8 @@ Les options sont :
<dt>last_modified</dt>
<dd>
- valeur pour l’entête Last-Modified, par défaut la date de modification du
- fichier
+ valeur pour l’en-tête Last-Modified, par défaut la date de modification du
+ fichier.
</dd>
<dt>type</dt>
@@ -1817,23 +1805,23 @@ Les options sont :
<dt>disposition</dt>
<dd>
- utilisé pour Content-Disposition, les valuers possibles étant : <tt>nil</tt>
+ 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>entête Content-Length, par défaut la taille du fichier</dd>
+ <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>
-Si le gestionnaire Rack le supporte, d'autres moyens que le streaming via le
-processus Ruby seront utilisés. Si vous utilisez cette méthode, Sinatra gérera
-automatiquement les requêtes de type range.
-
### Accéder à l'objet requête
L'objet correspondant à la requête envoyée peut être récupéré dans le contexte
@@ -1845,7 +1833,7 @@ de la requête (filtres, routes, gestionnaires d'erreur) au moyen de la méthode
get '/foo' do
t = %w[text/css text/html application/javascript]
request.accept # ['text/html', '*/*']
- request.accept? 'text/xml' # true
+ 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)
@@ -1858,10 +1846,10 @@ get '/foo' do
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
+ request.get? # vrai (méthodes similaires pour les autres
# verbes HTTP)
- request.form_data? # false
- request["UN_ENTETE"] # valeur de l'entête UN_ENTETE
+ 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
@@ -1869,7 +1857,7 @@ get '/foo' do
request.url # "http://exemple.com/exemple/foo"
request.path # "/exemple/foo"
request.ip # adresse IP du client
- request.secure? # false
+ 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
@@ -1965,7 +1953,7 @@ find_template settings.views, 'foo', Tilt[:haml] do |file|
end
```
-Ce n'est pas très utilise. En revanche, il est utile de pouvoir surcharger
+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 :
@@ -1986,10 +1974,10 @@ de rendu différents :
set :views, :sass => 'views/sass', :haml => 'templates', :default => 'views'
helpers do
- def find_template(views, name, engine, &block)
- _, folder = views.detect { |k,v| engine == Tilt[k] }
- folder ||= views[:default]
- super(folder, name, engine, &block)
+ 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
```
@@ -1999,10 +1987,10 @@ 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
-un problème de performance dans le sens où `render` va utiliser `break` dès
-qu'un fichier est trouvé. De plus, l'emplacement des templates (et leur
+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
-devriez garder cela en tête si vous écrivez une méthode vraiment dingue.
+devez garder cela en tête si vous écrivez une méthode vraiment dingue.
## Configuration
@@ -2011,15 +1999,15 @@ Lancé une seule fois au démarrage de tous les environnements :
``` ruby
configure do
# définir un paramètre
- set :option, 'value'
+ set :option, 'valeur'
- # définir plusieurs paramètre
+ # définir plusieurs paramètres
set :a => 1, :b => 2
- # identique à "set :option, true"
+ # équivalent à "set :option, true"
enable :option
- # identique à "set :option, false""
+ # équivalent à "set :option, false""
disable :option
# vous pouvez également avoir des paramètres dynamiques avec des blocs
@@ -2027,8 +2015,7 @@ configure do
end
```
-Lancé si l'environnement (variable d'environnement RACK_ENV) est défini comme
-`:production` :
+Lancé si l'environnement (variable d'environnement RACK_ENV) est `:production` :
``` ruby
configure :production do
@@ -2301,11 +2288,11 @@ Erreur sur mesure :
``` ruby
error MonErreurSurMesure do
- 'Donc il est arrivé ceci...' + env['sinatra.error'].message
+ 'Oups ! Il est arrivé...' + env['sinatra.error'].message
end
```
-Donc si ceci arrive :
+Donc si cette erreur est soulevée :
``` ruby
get '/' do
@@ -2313,9 +2300,11 @@ get '/' do
end
```
-Vous obtenez ça :
+La réponse sera :
- Donc il est arrivé ceci... quelque chose de mal
+```
+Oups ! Il est arrivé... quelque chose de mal
+```
Alternativement, vous pouvez avoir un gestionnaire d'erreur associé à un code
particulier :
@@ -2339,19 +2328,19 @@ end
```
Sinatra installe pour vous quelques gestionnaires `not_found` et
-`error` génériques lorsque vous êtes en environnement
+`error` génériques lorsque vous êtes en environnement de
`development`.
## Les Middlewares Rack
-Sinatra tourne avec [Rack](http://rack.github.io/), une interface standard
+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" -- composant qui vient se
+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 de construire facilement des middlewares Rack via la méthode de
+Sinatra permet d'utiliser facilement des middlewares Rack via la méthode de
haut niveau `use` :
``` ruby
@@ -2368,19 +2357,19 @@ end
La sémantique de `use` est identique à celle définie dans le DSL de
[Rack::Builder](http://rubydoc.info/github/rack/rack/master/Rack/Builder)
-(le plus souvent utilisé dans un fichier rackup). Par exemple, la méthode
+(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 |login, password|
- login == 'admin' && password == 'secret'
+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` en ce qui les concerne.
+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),
@@ -2411,7 +2400,7 @@ class MonTest < Minitest::Test
end
def test_avec_des_parametres
- get '/rencontrer', :name => 'Frank'
+ get '/rencontrer', :nom => 'Frank'
assert_equal 'Salut Frank !', last_response.body
end
@@ -2477,11 +2466,11 @@ 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 pas
+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 Ruby par processus Ruby. Si vous pensez en
+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.
@@ -2615,7 +2604,7 @@ de passer au style modulaire pour utiliser un fichier `config.ru`.**
Non seulement Sinatra peut utiliser d'autres middlewares Rack, il peut
également être à son tour utilisé au-dessus de n'importe quel endpoint Rack
-en tant que middleware. Ce endpoint peut très bien être une autre
+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/...) :
@@ -2682,7 +2671,7 @@ map('/b') do
end
```
-C'est notamment utile pour tester des extensions à Sinatra ou bien pour
+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 :
@@ -2777,9 +2766,9 @@ Le contexte de délégation se contente de transmettre les appels de méthodes a
contexte de classe. Toutefois, il ne se comporte pas à 100% comme le contexte
de classe car vous n'avez pas le binding de la classe : seules les méthodes
spécifiquement déclarées pour délégation sont disponibles et il n'est pas
-possible de partager des variables/états avec le contexte de classe
-(comprenez : `self` n'est pas le même). Vous pouvez ajouter des délégation de
-méthodes en appelant `Sinatra::Delegator.delegate :method_name`.
+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 :
Please sign in to comment.
Something went wrong with that request. Please try again.