1                       Tutoriel Ruby on Rails                                    Apprendre Rails par lexemple            ...
2    1.2.4 Bundler ..........................................................................................................
3   2.2 La ressouce Utilisateur (Users) .....................................................................................
4    3.3.4 Éliminer les duplications avec les layouts........................................................................
5      5.1 Ajout de structure................................................................................................
6    6.3.1 Débuggage et environnement Rails .................................................................................
7          8.1.2 Le formulaire HTML .........................................................................................
8    9.3.2 Se souvenir de moi................................................................................................
9      10.6 Exercices........................................................................................................
10     12.2.1 Données de simple lecteur......................................................................................
11Enfin, en incluant Git, GitHub et Heroku dans les exemples de la démonstration, lauteur vous donnevraiment le goût de ce...
12          Permission est accordée, à titre gratuit, à toute personne obtenant             une copie de ce logiciel et la...
13chapitre 1 De zéro au déploiementBienvenue dans Le Tutoriel Ruby on Rails : Apprendre Rails par lexemple. Le but de ce l...
14     modèle de données utilisateur (« user data model ») et un système complet et fonctionnel denregistrement et       d...
15éventail dapplications, depuis la start-up bagarreuse jusquaux énormes compagnies : Posterous,UserVoice, 37signals, Shop...
16     mesure dutiliser des ressources Rails plus avancées, et prêts de la même manière à approfondir de façon plus       ...
17     niveau professionnel dune application Rails, seul le cœur du code de lapplication est strictement     nécessaire da...
18     larchitecture REST préconisé par Rails. Ruby possède également sa propre idiosyncrasie, peut-être sera-t-elle      ...
19Les éditions HTML et PDF de ce livre sont riches en liens, vers des sections internes (telles que Section 1.2)aussi bien...
20     Comme pour linvite de la commande en ligne, ce Tutoriel Rails utilise la convention Unix pour les séparateurs de   ...
21concerne pas en particulier ; tout développeur doit en passer par là (et souvent plus dune fois), mais soyezassuré que l...
22      Illustration 1.1: Un environnement de développement éditeur de texte/ligne de commande (TextMate/iTerm).     Navig...
231.2.2 Ruby, RubyGems, Rails, et GitMaintenant, il est temps dinstaller Ruby et Rails. La source canonique et actualisée ...
24     ligne. Ce qui suit est une série détapes que jai exécutées pour le fonctionnement sur mon système (Macintosh       ...
25  $ rvm --create 1.8.7-p174@rails2tutorial  $ rvm --create use 1.9.2@rails3tutorialLa première commande crée le gemset r...
26     $ [sudo] gem update --system      Pour finir, si vous utilisez Ubuntu Linux, vous devriez jeter un coup dœil à the ...
27              create       config/application.rb              create       config/environment.rb              . Remarque...
28 config/                  Configuration de lapplication db/                      Fichiers pour manipuler la base de donn...
29  # Bundle edge Rails instead:  # gem rails, :git => git://github.com/rails/rails.git  gem sqlite3-ruby, :require => sql...
30     source http://rubygems.org        gem rails, 3.0.5        gem sqlite3-ruby, 1.3.2, :require => sqlite3      Cela ch...
31   $ rails server   => Booting WEBrick   => Rails 3.0.5 application starting on http://0.0.0.0:3000   => Call with -d to...
32         Illustration 1.4: La page par défaut (http://localhost:3000/) avec lenvironnement de                           ...
33représente un élément du site (tel quun utilisateur) et est en charge de la communication avec la base dedonnées. Après ...
34     Il y a beaucoup doptions pour le contrôle de version, mais la communauté Rails a largement opté pour Git, un       ...
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
Prochain SlideShare
Chargement dans…5
×

Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl

14 611 vues

Publié le

Mise en page avec pagination du tutoriel Ruby on Rails de Michael Hartl traduit en français

Publié dans : Technologie
0 commentaire
7 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
14 611
Sur SlideShare
0
Issues des intégrations
0
Intégrations
247
Actions
Partages
0
Téléchargements
784
Commentaires
0
J’aime
7
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl

  1. 1. 1 Tutoriel Ruby on Rails Apprendre Rails par lexemple Michael HartlContenuchapitre 1 De zéro au déploiement...........................................................................................................13 1.1 Introduction ....................................................................................................................................14 1.1.1 Commentaires pour la grande variété de lecteurs ...................................................................15 1.1.2 « Mise à léchelle » (Scaling) de Rails ....................................................................................18 1.1.3 Conventions utilisées dans ce livre .........................................................................................18 1.2 Debout et au boulot ........................................................................................................................20 1.2.1 Les environnements de développement ..................................................................................21 IDEs .............................................................................................................................................21 Éditeurs de texte et ligne de commande.......................................................................................21 Navigateurs internet .....................................................................................................................22 Une note à propos des outils ........................................................................................................22 1.2.2 Ruby, RubyGems, Rails, et Git...............................................................................................23 Installeur Rails (Windows) ..........................................................................................................23 Installation de Git.........................................................................................................................23 Installer Ruby...............................................................................................................................23 Installation de RubyGems ............................................................................................................25 Installer Rails ...............................................................................................................................26 1.2.3 La première application ..........................................................................................................26
  2. 2. 2 1.2.4 Bundler ...................................................................................................................................................28 1.2.5 rails server....................................................................................................................30 1.2.6 Modèle-Vue-Contrôleur (MVC) .............................................................................................32 1.3 Contrôle de version avec Git..........................................................................................................33 1.3.1 Installation et réglages ............................................................................................................34 Initialisation des réglages du système ..........................................................................................34 Initialisation des réglages du repository.......................................................................................35 1.3.2 Ajout et mandat de dépôt ........................................................................................................36 1.3.3 Quest-ce que Git peut faire de bien pour vous ? ....................................................................37 1.3.4 GitHub.....................................................................................................................................39 1.3.5 Branch, edit, commit, merge ...................................................................................................41 Branch ..........................................................................................................................................41 Edit ...............................................................................................................................................42 Commit.........................................................................................................................................42 Merge ...........................................................................................................................................43 Push..............................................................................................................................................44 1.4 Déploiement ...................................................................................................................................45 1.4.1 Réglages Heroku .....................................................................................................................46 1.4.2 Déploiement Heroku, première étape .....................................................................................46 1.4.3 Déploiement Heroku, seconde étape ............................................................................47 1.4.4 Commandes Heroku................................................................................................................48 1.5 Conclusion .....................................................................................................................................49 Chapitre 2 Une application Démo............................................................................................................50 2.1 Planifier lapplication .....................................................................................................................50 2.1.1 Modéliser les utilisateurs ........................................................................................................52 2.1.2 Modéliser les micro-messages ................................................................................................52
  3. 3. 3 2.2 La ressouce Utilisateur (Users) ......................................................................................................53 2.2.1 Un tour de lutilisateur.............................................................................................................55 2.2.2 MVC en action ........................................................................................................................60 2.2.3 Faiblesse de cette ressource utilisateur ...................................................................................66 2.3 La ressource micro-messages.........................................................................................................66 2.3.1 Un petit tour du micro-message ..............................................................................................66 2.3.2 Appliquer le micro aux micro-messages.................................................................................71 2.3.3 Un utilisateur possède plusieurs micro-messages...................................................................72 2.3.4 Hiérarchie des héritages ..........................................................................................................73 2.3.5 Déployer lapplication Démo ..................................................................................................76 2.4 Conclusion .....................................................................................................................................76Chapitre 3 Pages statiques courantes .......................................................................................................78 3.1 Pages statiques ...............................................................................................................................81 3.1.1 Vraies pages statiques .............................................................................................................81 3.1.2 Les pages statiques avec Rails ................................................................................................84 3.2 Nos premiers tests ..........................................................................................................................89 3.2.1 Outils de test............................................................................................................................90 Autotest ........................................................................................................................................90 3.2.2 TDD : Rouge, Vert, Restructurer ............................................................................................92 Spork ............................................................................................................................................98 Rouge .........................................................................................................................................102 Vert.............................................................................................................................................105 3.3 Pages (un peu) dynamiques..........................................................................................................108 3.3.1 Tester un changement de titre ...............................................................................................108 3.3.2 Réussir les tests de titre.........................................................................................................111 3.3.3 Variables dinstance et Ruby embarqué ................................................................................114
  4. 4. 4 3.3.4 Éliminer les duplications avec les layouts............................................................................................117 3.4 Conclusion ...................................................................................................................................119 3.5 Exercises ......................................................................................................................................120 chapitre 4 Rails au goût Ruby ................................................................................................................123 4.1 Motivation ..............................................................................................................................123 4.1.1 Un « helper » pour le titre.............................................................................................123 4.1.2 Feuilles de styles en cascade (CCS — Cascading Style Sheets)................................126 4.2 Chaines de caractères et méthodes ....................................................................................128 4.2.1 Commentaires ................................................................................................................128 4.2.2 Chaines de caractères....................................................................................................129 4.2.3 Objets et passage de message ......................................................................................132 4.2.4 Définition des méthodes...............................................................................................135 4.2.5 Retour à lhelper titre ...............................................................................................136 4.3 Autres structures de données..............................................................................................137 4.3.1 Tableaux (Arrays) et rangs (ranges)............................................................................137 4.3.2 Blocs ................................................................................................................................140 4.3.3 Tables de hachage et symboles ....................................................................................143 4.3.4 CSS Revisité....................................................................................................................146 4.4 Classes Ruby ..........................................................................................................................147 4.4.1 Constructeurs .................................................................................................................147 4.4.2 Héritage de classe..........................................................................................................149 4.4.3 Modifier les classes dorigine .......................................................................................152 4.4.4 Une classe contrôleur....................................................................................................153 4.4.5 La classe utilisateur .......................................................................................................155 4.5 Exercises.................................................................................................................................157 Chapitre 5 Poursuivre la mise en page...................................................................................................159
  5. 5. 5 5.1 Ajout de structure..................................................................................................................159 5.1.1 Navigation........................................................................................................................160 5.1.2 CSS personnalisés ..........................................................................................................166 5.1.3 Partiels .............................................................................................................................173 5.2 Liens pour la mise en page ..................................................................................................177 5.2.1 Test dintégration ...........................................................................................................178 5.2.2 Routes Rails....................................................................................................................181 5.2.3 Routes nommées............................................................................................................184 5.3 Inscription de lutilisateur : une première étape ..............................................................186 5.3.1 Contrôleur des utilisateurs (Users ) ............................................................................186 5.3.2 URL de linscription ......................................................................................................189 5.4 Conclusion .............................................................................................................................191 5.5 Exercises.................................................................................................................................192Chapitre 6 Modéliser et afficher les utilisateurs, partie I.......................................................................194 6.1 Modèle Utilisateur.................................................................................................................196 6.1.1 Migrations de la base de données ................................................................................196 6.1.2 Le fichier modèle............................................................................................................200 6.1.3 Créer des objets utilisateur ...........................................................................................203 6.1.4 Recherche dans les objets Utilisateurs (Users) .........................................................206 6.1.5 Actualisation des objets Utilisateurs (Users) .............................................................208 6.2 Validations de lutilisateur...................................................................................................209 6.2.1 Valider la présence.........................................................................................................210 6.2.2 Validation de la longueur (length) ..............................................................................217 6.2.3 Validation de format .....................................................................................................218 6.2.4 Validation dunicité .......................................................................................................222 6.3 Affichage des utilisateurs.....................................................................................................226
  6. 6. 6 6.3.1 Débuggage et environnement Rails ................................................................................................227 6.3.2 Modèle User, Vue, Contrôleur .....................................................................................229 6.3.3 Une ressource Users......................................................................................................232 6.4 Conclusion ...................................................................................................................................235 6.5 Exercises ......................................................................................................................................235 chapitre 7 Modéliser et afficher les utilisateurs, partie II ......................................................................236 7.1 Mots de passe peu sécurisés.................................................................................................237 7.1.1 Validations du mot de passe..........................................................................................237 7.1.2 La migration du mot de passe ......................................................................................240 7.1.3 Fonction de rappel dans lActive Record ....................................................................243 7.2 Mots de passe sécurisés........................................................................................................247 7.2.1 Un test de mot de passe sécurisé..................................................................................247 7.2.2 Un peu de théorie sur la sécurisation des mots de passe.........................................249 7.2.3 Implémenter has_password?...................................................................................251 7.2.4 Une méthode dauthentification..................................................................................254 7.3 Meilleures vues dutilisateurs..............................................................................................259 7.3.1 Tester la page daffichage de lutilisateur (avec factories)........................................259 7.3.2 Un nom et un Gravatar .................................................................................................264 7.3.3 Une barre utilisateur latérale .......................................................................................271 7.4 Conclusion..............................................................................................................................274 7.4.1 Dépôt Git .........................................................................................................................274 7.4.2 déploiement Heroku......................................................................................................275 7.5 Exercices.................................................................................................................................275 chapitre 8 Inscription .............................................................................................................................277 8.1 Formulaire dinscription ......................................................................................................277 8.1.1 Utiliser form_for .........................................................................................................279
  7. 7. 7 8.1.2 Le formulaire HTML .....................................................................................................282 8.2 Échec de linscription ...........................................................................................................285 8.2.1 Tester léchec ..................................................................................................................286 8.2.2 Un formulaire fonctionnel ...........................................................................................288 8.2.3 Message derreur à linscription ..................................................................................291 8.2.4 Filtrer les paramètres didentification........................................................................296 8.3 Réussite de linscription.......................................................................................................298 8.3.1 Tester la réussite ............................................................................................................299 8.3.2 Le formulaire dinscription final .................................................................................300 8.3.3 Le message « flash »......................................................................................................301 8.3.4 La première inscription ................................................................................................305 8.4 Les tests dintégration RSpec ..............................................................................................306 8.4.1 Tests dintégration sur les styles ..................................................................................307 8.4.2 Un échec dinscription ne devrait pas créer un nouvel utilisateur.........................308 8.4.3 Le succès dune inscription devrait créer un nouvel utilisateur .............................311 8.5 Conclusion .............................................................................................................................313 8.6 Exercises ................................................................................................................................314Chapitre 9 Connexion, déconnexion ......................................................................................................316 9.1 Les sessions ............................................................................................................................316 9.1.1 Contrôleur Sessions........................................................................................................317 9.1.2 Formulaire didentification...........................................................................................319 9.2 Échec de lidentification.......................................................................................................322 9.2.1 Examen de la soumission du formulaire ....................................................................323 9.2.2 Échec de lidentification (test et code)........................................................................325 9.3 Réussite de lidentification ..................................................................................................328 9.3.1 Laction create achevée..............................................................................................329
  8. 8. 8 9.3.2 Se souvenir de moi............................................................................................................................331 9.3.3 Utilisateur courant ........................................................................................................335 9.4 Déconnexion..........................................................................................................................344 9.4.1 Détruire les sessions ......................................................................................................345 9.4.2 Connexion à linscription .............................................................................................347 9.4.3 Changement des liens de la mise en page ..................................................................348 9.4.4 Test dintégration pour lidentification et la déconnexion.......................................353 9.5 Conclusion .............................................................................................................................354 9.6 Exercises.................................................................................................................................354 Chapitre 10Actualiser, afficher et supprimer des utilisateurs ................................................................356 10.1 Actualisation ........................................................................................................................356 10.1.1 Formulaire dédition ....................................................................................................356 10.1.2 Permettre lédition .......................................................................................................363 10.2 Protection des pages...........................................................................................................366 10.2.1 Lidentification requise de lutilisateur .....................................................................367 10.2.2 Nécessité du bon utilisateur.......................................................................................370 10.2.3 Redirection conviviale.................................................................................................373 10.3 Affichage des utilisateurs...................................................................................................376 10.3.1 Liste des utilisateurs ....................................................................................................376 10.3.2 Utilisateurs fictifs ........................................................................................................381 10.3.3 Pagination.....................................................................................................................383 10.3.4 Restructuration des partiels.......................................................................................389 10.4 Destruction des utilisateurs...............................................................................................391 10.4.1 Utilisateurs administrateurs.......................................................................................391 10.4.2 Laction destroy (détruire) .....................................................................................395 10.5 Conclusion............................................................................................................................400
  9. 9. 9 10.6 Exercices...............................................................................................................................401chapitre 11 Micro-messages dutilisateur...............................................................................................403 11.1 Un modèle `Micropost` ......................................................................................................403 11.1.1 Le modèle de base .........................................................................................................403 11.1.2 Association Utilisateur/Micro-message (User/Micropost) ....................................406 11.1.3 Affinements du micro-message ..................................................................................411 11.1.4 Validation du micro-message......................................................................................415 11.2 Affichage des micro-messages ...........................................................................................417 11.2.1 Etoffement de la page de lutilisateur ........................................................................418 11.2.2 Exemples de micro-messages.....................................................................................425 11.3 Manipuler les micro-messages ..........................................................................................428 11.3.1 Contrôle daccès ............................................................................................................429 11.3.2 Création des micro-messages .....................................................................................431 11.3.3 Une proto-alimentation...............................................................................................438 11.3.4 Destruction des micro-messages ...............................................................................445 11.3.5 Test de la nouvelle page daccueil ..............................................................................449 11.4 Conclusion ............................................................................................................................450 11.5 Exercices ...............................................................................................................................451Chapitre 12 Suivi des utilisateurs...........................................................................................................453 12.1 Le modèle de relation..........................................................................................................456 12.1.1 Problème avec le modèle de données (et ses solutions)..........................................456 12.1.2 Association utilisateur/relations................................................................................460 12.1.3 Validations.....................................................................................................................464 12.1.4 Suivi................................................................................................................................465 12.1.5 Les Lecteurs...................................................................................................................471 12.2 Une interface web pour les auteurs et les lecteurs .........................................................473
  10. 10. 10 12.2.1 Données de simple lecteur..............................................................................................................474 12.2.2 Statistiques et formulaire de suivi.............................................................................476 12.2.3 Pages des auteurs suivis et des lecteurs....................................................................485 12.2.4 Un bouton de suivi standard ......................................................................................491 12.2.5 Un bouton de suivi fonctionnel avec Ajax ................................................................493 12.3 Létat de lalimentation.......................................................................................................498 12.3.1 Motivation et stratégie.................................................................................................499 12.3.2 Une première implémentation de lalimentation....................................................502 12.3.3 Champs dapplication, sous-sélections et lambda ..................................................504 12.3.4 Le nouvel état de lalimentation ................................................................................509 12.4 Conclusion............................................................................................................................510 12.4.1 Extensions de lApplication Exemple ........................................................................511 12.4.2 Guide vers dautres ressources...................................................................................513 12.5 Exercices...............................................................................................................................514 Notes ......................................................................................................................................................516 Avant-propos Ma précédente compagnie (CD Baby) fut une des premières à basculer intégralement vers Ruby on Rails, et à rebasculer aussi intégralement vers PHP (googlez-moi si vous voulez prendre la mesure du drame). On ma tellement recommandé ce livre Michael Hartl que je nai pu faire autrement que de le lire. Cest ainsi que le Tutoriel Ruby on Rails ma fait revenir à nouveau à Rails. Bien quayant parcouru de nombreux livres sur Rails, cest ce tutoriel-là qui ma véritablement « mis en possession » de Rails. Tout est fait ici « à la manière de Rails » — une manière qui ne mavait jamais semblé naturelle avant que je ne lise ce livre. Cest aussi le seul ouvrage sur Rails qui met en place, dun bout à lautre, un Développement Dirigé par les Tests (Test-Driven Development), une approche que je savais hautement recommandée par les experts mais dont je navais jamais compris aussi bien la pertinence que dans ce livre.
  11. 11. 11Enfin, en incluant Git, GitHub et Heroku dans les exemples de la démonstration, lauteur vous donnevraiment le goût de ce quest le développement dun projet dans la vie réelle. Et le exemples de code ne sont pasen reste.La narration linéaire adoptée par ce tutoriel est vraiment un bon format. Personnellement, jai étudié LeTutoriel Rails en trois longues journées, en faisant tous les exemples et les exercices proposés à la fin de chaquechapitre. Cest en lisant ce livre du début à la fin, sans sauter la moindre partie, quon en tire tout le bénéfice.Régalez-vous ! Derek Sivers (sivers.org) Précédemment : Fondateur de CD Baby Actuellement : Fondateur de Thoughts Ltd. RemerciementsCe Tutoriel Ruby on Rails doit beaucoup à mon livre précédent sur Rails, RailsSpace, et donc à mon co-auteurAurelius Prochazka. Jaimerais remercier Aure à la fois pour le travail quil a accompli sur ce précédent livre etpour son soutien pour le présent ouvrage. Jaimerais aussi remercier Debra Williams Cauley, mon éditeur pourles deux ouvrages ; aussi longtemps quelle jouera avec moi au baseball, je continuerai décrire des livres pourelle. Jaimerais remercier une longue liste de Rubyistes qui mont parlé et inspiré au cours des années : David Heinemeier Hansson, Yehuda Katz, Carl Lerche, Jeremy Kemper, Xavier Noria, Ryan Bates, Geoffrey Grosenbach, Peter Cooper, Matt Aimonetti, Gregg Pollack, Wayne E. Seguin, Amy Hoy, Dave Chelimsky, Pat Maddox, Tom Preston-Werner, Chris Wanstrath, Chad Fowler, Josh Susser, Obie Fernandez, Ian McFarland, Steven Bristol, Giles Bowkett, Evan Dorn, Long Nguyen, James Lindenbaum, Adam Wiggins, Tikhon Bernstam, Ron Evans, Wyatt Greene, Miles Forrest, les gens bien de Pivotal Labs, le gang Heroku, les mecs de thoughtbot et léquipe de GitHub. Enfin, tellement, tellement, tellement de lecteurs — beaucoup trop pour les citer tous — qui ont contribué par leur rapport de bogues et leurs suggestions durant lécriture de ce livre, et je tiens à saluer leur aide sans laquelle ce livre ne serait pas ce quil est. À propos de lauteur Michael Hartl est programmeur, éducateur et entrepreneur. Il est le co-auteur de RailsSpace, un tutoriel Rails publié en 2007, et a été co-fondateur et développeur en chef de Insoshi, une plateforme de réseau social populaire en Ruby on Rails. Précédement, il a enseigné la théorie et la physique informatique au California Institute of Technology (Caltech), où il a reçu le Lifetime Achievement Award for Excellence en enseignement. Michael est diplômé du Harvard College, a un Ph.D. en physique (un doctorat. NdT) de Caltech, et il est ancien élève du programme des entrepreneurs Y Combinator. Copyright et licenseLe Tutoriel Ruby on Rails : apprendre Rails par lexemple. Copyright © 2010 par Michael Hartl. Tout le codesource du Tutoriel Ruby on Rails est disponible sous la license MIT License et la licence Beerware License. Copyright (c) 2010 Michael Hartl
  12. 12. 12 Permission est accordée, à titre gratuit, à toute personne obtenant une copie de ce logiciel et la documentation associée, pour faire des modification dans le logiciel sans restriction et sans limitation des droits d’utiliser, copier, modifier, fusionner, publier, distribuer, concéder sous licence, et / ou de vendre les copies du Logiciel, et à autoriser les personnes auxquelles le Logiciel est meublé de le faire, sous réserve des conditions suivantes: L’avis de copyright ci-dessus et cette autorisation doit être inclus dans toutes les copies ou parties substantielles du Logiciel. LE LOGICIEL EST FOURNI «TEL QUEL», SANS GARANTIE D’AUCUNE SORTE, EXPLICITE OU IMPLICITE, Y COMPRIS, MAIS SANS S’Y LIMITER, LES GARANTIES DE QUALITÉ MARCHANDE, ADAPTATION À UN USAGE PARTICULIER ET D’ABSENCE DE CONTREFAÇON. EN AUCUN CAS LES AUTEURS OU TITULAIRES DU ETRE TENU RESPONSABLE DE TOUT DOMMAGE, RÉCLAMATION OU AUTRES RESPONSABILITÉ, SOIT DANS UNE ACTION DE CONTRAT, UN TORT OU AUTRE, PROVENANT DE, DE OU EN RELATION AVEC LE LOGICIEL OU L’UTILISATION OU DE TRANSACTIONS AUTRES LE LOGICIEL. /* * ------------------------------------------------------------ * "LA LICENCE BEERWARE" (Révision 42) : * Michael Hartl a écrit ce code. Aussi longtemps que vous * conservez cette note, vous pouvez faire ce que vous voulez * de ce travail. Si nous nous rencontrons un jour, et que vous * pensez que ce travail en vaut la peine, vous pourrez me * payer une bière en retour. * ------------------------------------------------------------ */
  13. 13. 13chapitre 1 De zéro au déploiementBienvenue dans Le Tutoriel Ruby on Rails : Apprendre Rails par lexemple. Le but de ce livre est dêtre lameilleure réponse à la question : « Si je veux apprendre le développement web avec Ruby on Rails, par où dois-je commencer ? » Quand vous aurez achevé Le Turoriel Ruby on Rails, vous aurez toutes les connaissancesnécessaires pour développer et déployer votre propre application web. Vous serez également en mesure de tirerprofit de livre plus avancés, des blogs et des screencasts qui peuplent le écosystème Rails, prospère. Enfin,puisque le Tutoriel Ruby on Rails utilise Rails 3.0, la connaissance que vous acquiererez sera pleinementdactualité avec la dernière et meilleure version de Rails.1Le Tutoriel Ruby on Rails suit essentiellement la même approche que mon livre précédent,2 enseignant ledéveloppement web avec Rails en construisant un exemple dapplication conséquente, depuis le tout départ.Comme Derek Sivers le souligne dans lavant-propos, ce livre est structuré en narration linéaire, destinée enconséquence à être lue du début à la fin. Si vous avez lhabitude de survoler les livres techniques, suivre cetteapproche linéaire peut vous demander quelques ajustements, mais je ne saurais trop vous recommanderdessayer. Vous pouvez penser au Tutoriel Ruby on Rails comme un jeu vidéo dont vous êtes le héros, et oùvous augmentez votre niveau de développeur Rails à chaque chapitre (les exercices sont comme des mini-boss).Dans le premier chapitre, nous commencerons avec Ruby on Rails en installant tous les softwares nécessaires eten préparant votre environnement de développement (section 1.2). Nous créerons alors notre premièreapplication Rails, appelée (de façon assez pertinente ma foi) first_app (première_application). LeTutoriel Rails met laccent sur les bonnes pratiques de développement, aussi, immédiatement après avoir créénotre tout nouveau projet Rails nous le déposerons sous un contrôle de version avec Git (section 1.3). Et,croyez-le ou non, dans ce chapitre nous déploierons même notre première application en mode « production »(Section 1.4).Au chapitre 2, nous créerons un second projet, dont le but sera dillustrer les fonctions élémentaires duneapplication Rails. De façon très rapide, nous construirons cette application démo (qui sappellerademo_app) en utilisant le système déchaffaudage (« scaffolding ») (Box 1.1) pour générerautomatiquement le code ; comme ce code est aussi laid que complexe, le chapitre 2 se concentrera plutôt surlinteraction avec lapplication démo par le biais des URLs3 en utilisant un navigateur internet.Au chapitre 3, nous créerons une application exemple (que nous appellerons sample_app), en écrivantcette fois tout le code à partir de (presque) rien. Nous développerons cette application exemple en utilisant leTest Dirigé par le Développement (« test-driven development », TDD), amorcé au chapitre 3 en créant despages statiques puis en ajoutant un peu de contenu dynamique. Nous ferons un rapide détour au chapitre 4pour en apprendre un peu plus sur le langage Ruby sous-jacent à Rails. Puis, du chapitre 5 au chapitre 10, nouscomplèterons les fondations de lapplication exemple en fabricant un layout (une mise en page) pour le site, un
  14. 14. 14 modèle de données utilisateur (« user data model ») et un système complet et fonctionnel denregistrement et dauthentification. Enfin, aux chapitre 11 et chapitre 12 nous incorporerons des outils de micro-blogging (un système de mini-messages) et de réseau social pour faire un exemple de site tout à fait fonctionnel. Lapplication exemple finale aura plus dune ressemblance avec une certaine application sociale de micro- blogging — un site qui, est-ce un hasard, est également écrit en Rails. Bien que nos efforts se concentrent nécessairement sur cette application exemple spécifique, laccent dans ce Tutoriel Rails sera mis sur des principes généraux, donc vous acquièrerez des notions fondamentales et solides qui vous permettrons de développer vos propres applications web, quels que soient leur genres. Box 1.1.Échaffaudage (Scaffolding) : Plus rapide, plus facile, plus séduisant Depuis le départ, Rails a bénéficié dun engouement évident, notamment gràce au fameux Un Weblog vidéo en 15 minutes par le créateur de Rails David Heinemeier Hansson, actualisé à présent dans le Un Weblog en 15 minutes en utilisant Rails 2 par Ryan Bates. Ces vidéos sont une excellent façon de goûter à la puissance de Rails, et je recommande vivement de les regarder. Mais soyez averti quand même : ils accomplissent leur incroyable coup dadresse de quinze minutes en utilisant loutil appelé scaffolding (Échaffaudage), bâti essentiellement sur un code automatiquement généré, créé comme par magie par la commande Rails generate (Générer). En écrivant un tutoriel sur Ruby on rails, il est tentant de sappuyer sur lapproche par échaffaudage — elle est plus rapide, plus facile, et plus séduisante. Mais la complexité et lénorme quantité de code dun échaffaudage peut être rédhibitoire pour un développeur Rails débutant ; vous pouvez peut-être lutiliser, mais vous serez incapable de le comprendre. Suivre lapproche par échaffaudage risque de vous tourner vers un script générateur de code virtuose au détriment dune véritable connaissance de Rails. Dans le Tutoriel Ruby on Rails, nous adopterons lapproche presque exactement opposée : bien que le chapitre 2 développera une petite application démo en utilisant le système déchaffaudage, le cœur de ce tutoriel est lApplication Exemple, que nous commencerons à concevoir au chapitre 3. À chaque étape du développement de cette application exemple, nous générerons le code bouchée après bouchée, petite pièce de code par petite pièce de code — assez simple pour être compris, mais assez nouveau pour représenter une difficulté à surmonter. Leffet de cette approche par couches résultera en une approche profonde, et une connaissance flexible de Rails, vous fournissant de bonnes connaissances fondamentales pour concevoir pratiquement nimporte quel type dapplication web. 1.1 Introduction Depuis ses début en 2004, Ruby on Rails est rapidement devenu un des frameworks les plus populaires et les plus puissants pour construire des applications web dynamiques. Les utilisations de Rails couvrent un large
  15. 15. 15éventail dapplications, depuis la start-up bagarreuse jusquaux énormes compagnies : Posterous,UserVoice, 37signals, Shopify, Scribd, Twitter, Hulu, the Yellow Pages (les Pages Jaunes) — la liste des sitesutilisant Rails sallongent de jour en jour. Il y a aussi de nombreux producteurs de développements web qui sespécialisent en Rails, tels que ENTP, thoughtbot, Pivotal Labs ou Hashrocket, sans compter les innombrablesconsultants indépendants, entraineurs et entrepreneurs.Quest-ce qui rend Rails si fantastique ? Tout dabord, Ruby on Rails est 100% en « open-source », accessiblesous la licence MIT License, e qui signifie quil ne coûte rien de le télécharger et de lutiliser. Rails doitégalement le plus gros de son succès à son design compact et élégant ; en exploitant la maléabilité de la sous-couche en langage Ruby, Rails crée de façon effective un langage de domaine spécifique pour écrire desapplications web. Il en résulte que de nombreuse tâches courantes de programmation web — telles que générerdu code HTML, faire des modèles de données ou rediriger les URLs — deviennent faciles avec Rails, et le codede lapplication produit est concis et lisible.Rails sadapte également avec rapidité aux développements les plus récents de la technologie internet et à laconception par framework. Rails a par exemple été lun des premiers frameworks à digérer et implémenter entotalité larchitecture de style REST pour structurer les applications web (ce que nous apprendrons à faire aucours de ce tutoriel). Et quand dautres framewords développent avec succès de nouvelles technologies, lecréateur de Rails, David Heinemeier Hansson ainsi que le cœur de léquipe Rails nhésite jamais à incorporer àRails leurs nouvelles idées. Peut-être lexemple le plus parlant est la fusion de Rails et de Merb, un frameworkconcurrent, de telle sorte que Rails bénéficie maintenant de la conception modulaire de Merb, API stable et auxperformances améliorées. Quiconque a assisté à la conférence donnée par le développeur de Merb et le noyaudur de léquipe Yehuda Katz na pu faire autrement que de noter à quel point ce fut une extrêmement bonneidée de monter léquipe de Merb à bord.Enfin, Rails bénéficie dune communauté exceptionnellement enthousiaste et diverse. Les résultats en sont descentaines de contributeurs open-source, des conférences largement suivies, un nombre considérable de pluginset des gems (solutions clé-en-main pour des problèmes spécifiques comme la pagination ou le téléchargementdimages), une riche variété de blogs dinformation, et une corne dabandonce débordant de forums dediscussions et de canaux de discussion IRC. Le grand nombre de développeurs Rails rend également plus facilela résolution des erreurs inévitables de toute lapplication : lalgorithme « Googlelisez votre message derreur »renvoie pratiquement toujours vers le message pertinent dun blog ou un sujet de discussion dans un forum.1.1.1 Commentaires pour la grande variété de lecteursLe Tutoriel Rails contient des « tutoriels intégrés » non seulement pour Rails, mais aussi pour le langage sous-jacent Ruby, aussi bien que pour HTML, CSS, un peu de JavaScript, et même un peu de SQL. Cela signifie que,quelles que soient vos connaissances en matière de développement web, en finissant ce tutoriel vous serez en
  16. 16. 16 mesure dutiliser des ressources Rails plus avancées, et prêts de la même manière à approfondir de façon plus systématique tous les autres sujets abordés. Rails titre une grande partie de son pouvoir de la « magic » — il en va ainsi des capacités du framework (telles que déduire automatiquement les attributs dun objet à partir du nom des colonnes de la base de données) qui accomplissent des miracles mais dont les mécanismes peuvent rester plutôt obscures. Le Tutorial Ruby on Rails nest pas destiné à expliquer cette magie — principalement parce que la plupart des développeurs dapplications Rails nont jamais besoin de savoir ce qui se passe en coulisses (après tout, le langage Ruby lui- même est écrit principalement en langage de programmation C, mais vous navez pas besoin de creuser dans le code source en C pour utiliser Ruby). Si vous êtes le genre de personne qui aime bien tirer les choses de derrière le rideau, je vous recommande la lecture de The Rails 3 Way par Obie Fernandez qui accompagnera avec profit ce Tutoriel Ruby on Rails. Bien que ce livre ne nécessite pas de requis spéciaux, vous devez bien entendu posséder au moins quelque expérience des ordinateurs. Si vous navez même jamais utilisé déditeur de texte, ce ne sera pas facile pour vous davancer, mais avec un peu de détermination vous devriez pouvoir passer à travers. Si, dun autre côté, votre fichier .emacs est tellement complexe quil pourrait faire pleurer un adulte, il vous restera toujours ici quelque défi à relever. Le Tutoriel Rails est destiné à enseigner le développement Rails quels que soient ses acquis propres, mais lexpérience que vous ferez de cette lectutre dépendra de vos aptitudes particulières. À tous les lecteurs : une question classique en étudiant Rails est de savoir sil faut étudier Ruby au préalable. La réponse dépend de la façon dont vous apprenez. Si vous avez une prédilection pour apprendre tout depuis la base, de façon systématique, alors apprendre le langage Ruby peut vous être utile ; plusieurs livres sont recommandés dans cette section pour vous faire débuter. Dun autre côté, de nombreux développeurs Rails débutants sont excités à lidée de créer des applications web, et préfèreront ne pas se coltiner un livre de 500 pages en pur Ruby avant décrire la moindre page sur une simple page web. Plus encore, le sous-ensemble de Ruby nécessaire aux développeurs Rails est différent de ce que vous pourriez trouver dans une introduction sur du pur Ruby, tandis que le Tutoriel Rails se concentre exclusivement sur ce sous-ensemble. Si votre intérêt premier est de construire des applications Rails, je vous recommande de commencer par ce Tutoriel Rails et de lire des livres de pur Ruby ensuite. Ce nest pas une proposition « tout ou rien », pour autant : si vous commencez à lire ce Tutoriel Rails et sentez votre manque de connaissance du Ruby vous ralentir, soyez libre de basculer vers un livre sur le langage Ruby avant de revenir au tutoriel lorsque vous vous sentirez plus à laise. Vous pouvez aussi vous contenter dun goût de ce quest Ruby en suivant un court tutoriel en ligne, tels que ceux quon peut trouver sur les sites http://www.ruby-lang.org/ ou http://rubylearning.com/. Une autre question classique concerne lutilisation des tests dès le départ. Comme cela est indiqué dans lintroduction, ce Tutoriel Rails fait appel au « Test Dirigé par le Développement » (test-driven development, appelé aussi test-first development), qui selon moi est la meilleure façon de développer des applications Rails, mais le fait est que cette approche introduit une quantité substantielle de difficulté et de complexité. Si vous sentez que vous vous enlisez à cause des tests, sentez-vous libre de les sauter dans une première lecture.4 Vraiment, certains lecteurs se sentent dans un premier temps écrasés par linclusion de nombreux concepts et de pratiques nouvelles — telles que les tests, les contrôles de versions, le déploiement. Aussi, si vous vous rendez compte que vous dépensez une énergie excessive sur toutes ces étapes, nhésitez pas à les passer. Bien que jai inclus seulement le matériel que je considère essentiel au développement dun
  17. 17. 17 niveau professionnel dune application Rails, seul le cœur du code de lapplication est strictement nécessaire dans une première lecture.Aux programmeurs non expérimentés (non-concepteurs) : ce Tutoriel Rails nexige aucun autrebackground quune connaissance générale de lordinateur, donc si vous avez une expérience limitée de laprogrammation ce livre est une bonne façon de commencer. Gardez à lesprit que cest seulement la premièreétape dun long voyage ; le développement web possède de nombreux aspects différents, parmi lesquels leHTML/CSS, JavaScript, les bases de données (et SQL), les contrôles de version et le déploiement. Ce livrecontient de courtes introductions à ces sujets, mais il y a bien plus encore à connaitre.Aux programmeurs non expérimentés (concepteurs) : vos aptitudes en matière de conception webvous donnent une longueur davance, puisque vous connaissez certainement déjà le HTML et les CSS. Aprèsavoir fini ce livre, vous serez dans une excellente position pour travailler sur des projets Rails existants etpourrez probablement en amorcer un de votre propre chef. Vous pouvez trouver difficile tout ce qui concerne laprogrammation, mais le langage Ruby est exceptionnellement accessible aux débutants, tout spécialement ceuxqui possèdent une fibre artistique.Après avoir achevé la lecture du Tutoriel Ruby on Rails, je recommande aux nouveaux programmeurs la lecturede Beginning Ruby de Peter Cooper, qui partage la même philosophie pédagogique que ce Tutoriel Rails. Jerecommande aussi The Ruby Way de Hal Fulton. Enfin, pour acquérir une compréhension plus profonde deRails je recommande The Rails 3 Way de Obie Fernandez. Les applications Web, même les relativement simples, sont de par nature assez complexes. Si vous êtes tout à fait nouveau dans la programmation web et trouvez trop complexe la lecture de ce Tutoriel Rails, cest peut-être que vous nêtes pas tout à fait prêts encore à développer des applications web. Dans ce cas, je vous suggère dapprendre les bases du HTML et des CSS et de recommencer ensuite seulement la lecture de ce tutoriel (malheureusement, je nai pas de recommandations particulières ici, mais Head First HTML semble prometteur, et un des lecteurs recommande CSS: The Missing Manual de David Sawyer McFarland). Vous pouvez aussi lire avec profit les premiers chapitres de Beginning Ruby, qui débute avec lexemple dune application plus petite quune application web au sens fort du terme.Aux programmeurs expérimentés découvrant le développement web : votre expérience signifie quevous comprenez probablement déjà les concepts de classes, de méthodes, de structures de données, etc., ce quiconstitue un sérieux avantage. Soyez tout de même avertis, dans le cas où votre background est le C/C++ ou leJava, que vous pourriez trouver que le langage Ruby ressemble un peu à un canard boiteux, et sa prise en mainpourrait vous prendre du temps ; familiarisez-vous juste avec lui, et tout devrait aller pour le mieux (Ruby vousautorise même à mettre des points-virgule à la fin des lignes sils vous manquent trop !). Ce Tutoriel Railscouvre toutes les idées spécifiques au développement web dont vous avez besoin, donc ne vous inquiétez pas sivous ne distinguez pas pour le moment une requête PUT dune requête POST.Aux développeurs web expérimentés découvrant Rails : vous avez une sérieuse longueur davance, toutspécialement si vous avez utilisé un langage dynamique tel que le PHP ou (encore mieux) le langage Python. Lesbases de ce que nous couvrons vous seront pour le moins familières, mais le développement par le test(Développement Dirigé par le Test, ou TDD) sera peut-être nouveau pour vous, comme peut lêtre aussi
  18. 18. 18 larchitecture REST préconisé par Rails. Ruby possède également sa propre idiosyncrasie, peut-être sera-t-elle aussi nouvelle pour vous. Aux programmeurs Ruby expérimentés : lensemble des programmeurs Ruby ne connaissant pas Rails est très restreint de nos jours, mais si vous faites partie de ce groupe délite, vous pouvez survoler ce livre et vous diriger ensuite sur le livre The Rails 3 Way de Obie Fernandez. Aux programmeurs Rails inexpérimentés : vous avez peut-être lu dautres tutoriels et créé quelques petites applications Rails. En me basant sur le retour des lecteurs, je suis confiant sur le fait que vous pourrez tirer beaucoup de ce livre. Parmi dautres choses, les techniques employées ici sont peut-être plus dactualité que celles que vous avez abordés quand vous avez appris Rails. Aux programmeurs Rails expérimentés : ce livre ne vous sera pas utile, et pourtant, de nombreux développeurs Rails expérimentés mont exprimé leur surprise quant à la quantité de choses quils avaient tirés de ce livre, et vous pourriez être ravis daborder Rails sous un autre jour, dans une autre perspective. Après avoir terminé ce Tutoriel Ruby on Rails, je recommande aux programmeurs (non Ruby) expérimentés la lecture de The Well-Grounded Rubyist de David A. Black, qui est une excellente et profonde discussion sur Ruby depuis la base, ou The Ruby Way de Hal Fulton, qui est tout aussi avancé mais adopte une approche plus actuelle. Passez ensuite à The Rails 3 Way pour approfondir encore votre expertise de Rails. À la fin de ce processus, quel que soit doù vous partiez, vous serez en mesure dappréhender les ressources Rails plus avancées. Voilà celle que je recommande particulièrement : • Railscasts : dexcellents screencats gratuits sur Rails ; • PeepCode, Pragmatic.tv, EnvyCasts : dexcellent screencasters payants ; • Rails Guides : bonnes références sur Rails, dactualité et actualisées. Ce Tutoriel Rails fait fréquemment référence au Rails Guides pour un traitement plus en profondeur de certains sujets ; • Rails blogs : trop de choses à énumérer, et quelles choses ! 1.1.2 « Mise à léchelle » (Scaling) de Rails Avant de poursuivre avec la suite de lintroduction, jaimerais marrêter un moment sur un problème qui collait au framework Rails à ses tout débuts : sa supposée inaptitude à se « mettre à léchelle » — pour, par exemple, absorber un trafic important. Une partie de cette question repose sur une idée tout à fait fausse ; vous mettez à léchelle un site, pas un framework, et Rails, aussi intelligent soit-il, nest quun framework. Donc la vraie question aurait dû être « Est-ce quun site construit en Rails peut se mettre à léchelle ? ». Dans ce cas, la réponse est résolument « oui » : quelques uns des sites les plus lourds en trafic dans le monde utilisent Rails. En fait, rendre la mise à léchelle possible va bien au-delà du champ dapplication de Rails, mais soyez assurés que si votre application connait un trafic similaire à celui de Hulu ou des « Pages jaunes », Rails ne sera pas un handicap pour vous étendre au travers du monde. 1.1.3 Conventions utilisées dans ce livre Les conventions de ce livre sexpliquent la plupart du temps delles-mêmes ; dans cette section, je mentionne celles qui ne le pourraient pas.
  19. 19. 19Les éditions HTML et PDF de ce livre sont riches en liens, vers des sections internes (telles que Section 1.2)aussi bien que des sites externes (tels que la page principale Télécharger Ruby on Rails).5De nombreux exemples de ce livre utilisent la « ligne de commande ». Pour la simplicité, tous les exemples enligne de commande utilisent linvite classique Unix (un dollar), comme suit : $ echo "bonjour le monde" bonjour le mondeLes utilisateurs Windows doivent savoir que leur système utilisera linvite analogue « > » : C:Sites>echo Salut le monde Salut le mondeSur les systèmes dexploitation Unix, certaines commandes devront être exécutées avec sudo, qui signifie« substitute user do » (Lutilisateur de substition fait…). Par défaut, une commande exécutée avec sudo estjouée comme par un utilisateur-administrateur, qui a accès à des fichiers et des dossiers que les utilisateursnormaux ne peuvent pas toucher. Pour indiquer que lutilisation de sudo dépendra de votre système, elle seprésentera entre crochets quand elle peut être (ou ne pas être) nécessaire sur votre propre système, commedans lexemple de la section 1.2.2: $ [sudo] ruby setup.rbLa plupart des systèmes dexploitation Unix/Linux/Os X requièrent la commande sudo par défaut, sauf si vousutilisez le Ruby Version Manager comme cela est suggéré dans la section 1.2.2.3. Notez que vous ne devez pasutiliser les crochets ; vous devez utiliser soit… $ sudo ruby setup.rbsoit… $ ruby setup.rb… en fonction de votre système dexploitation.Rails est fourni avec un grand nombre de commandes qui peuvent être jouées en ligne de commande. Parexemple, dans la section 1.2.5 nous lancerons un serveur web local en mode développement comme suit : $ rails server
  20. 20. 20 Comme pour linvite de la commande en ligne, ce Tutoriel Rails utilise la convention Unix pour les séparateurs de dossiers (cest-à-dire une balance /). Ma propre Application exemple développée dans ce tutoriel, par exemple, se trouve dans : /Users/mhartl/rails_projects/sample_app Sur Windows, ladresse du dossier analogue devrait être : C:Sitessample_app Le dossier racine pour toute application donnée est connue comme la racine Rails (Rails root), et désormais tous les chemins daccès seront relatifs à ce dossier (notez bien que la « racine Rails » nest pas le dossier racine du framework Rails lui-même). Par exemple, le dossier config de mon application exemple est : /Users/mhartl/rails_projects/sample_app/config La racine Rails est ici ce qui se trouve avant config, cest-à-dire : /Users/mhartl/rails_projects/sample_app Par souci de brièveté, quand nous ferons référence au fichier : /Users/mhartl/rails_projects/sample_app/config/routes.rb … nous omettrons la racine Rails et écrirons simplement config/routes.rb. Pour finir, ce Tutoriel Rails montre souvent les sorties (les résultats) de programmes variés (commandes shell, état de contrôle de version, programmes Ruby, etc.). À cause des innombrables petites différences entre les différents systèmes dexploitation, la sortie que vous obtiendrez ne coïncidera pas toujours avec ce qui sera montré dans le texte, mais il ny a aucune raison de sen pré-occuper. De surcroît, certaines commandes pourrons produire des erreurs en fonction de votre système ; plutôt que dessayer la tâche Sisyphéenne de documenter tous ces types derreurs dans ce tutoriel, je délèguerai cette tâche à lalgorithme « Google le message derreur », qui est, parmi dautres choses, une bonne pratique dans le développement grandeur nature de logiciel. 1.2 Debout et au boulot Le temps est venu daborder lenvironnement de développement Ruby on Rails et notre première application. Il y a quelques casse-têtes ici, spécialement si vous navez pas une expérience étendue de la programmation, donc ne vous découragez pas si cela vous demande un moment avant de pouvoir réellement démarrer. Ça ne vous
  21. 21. 21concerne pas en particulier ; tout développeur doit en passer par là (et souvent plus dune fois), mais soyezassuré que les efforts seront richement récompensés.1.2.1 Les environnements de développementEn prenant en compte la grande variété des personnalisations possibles, il existe au moins autantdenvironnements de développement que de programmeurs Rails, mais il se dégage tout de même deuxméthodes principales : les environnements à base déditeur de texte/ligne de commande, et les environnementsde développement intégrés (IDEs). Considérons dabord le second.IDEsLes IDEs Rails ne manquent pas, incluant RadRails, RubyMine, et 3rd Rail. Tous sont « cross-platform »(utilisables sur nimporte quel système. NdT), et jai entendu dire du bien de quelques uns dentre eux. Je vousencourage à les essayer sils fonctionnent pour vous, mais jai une confession à vous faire : je nai jamais trouvéun IDE qui me permette de satisfaire tous mes besoins en matière de développement Rails — et pour certainsprojets je nai pas même été capable de les faire fonctionner.Éditeurs de texte et ligne de commandeQue devons-nous utiliser alors pour remplacer ces IDE tout-en-un ? Je parierai que la majorité desdéveloppeurs Rails ont opté pour la même solution que moi : utiliser un éditeur de texte pour éditer le texte, etune ligne de commande pour exécuter des commandes (Illustration 1.1). La combinaison que vous utiliserezdépendra de vos goûts et de votre plate-forme : • Macintosh OS X : comme beaucoup de développeurs Rails, jai une préférence pour TextMate. Dautres options incluent Emacs et MacVim (chargé par la commande mvim), lexcellente version Macintosh de Vim.6 Jutilise iTerm comme terminal de ligne de commande ; dautres affectionnent lapplication native « Terminal ». • Linux : vos options dédition sont à la base les mêmes que pour les OS X, à lexception de TextMate. Je recommande « graphical Vim » (gVim), gedit (avec le plugin GMate), ou Kate. En terme de ligne de commande, vous devez déjà être totalement équipés : toute distribution Linux est fournie avec une application terminal de ligne de commande (et même souvent plusieurs). • Windows : Certains éditeurs prometteurs sur Windows sont Vim, le E Text Editor, Komodo Edit, et Sublime Text. Pour les lignes de commande, je recommande dutiliser linvite fournie avec Rails Installer (Section 1.2.2.1).Si vous avez une connaissance de Vim, assurez-vous de puiser dans la florissante communauté des Vim-usingRails hackers. Attardez-vous spécialement sur les améliorations de rails.vim et le projet à tiroir NERD tree.
  22. 22. 22 Illustration 1.1: Un environnement de développement éditeur de texte/ligne de commande (TextMate/iTerm). Navigateurs internet Bien quon puisse choisir dans une large panoplie de navigateurs, la majorité des développeurs Rails font appel à Firefox, Safari ou Chrome pour développer leurs applications. Les copies décran dans ce tutoriel Rails proviennent en général de Firefox. Si vous utilisez Firefox, je vous suggère dutiliser ladd-on Firebug, qui vous permet de faire tout un tas de choses magiques, comment inspecter dynamiquement (ou même modifier) la structure HTML et les règles CSS de nimporte quelle page. Pour ceux qui nutilisent pas Firefox, Firebug Lite fonctionne avec la plupart des autres navigateurs, et Safari comme Chrome ont de façon native un outil dinspection des éléments accessible en cliquant-droit sur nimporte quelle partie de la page. Quel que soit le navigateur utilisé, lexpérience démontre que le temps passé à apprendre à se servir dun outil dinspection est rapidement et richement récompensé. Une note à propos des outils En vous appliquant à rendre votre environnement de développement opérationnel, vous constaterez peut-être que vous dépensez beaucoup de temps à faire en sorte que les choses, simplement, fonctionnent. Le processus dapprentissage des éditeurs et des IDEs est particulièrement long ; vous pourrez passer des semaines sur des tutoriels TextMate ou Vim. Si ce jeu est tout nouveau pour vous, je tiens à vous assurer que passer du temps à apprendre à connaître ses outils est normal. Tout le monde y passe. Parfois cela est frustrant, et il est facile de perdre patience quand vous avez en tête le projet dune magnifique application web et que vous voulez juste apprendre Rails tout de suite, mais que vous avez à « perdre » une semaine sur un ancien et bizarre éditeur de texte Unix pour pouvoir ne faire que commencer. Mais un artisan se doit de connaître ses outils ; au bout du compte, soyez certain que le jeu en vaut la chandelle.
  23. 23. 231.2.2 Ruby, RubyGems, Rails, et GitMaintenant, il est temps dinstaller Ruby et Rails. La source canonique et actualisée est la page detéléchargement de Ruby on Rails. Vous pouvez y aller dès à présent ; les parties de ce livre peuvent être luesavec profit sans être connecté à par celle-ci. Car je vais injecter certains commentaires personnels sur cetteétape.Installeur Rails (Windows)Linstallation de Rails sur Windows était auparavant une calamité, mais grâce aux efforts de bonnes personnesà Engine Yard — spécialement Dr. Nic Williams et Wayne E. Seguin — linstallation de Rails et des logicielsafférents sur Windows est maintenant incroyablement facilitée. Si vous êtes sous Windows, allez au RailsInstaller (http://railsinstaller.org/) et téléchargez lexécutable Rails Installer. Double-cliquez lexécutable etsuivez les instructions dinstallation pour installer Git (vous pourrez donc passer la section 1.2.2.2), Ruby(passer la section 1.2.2.3), RubyGems (passez la section 1.2.2.4), et Rails lui-même (passez la section 1.2.2.5).Une fois linstallation terminée, vous pouvez directement passer à la création de la première application à lasection 1.2.3.Installation de GitLe plus gros de lécosystème Rails repose dune manière ou dune autre sur un système de contrôle de versionappelé Git (couvert plus en détail dans la section 1.3). Puisque son usage est omniprésent, vous devriez installerGit même à ce point de départ ; je vous suggère de suivre les instructions dinstallation propres à votre plate-forme que vous trouverez à cette adresse : Installing Git section of Pro Git.Installer RubyLétape suivante consiste à installer Ruby. Il est possible que votre système le possède déjà ; essayez dexécuterla commande… $ ruby -v ruby 1.9.2… pour voir le numéro de version de votre Ruby. Rails 3 requiert Ruby 1.8.7 ou plus récent et fonctionne mieuxavec Ruby 1.9.2. Ce tutoriel pré-suppose que vous utilisez la dernière version de développent de Ruby 1.9.2,connu sous le nom Ruby 1.9.2-head, mais Ruby 1.8.7 devrait fonctionner tout aussi bien.La branche Ruby 1.9 est en développement lourd, donc malheureusement installer la dernière version de Rubypeut relever du challenge. Vous devrez compter alors sur les instructions les plus actualisées quon trouve en
  24. 24. 24 ligne. Ce qui suit est une série détapes que jai exécutées pour le fonctionnement sur mon système (Macintosh OS X), mais vous aurez peut-être à chercher à droite et à gauche pour quelles fonctionnent sur le vôtre. Dans le cadre de linstallation de Ruby, si vous utilisez OS X ou Linux je recommande fortement linstallation de Ruby en utilisant le Ruby Version Manager (RVM), qui vous permet dinstaller et gérer plusieurs versions de Ruby sur la même machine (le projet Pik accomplit la même chose sous Windows). Cela est particulièrement important si vous voulez faire tourner Rails 3 et Rails 2.3 sur le même ordinateur. Si vous voulez emprunter cette voie, je vous suggère lutilisation de RVM pour installer deux combinaisons Ruby/Rails : Ruby 1.8.7/Rails 2.3.10 et Ruby 1.9.2/Rails 3.0.5. Si vous rencontrez le moindre problème avec RVM, vous pouvez souvent trouver son créateur, Wayne E. Seguin, sur le canal IRC de RVM (#rvm on freenode.net).7 Après linstallation de RVM, vous pouvez installer Ruby de cette manière :8 $ rvm get head $ rvm reload $ rvm install 1.8.7 $ rvm install 1.9.2 <attendez un moment> Les deux premières commandes actualisent et rechargent RVM lui-même, ce qui constitue une bonne pratique puisque RVM est fréquemment actualisé. Les deux commandes finales procèdent à linstallation de Ruby ; en fonction de votre système, cela peut prendre plus ou moins de temps pour télécharger et compiler les sources, donc ne vous inquiétez pas si ça vous semble une éternité (soyez également informé que beaucoup de peites choses peuvent aller de travers. Par exemple, sur mon système la dernière version de Ruby 1.8.7 ne voudra pas se compiler ; après bien des recherches et des lamentations, jai découvert que javais besoin du « patchlevel » numéro 174 : $ rvm install 1.8.7-p174 Quand de telles choses surviennent, cest toujours très frustrant (Oh que oui ! NdT), mais au moins, vous saurez que ça narrive pas quà vous. Typiquement, les programmes Ruby sont distribués via des gems, qui sont des packages autonomes de code Ruby. Puisque des gems avec des numéros de versions différents peuvent parfois entrer en conflit, il est souvent pratique de créer des gemsets séparés, qui sont des faisceaux (bundles) autonomes de gems. En particulier, Rails est distribué comme un gem, et il y a des conflits entre Rails 2 et Rails 3, donc si vous voulez lancer plusieurs versions de Rails sur le même système vous aurez besoin de créer une gemset différent pour chacune delle :
  25. 25. 25 $ rvm --create 1.8.7-p174@rails2tutorial $ rvm --create use 1.9.2@rails3tutorialLa première commande crée le gemset rails2tutorial associé à Ruby 1.8.7-p174, tandis que la secondecommande crée le gemset rails3tutorial associé à Ruby 1.9.2 et lutilise (via la commande use) en mêmetemps. RVM supporte une large variété de commandes pour manipuler les gemsets ; voyez la documentation àladresse http://rvm.beginrescueend.com/gemsets/.Dans ce tutoriel, nous voulons que notre système utilise Ruby 1.9.2 et Rails 3.0 par défaut, ce que nous pouvonsdéfinir comme suit : $ rvm --default use 1.9.2@rails3tutorialCela définit simultanéement la version de Ruby par défaut à la version 1.9.2 et le gemset par défaut àrails3tutorial.En passant, si vous vous retrouvez coincé avec RVM, exécuter des commandes telles que les suivantes devraientvous permettre de retrouver toutes vos facultés : $ rvm --help $ rvm gemset --helpInstallation de RubyGemsRubyGems est un gestionnaire de packages pour les projets Ruby, et il y a légion dexcellentes librairies (Railsinclus) accessibles comme packages Ruby, ou comme gems. Linstallation de RubyGems devrait être facile unefois Ruby installé. En fait, si vous avez installé RVM, vous avez déjà RubyGems, puisque RVM linclutautomatiquement : $ which gem /Users/mhartl/.rvm/rubies/ruby-head/bin/gemSi vous ne lavez pas encore, vous devez télécharger RubyGems, lextraire, puis aller dans le dossier rubygemspour lancer le programme dinstallation : $ [sudo] ruby setup.rbSi RubyGems est déjà installé, vous pouvez vouloir actualiser votre système avec la dernière version :
  26. 26. 26 $ [sudo] gem update --system Pour finir, si vous utilisez Ubuntu Linux, vous devriez jeter un coup dœil à the Ubuntu/Rails 3.0 blog post by Toran Billups pour des instructions complètes sur linstallation. Installer Rails Une fois RubyGems installé, linstallation de Rails 3.0 devrait être un jeu denfant : $ [sudo] gem install rails --version 3.0.5 Pour vérifier si tout a fonctionné, exécutez la commande suivante : $ rails -v Rails 3.0.5 1.2.3 La première application Grosso-modo, toutes les applications Rails commencent de la même manière, par une commande rails. Ce programme pratique crée un squelette de lapplication Rails dans le dossier de votre choix. Pour commencer, faite un dossier pour votre projet Rails et exécutez la commande rails pour créer la première application : Illustration 1.1. Exécution du script rails pour générer une nouvelle application web. $ mkdir rails_projects $ cd rails_projects $ rails new first_app create create README create .gitignore create Rakefile create config.ru create Gemfile create app create app/controllers/application_controller.rb create app/helpers/application_helper.rb create app/views/layouts/application.html.erb create app/models create config create config/routes.rb
  27. 27. 27 create config/application.rb create config/environment.rb . Remarquez le nombre de fichiers et de dossier que la commande rails crée. Cette structure stantard de dossiers et de fichiers (Illustration 1.2) est lun des nombreux avantages de Rails ; cela vous propulse directement de zéro à une application fonctionnelle (bien que minimale). Plus encore, puisque la structure est commune à toutes les applications Rails, vous pouvez immédiatement prendre vos repères en regardant le code de quelquun dautre. Un résumé des fichiers Rails par défaut apparait dans la table 1.1 ; nous en apprendrons plus sur la plupart de ces fichiers tout au long de ce livre. Illustration 1.2: La structure du dossier pour une toute nouvelle application Rails. Fichier/Dossier Objet Cœur du code de lapplication (app), incluant des modèles (models), des vues (views), des contrôleurs (controllers), etapp/ des « assistants » (helpers)
  28. 28. 28 config/ Configuration de lapplication db/ Fichiers pour manipuler la base de données doc/ Documentation pour lapplication lib/ Modules libraries log/ Journaux (logs) de lapplication public/ Données publiques (p.e., accessibles aux navigateurs web), telles que les images et les feuilles de styles (CSS) script/rails Un script fourni par Rails pour générer du code, ouvrir les sessions console, ou démarrer une serveur web local test/ Tests de lapplication (rendu obsolète par le dossier spec/ introduit à la section 3.1.2) tmp/ Fichiers temporaires vendor/ Codes Tierce-partie tels que les plugins et les gems README Une brève description de lapplication Rakefile Tâches utiles accessibles par le biais de la commande rake Gemfile Les Gems requis par lapplication config.ru Un fichier de configuration pour Rack middleware .gitignore Les patterns pour les fichiers qui doivent être ignorés par Git Table 1.1: Résumé de la structure par défaut dun dossier Rails. 1.2.4 Bundler Après avoir créé une nouvelle application Rails, on utilise Bundler pour installer et inclure les gems utiles à lapplication. Cela consiste à ouvrir le fichier Gemfile avec votre éditeur de texte favori : $ cd first_app/ $ mate Gemfile Le résultat devrait ressembler à lillustration 1.2. Illustration 1.2. Le fichier Gemfile par défaut dans le dossier first_app. source http://rubygems.org gem rails, 3.0.5
  29. 29. 29 # Bundle edge Rails instead: # gem rails, :git => git://github.com/rails/rails.git gem sqlite3-ruby, :require => sqlite3 # Utilser unicorn comme serveur web # gem unicorn # Déployer lapplication avec Capistrano # gem capistrano # Le déboggueur # gem ruby-debug # Bundle les gems supplémentaires : # gem bj # gem nokogiri, 1.4.1 # gem sqlite3-ruby, :require => sqlite3 # gem aws-s3, :require => aws/s3 # Bundle ces gems pour certains environements: # gem rspec, :group => :test # group :test do # gem webrat # endLa plupart de ces lignes sont commentés par le symbole dièse (#) ; elles sont là pour vous montrer certains desgems les plus communs et donner des exemples de la syntaxe Bundler. Pour le moment, nous naurons besoindaucun gem autres que ceux par défaut : Rails lui-même, et le gem pour linterface Ruby pour la base dedonnées SQLite.Même si vous spécifiez un numéro de version pour la commande gem, Bundler installera toujoursautomatiquement la dernière version. Malheureusement, les actualisations des gems causent souvent desruptures mineures mais potentiellement perturbantes, donc dans ce tutoriel nous ajouterons en général unnuméro de version explicite connu, comme le montre lillustration 1.3.9 Illustration 1.3. Un fichier Gemfile avec un numéro de version du gem sqlite3-ruby explicite.
  30. 30. 30 source http://rubygems.org gem rails, 3.0.5 gem sqlite3-ruby, 1.3.2, :require => sqlite3 Cela change la ligne : gem sqlite3-ruby, :require => sqlite3 … de lextrait 1.2 en : gem sqlite3-ruby, 1.3.2, :require => sqlite3 … qui force Bundler à installer la version 1.3.2 du gem sqlite3-ruby (notez que vous aurez besoin de la version 1.2.5 du gem sqlite3-ruby si vous tournez sous OS X Leopard, comme 1.3.2 a besoin de Snow Leopard pour se compiler proprement). Si vous êtes sous Ubuntu Linux, vous pouvez devoir installer une paire dautre packages à ce point du tutoriel :10 $ sudo apt-get install libxslt-dev libxml2-dev libsqlite3-dev # pour Linux Une fois que vous avec assemblé correctement votre Gemfile, installez les gems en utilisant la commande bundle install :11 $ bundle install Fetching source index for http://rubygems.org/ . . Cela peut prendre un certain temps, mais une fois fait, notre application sera prête à démarrer. 1.2.5 rails server Grâce à lexécution de rails new à la section 1.2.3 et bundle install à la section 1.2.4, nous avons déjà une application que nous pouvons lancer — mais comment ? Heureusement, Rails est fourni avec un programme de commande en ligne, ou script, qui lance un serveur web local,12 visible seulement depuis votre machine de développement :13
  31. 31. 31 $ rails server => Booting WEBrick => Rails 3.0.5 application starting on http://0.0.0.0:3000 => Call with -d to detach => Ctrl-C to shutdown serverCe code nous dit que lapplication est lancée sur le port 300014 à ladresse 0.0.0.0. Cette adresse dit àlordinateur découter toutes les adresses IP accessibles et configurées sur la machine spécifiques ; enparticulier, nous pouvons voir lapplication en utilisant ladresse spéciale 127.0.0.1, connue aussi sous laforme localhost. Nous pouvons voir le résultat en visitant ladresse http://localhost:3000/de lillustration 1.3.15 Illustration 1.3: La page Rails par défaut (http://localhost:3000/).Pour voir les informations sur notre première application, cliquez sur le lien « About your applicationsenvironment ». Le résultat est montré dans lillustration 1.4.16
  32. 32. 32 Illustration 1.4: La page par défaut (http://localhost:3000/) avec lenvironnement de lapplication. Bien sûr, nous navons pas besoin de la page par défaut de Rails très longtemps, mais il est sympa de voir quelle fonctionne pour le moment. Nous détruirons la page par défaut et la remplacerons par une page daccueil personnalisée à la section 5.2.2. 1.2.6 Modèle-Vue-Contrôleur (MVC) Même à cette étape précoce, il est utile davoir un aperçu de haut-niveau de comment fonctionne les applications Rails (Illustration 1.5). Vous pouvez avoir noté que la structure standard dune application Rails (Illustration 1.2) possède un dossier appelé app/ contenant trois sous-dossiers : models (Modèles), views (Vues), and controllers (Contrôleurs). Cest lindice que Rails suit le modèle architectural Modèle-Vue- Contrôleur (Model-View-Controls ou MVC), qui force une séparation entre la « logique domaine » (appelée aussi « logique métier ») et les entrées, et la logique de présentation associée à une interface utilisateur graphique (Graphical User Interface ou GUI). Dans le cas des applications web, la « logique domaine » consiste typiquement en modèles de données pour des choses telles que les utilisateurs, les articles et les produits, et le GUI est juste une page web dans un navigateur web. En interagissant avec une application Rails, un navigateur envoie une requête, qui est reçue par un serveur web et passée à un contrôleur Rails, qui lui-même prend en charge la suite des opérations. Dans certains cas, le contrôleur rendra immédiatement une vue, qui est un modèle converti en HTML et renvoyé au navigateur. De façon plus classique pour les sites dynamiques, le contrôleur interagit avec le modèle, qui est un objet Ruby qui
  33. 33. 33représente un élément du site (tel quun utilisateur) et est en charge de la communication avec la base dedonnées. Après linvocation du modèle, le contrôleur produit alors une vue et retourne la page web achevée aunavigateur sous forme de code HTML. Illustration 1.5: Une représentation schématique de larchitecture modèle-vue-contrôleur (MVC).Si cette discussion vous semble un peu trop abstraite pour le moment, ne vous inquiétez pas ; nous y feronsfréquemment référence. Addionnellement, la section 2.2.2 contient une discussion plus détaillée sur le MVCdans le contexte de lApplication démo. Pour finir, lApplication exemple utilisera tous les aspects du MVC ;nous couvrirons le problème des contrôleurs et des vues en abordant la section 3.1.2, les modèles en abordant lasection 6.1, et nous verrons comment les trois fonctionnent ensemble dans la section 6.3.2.1.3 Contrôle de version avec GitMaintenant que nous avons une application Rails fraiche et fonctionnelle, nous allons prendre le temps pourune étape qui, bien que techniquement optionnelle, est considérée par de nombreux développeurs Rails commepratiquement essentielle, à savoir placer le code source de votre application sous contrôle de version. Lessystèmes de contrôle de version nous permettent de procéder à des modifications du code de notre projet, decollaborer plus aisément avec dautres développeurs, et de revenir en arrière en cas derreur (comme lasuppression accidentelle de fichiers). Savoir utiliser un système de contrôle de version est une compétence quedoit acquérir tout développeur.
  34. 34. 34 Il y a beaucoup doptions pour le contrôle de version, mais la communauté Rails a largement opté pour Git, un système de contrôle de version originellement développé par Linus Torvalds pour accueillir le kernel Linux. Git est un vaste sujet, et nous ne ferons que leffleurer dans ce livre, mais vous trouverez de nombreuses bonnes ressources sur le web ; je recommande spécialement Pro Git de Scott Chacon (Apress, 2009). Mettre votre code source sous contrôle de version avec Git est chaudement recommandé, pas seulement parce que cest une pratique universelle dans le monde de Rails, mais aussi parce que cela vous permettra de partager votre code plus facilement (Section 1.3.4) et déployer votre application dès le premier chapitre (Section 1.4). 1.3.1 Installation et réglages La première chose à faire est dinstaller Git si vous navez pas suivi les étapes de la section 1.2.2.2 (comme indiqué dans la section, cela implique davoir suivi les instructions de la Section « Installation de Git » de Pro Git (Installing Git section of Pro Git).) Initialisation des réglages du système Après avoir installé Git, vous devez effectuer une initialisation des réglages. Ce sont des réglages système, ce qui signifie que vous navez à les faire quune fois par ordinateur : $ git config --global user.name "Votre Nom" $ git config --global user.email youremail@example.com Jaime aussi utiliser co au lieu de la commande verbeuse checkout, ce que nous pouvons arranger comme suit : $ git config --global alias.co checkout Ce tutoriel utilisera souvent la commande complète checkout qui fonctionne pour les systèmes qui nont pas configuré ce co, mais dans la vie réelle jutilise presque toujours git co pour contrôler la sortie dun projet. En dernier réglage, vous pouvez optionnellement définir léditeur que Git utilisera pour les messages commits. Si vous utilisez un éditeur graphique comme TextMate, gVim ou MacVim, vous aurez besoin dutiliser un drapeau (flag) pour vous assurer que léditeur reste attaché à la shell au lieu de se détacher automatiquement :17 $ git config --global core.editor "mate -w" Remplacez "mate -w" par "gvim -f" pour gVim ou "mvim -f" pour MacVim.

×