The Ring programming language version 1.7 book - Part 1 of 196
Tutoriel Ruby on Rails : apprendre Rails par l'exemple de Michael Hartl
1. 1
Tutoriel Ruby on Rails
Apprendre Rails par l'exemple
Michael Hartl
Contenu
chapitre 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
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 Qu'est-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 l'application .....................................................................................................................50
2.1.1 Modéliser les utilisateurs ........................................................................................................52
2.1.2 Modéliser les micro-messages ................................................................................................52
3. 3
2.2 La ressouce Utilisateur (Users) ......................................................................................................53
2.2.1 Un tour de l'utilisateur.............................................................................................................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 l'application Démo ..................................................................................................76
2.4 Conclusion .....................................................................................................................................76
Chapitre 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 d'instance et Ruby embarqué ................................................................................114
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 à l'helper 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 d'origine .......................................................................................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.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 d'intégration ...........................................................................................................178
5.2.2 Routes Rails....................................................................................................................181
5.2.3 Routes nommées............................................................................................................184
5.3 Inscription de l'utilisateur : une première étape ..............................................................186
5.3.1 Contrôleur des utilisateurs (Users ) ............................................................................186
5.3.2 URL de l'inscription ......................................................................................................189
5.4 Conclusion .............................................................................................................................191
5.5 Exercises.................................................................................................................................192
Chapitre 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 l'utilisateur...................................................................................................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 d'unicité .......................................................................................................222
6.3 Affichage des utilisateurs.....................................................................................................226
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 l'Active 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 d'authentification..................................................................................254
7.3 Meilleures vues d'utilisateurs..............................................................................................259
7.3.1 Tester la page d'affichage de l'utilisateur (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 d'inscription ......................................................................................................277
8.1.1 Utiliser form_for .........................................................................................................279
7. 7
8.1.2 Le formulaire HTML .....................................................................................................282
8.2 Échec de l'inscription ...........................................................................................................285
8.2.1 Tester l'échec ..................................................................................................................286
8.2.2 Un formulaire fonctionnel ...........................................................................................288
8.2.3 Message d'erreur à l'inscription ..................................................................................291
8.2.4 Filtrer les paramètres d'identification........................................................................296
8.3 Réussite de l'inscription.......................................................................................................298
8.3.1 Tester la réussite ............................................................................................................299
8.3.2 Le formulaire d'inscription final .................................................................................300
8.3.3 Le message « flash »......................................................................................................301
8.3.4 La première inscription ................................................................................................305
8.4 Les tests d'intégration RSpec ..............................................................................................306
8.4.1 Tests d'intégration sur les styles ..................................................................................307
8.4.2 Un échec d'inscription ne devrait pas créer un nouvel utilisateur.........................308
8.4.3 Le succès d'une inscription devrait créer un nouvel utilisateur .............................311
8.5 Conclusion .............................................................................................................................313
8.6 Exercises ................................................................................................................................314
Chapitre 9 Connexion, déconnexion ......................................................................................................316
9.1 Les sessions ............................................................................................................................316
9.1.1 Contrôleur Sessions........................................................................................................317
9.1.2 Formulaire d'identification...........................................................................................319
9.2 Échec de l'identification.......................................................................................................322
9.2.1 Examen de la soumission du formulaire ....................................................................323
9.2.2 Échec de l'identification (test et code)........................................................................325
9.3 Réussite de l'identification ..................................................................................................328
9.3.1 L'action create achevée..............................................................................................329
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 à l'inscription .............................................................................................347
9.4.3 Changement des liens de la mise en page ..................................................................348
9.4.4 Test d'intégration pour l'identification 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 L'identification requise de l'utilisateur .....................................................................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 L'action destroy (détruire) .....................................................................................395
10.5 Conclusion............................................................................................................................400
9. 9
10.6 Exercices...............................................................................................................................401
chapitre 11 Micro-messages d'utilisateur...............................................................................................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 l'utilisateur ........................................................................418
11.2.2 Exemples de micro-messages.....................................................................................425
11.3 Manipuler les micro-messages ..........................................................................................428
11.3.1 Contrôle d'accè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 d'accueil ..............................................................................449
11.4 Conclusion ............................................................................................................................450
11.5 Exercices ...............................................................................................................................451
Chapitre 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
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 l'alimentation.......................................................................................................498
12.3.1 Motivation et stratégie.................................................................................................499
12.3.2 Une première implémentation de l'alimentation....................................................502
12.3.3 Champs d'application, sous-sélections et lambda ..................................................504
12.3.4 Le nouvel état de l'alimentation ................................................................................509
12.4 Conclusion............................................................................................................................510
12.4.1 Extensions de l'Application Exemple ........................................................................511
12.4.2 Guide vers d'autres 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 m'a
tellement recommandé ce livre Michael Hartl que je n'ai pu faire autrement que de le lire. C'est ainsi que le
Tutoriel Ruby on Rails m'a fait revenir à nouveau à Rails.
Bien qu'ayant parcouru de nombreux livres sur Rails, c'est ce tutoriel-là qui m'a véritablement « mis en
possession » de Rails. Tout est fait ici « à la manière de Rails » — une manière qui ne m'avait jamais semblé
naturelle avant que je ne lise ce livre. C'est aussi le seul ouvrage sur Rails qui met en place, d'un bout à l'autre,
un Développement Dirigé par les Tests (Test-Driven Development), une approche que je savais hautement
recommandée par les experts mais dont je n'avais jamais compris aussi bien la pertinence que dans ce livre.
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
chapitre 1 De zéro au déploiement
Bienvenue dans Le Tutoriel Ruby on Rails : Apprendre Rails par l'exemple. Le but de ce livre est d'être la
meilleure 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 connaissances
nécessaires pour développer et déployer votre propre application web. Vous serez également en mesure de tirer
profit 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 pleinement
d'actualité avec la dernière et meilleure version de Rails.1
Le Tutoriel Ruby on Rails suit essentiellement la même approche que mon livre précédent,2 enseignant le
développement web avec Rails en construisant un exemple d'application conséquente, depuis le tout départ.
Comme Derek Sivers le souligne dans l'avant-propos, ce livre est structuré en narration linéaire, destinée en
conséquence à être lue du début à la fin. Si vous avez l'habitude de survoler les livres techniques, suivre cette
approche linéaire peut vous demander quelques ajustements, mais je ne saurais trop vous recommander
d'essayer. 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 et
en préparant votre environnement de développement (section 1.2). Nous créerons alors notre première
application Rails, appelée (de façon assez pertinente ma foi) first_app (première_application). Le
Tutoriel Rails met l'accent 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 d'illustrer les fonctions élémentaires d'une
application Rails. De façon très rapide, nous construirons cette application démo (qui s'appellera
demo_app) en utilisant le système d'échaffaudage (« scaffolding ») (Box 1.1) pour générer
automatiquement le code ; comme ce code est aussi laid que complexe, le chapitre 2 se concentrera plutôt sur
l'interaction avec l'application 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 écrivant
cette fois tout le code à partir de (presque) rien. Nous développerons cette application exemple en utilisant le
Test Dirigé par le Développement (« test-driven development », TDD), amorcé au chapitre 3 en créant des
pages statiques puis en ajoutant un peu de contenu dynamique. Nous ferons un rapide détour au chapitre 4
pour en apprendre un peu plus sur le langage Ruby sous-jacent à Rails. Puis, du chapitre 5 au chapitre 10, nous
complèterons les fondations de l'application exemple en fabricant un layout (une mise en page) pour le site, un
14. 14
modèle de données utilisateur (« user data model ») et un système complet et fonctionnel d'enregistrement et
d'authentification. 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.
L'application exemple finale aura plus d'une 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, l'accent 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é d'un 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 d'adresse de quinze minutes en utilisant l'outil 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 s'appuyer sur l'approche par échaffaudage — elle est
plus rapide, plus facile, et plus séduisante. Mais la complexité et l'énorme quantité de code d'un échaffaudage
peut être rédhibitoire pour un développeur Rails débutant ; vous pouvez peut-être l'utiliser, mais vous serez
incapable de le comprendre. Suivre l'approche par échaffaudage risque de vous tourner vers un script
générateur de code virtuose au détriment d'une véritable connaissance de Rails.
Dans le Tutoriel Ruby on Rails, nous adopterons l'approche 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 l'Application 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. L'effet 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 n'importe quel type d'application 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
éventail d'applications, depuis la start-up bagarreuse jusqu'aux énormes compagnies : Posterous,
UserVoice, 37signals, Shopify, Scribd, Twitter, Hulu, the Yellow Pages (les Pages Jaunes) — la liste des sites
utilisant Rails s'allongent de jour en jour. Il y a aussi de nombreux producteurs de développements web qui se
spécialisent en Rails, tels que ENTP, thoughtbot, Pivotal Labs ou Hashrocket, sans compter les innombrables
consultants indépendants, entraineurs et entrepreneurs.
Qu'est-ce qui rend Rails si fantastique ? Tout d'abord, Ruby on Rails est 100% en « open-source », accessible
sous la licence MIT License, e qui signifie qu'il ne coûte rien de le télécharger et de l'utiliser. 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 des
applications web. Il en résulte que de nombreuse tâches courantes de programmation web — telles que générer
du code HTML, faire des modèles de données ou rediriger les URLs — deviennent faciles avec Rails, et le code
de l'application produit est concis et lisible.
Rails s'adapte également avec rapidité aux développements les plus récents de la technologie internet et à la
conception par framework. Rails a par exemple été l'un des premiers frameworks à digérer et implémenter en
totalité l'architecture de style REST pour structurer les applications web (ce que nous apprendrons à faire au
cours de ce tutoriel). Et quand d'autres framewords développent avec succès de nouvelles technologies, le
créateur de Rails, David Heinemeier Hansson ainsi que le cœur de l'équipe Rails n'hésite jamais à incorporer à
Rails leurs nouvelles idées. Peut-être l'exemple le plus parlant est la fusion de Rails et de Merb, un framework
concurrent, de telle sorte que Rails bénéficie maintenant de la conception modulaire de Merb, API stable et aux
performances améliorées. Quiconque a assisté à la conférence donnée par le développeur de Merb et le noyau
dur de l'équipe Yehuda Katz n'a pu faire autrement que de noter à quel point ce fut une extrêmement bonne
idée de monter l'équipe de Merb à bord.
Enfin, Rails bénéficie d'une communauté exceptionnellement enthousiaste et diverse. Les résultats en sont des
centaines de contributeurs open-source, des conférences largement suivies, un nombre considérable de plugins
et des gems (solutions clé-en-main pour des problèmes spécifiques comme la pagination ou le téléchargement
d'images), une riche variété de blogs d'information, et une corne d'abandonce débordant de forums de
discussions et de canaux de discussion IRC. Le grand nombre de développeurs Rails rend également plus facile
la résolution des erreurs inévitables de toute l'application : l'algorithme « Googlelisez votre message d'erreur »
renvoie pratiquement toujours vers le message pertinent d'un blog ou un sujet de discussion dans un forum.
1.1.1 Commentaires pour la grande variété de lecteurs
Le 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
mesure d'utiliser 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 d'un 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 n'est pas destiné à expliquer cette magie — principalement parce que la plupart des développeurs
d'applications Rails n'ont 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 n'avez 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 n'avez même jamais utilisé d'éditeur de texte, ce ne sera pas facile pour
vous d'avancer, mais avec un peu de détermination vous devriez pouvoir passer à travers. Si, d'un autre côté,
votre fichier .emacs est tellement complexe qu'il 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 l'expé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 s'il 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. D'un autre côté, de nombreux développeurs Rails
débutants sont excités à l'idé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 n'est 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 à l'aise.
Vous pouvez aussi vous contenter d'un goût de ce qu'est Ruby en suivant un court tutoriel en ligne, tels que ceux
qu'on peut trouver sur les sites http://www.ruby-lang.org/ ou http://rubylearning.com/.
Une autre question classique concerne l'utilisation des tests dès le départ. Comme cela est indiqué dans
l'introduction, 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 l'inclusion 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, n'hésitez
pas à les passer. Bien que j'ai inclus seulement le matériel que je considère essentiel au développement d'un
17. 17
niveau professionnel d'une application Rails, seul le cœur du code de l'application est strictement
nécessaire dans une première lecture.
Aux programmeurs non expérimentés (non-concepteurs) : ce Tutoriel Rails n'exige aucun autre
background qu'une connaissance générale de l'ordinateur, donc si vous avez une expérience limitée de la
programmation ce livre est une bonne façon de commencer. Gardez à l'esprit que c'est seulement la première
étape d'un long voyage ; le développement web possède de nombreux aspects différents, parmi lesquels le
HTML/CSS, JavaScript, les bases de données (et SQL), les contrôles de version et le déploiement. Ce livre
contient 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 web
vous donnent une longueur d'avance, puisque vous connaissez certainement déjà le HTML et les CSS. Après
avoir fini ce livre, vous serez dans une excellente position pour travailler sur des projets Rails existants et
pourrez probablement en amorcer un de votre propre chef. Vous pouvez trouver difficile tout ce qui concerne la
programmation, mais le langage Ruby est exceptionnellement accessible aux débutants, tout spécialement ceux
qui possèdent une fibre artistique.
Après avoir achevé la lecture du Tutoriel Ruby on Rails, je recommande aux nouveaux programmeurs la lecture
de Beginning Ruby de Peter Cooper, qui partage la même philosophie pédagogique que ce Tutoriel Rails. Je
recommande aussi The Ruby Way de Hal Fulton. Enfin, pour acquérir une compréhension plus profonde de
Rails 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, c'est
peut-être que vous n'êtes pas tout à fait prêts encore à développer des applications web. Dans ce cas, je vous
suggère d'apprendre les bases du HTML et des CSS et de recommencer ensuite seulement la lecture de ce
tutoriel (malheureusement, je n'ai 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 l'exemple d'une
application plus petite qu'une application web au sens fort du terme.
Aux programmeurs expérimentés découvrant le développement web : votre expérience signifie que
vous comprenez probablement déjà les concepts de classes, de méthodes, de structures de données, etc., ce qui
constitue un sérieux avantage. Soyez tout de même avertis, dans le cas où votre background est le C/C++ ou le
Java, que vous pourriez trouver que le langage Ruby ressemble un peu à un canard boiteux, et sa prise en main
pourrait vous prendre du temps ; familiarisez-vous juste avec lui, et tout devrait aller pour le mieux (Ruby vous
autorise même à mettre des points-virgule à la fin des lignes s'ils vous manquent trop !). Ce Tutoriel Rails
couvre toutes les idées spécifiques au développement web dont vous avez besoin, donc ne vous inquiétez pas si
vous ne distinguez pas pour le moment une requête PUT d'une requête POST.
Aux développeurs web expérimentés découvrant Rails : vous avez une sérieuse longueur d'avance, tout
spécialement si vous avez utilisé un langage dynamique tel que le PHP ou (encore mieux) le langage Python. Les
bases 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
l'architecture 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 : l'ensemble 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 d'autres 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 d'autres choses, les techniques employées ici sont peut-être plus
d'actualité 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 m'ont exprimé leur surprise quant à la quantité de choses qu'ils avaient
tirés de ce livre, et vous pourriez être ravis d'aborder 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 d'où vous partiez, vous serez en mesure d'appréhender les ressources
Rails plus avancées. Voilà celle que je recommande particulièrement :
• Railscasts : d'excellents screencats gratuits sur Rails ;
• PeepCode, Pragmatic.tv, EnvyCasts : d'excellent screencasters payants ;
• Rails Guides : bonnes références sur Rails, d'actualité 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 l'introduction, j'aimerais m'arrê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, n'est qu'un framework. Donc la vraie
question aurait dû être « Est-ce qu'un 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 d'application 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 s'expliquent la plupart du temps d'elles-mêmes ; dans cette section, je mentionne
celles qui ne le pourraient pas.
19. 19
Les é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).5
De nombreux exemples de ce livre utilisent la « ligne de commande ». Pour la simplicité, tous les exemples en
ligne de commande utilisent l'invite classique Unix (un dollar), comme suit :
$ echo "bonjour le monde"
bonjour le monde
Les utilisateurs Windows doivent savoir que leur système utilisera l'invite analogue « > » :
C:Sites>echo Salut le monde
Salut le monde
Sur les systèmes d'exploitation Unix, certaines commandes devront être exécutées avec sudo, qui signifie
« substitute user do » (L'utilisateur de substition fait…). Par défaut, une commande exécutée avec sudo est
jouée comme par un utilisateur-administrateur, qui a accès à des fichiers et des dossiers que les utilisateurs
normaux ne peuvent pas toucher. Pour indiquer que l'utilisation de sudo dépendra de votre système, elle se
présentera entre crochets quand elle peut être (ou ne pas être) nécessaire sur votre propre système, comme
dans l'exemple de la section 1.2.2:
$ [sudo] ruby setup.rb
La plupart des systèmes d'exploitation Unix/Linux/Os X requièrent la commande sudo par défaut, sauf si vous
utilisez le Ruby Version Manager comme cela est suggéré dans la section 1.2.2.3. Notez que vous ne devez pas
utiliser les crochets ; vous devez utiliser soit…
$ sudo ruby setup.rb
soit…
$ ruby setup.rb
… en fonction de votre système d'exploitation.
Rails est fourni avec un grand nombre de commandes qui peuvent être jouées en ligne de commande. Par
exemple, dans la section 1.2.5 nous lancerons un serveur web local en mode développement comme suit :
$ rails server
20. 20
Comme pour l'invite de la commande en ligne, ce Tutoriel Rails utilise la convention Unix pour les séparateurs de
dossiers (c'est-à-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, l'adresse 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 d'accès seront relatifs à ce dossier (notez bien que la « racine Rails » n'est 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, c'est-à-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 d'exploitation, la sortie que vous obtiendrez ne coïncidera pas toujours avec ce qui sera
montré dans le texte, mais il n'y a aucune raison de s'en pré-occuper. De surcroît, certaines commandes
pourrons produire des erreurs en fonction de votre système ; plutôt que d'essayer la tâche Sisyphéenne de
documenter tous ces types d'erreurs dans ce tutoriel, je délèguerai cette tâche à l'algorithme « Google le
message d'erreur », qui est, parmi d'autres choses, une bonne pratique dans le développement grandeur nature
de logiciel.
1.2 Debout et au boulot
Le temps est venu d'aborder l'environnement de développement Ruby on Rails et notre première application. Il
y a quelques casse-têtes ici, spécialement si vous n'avez 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
concerne pas en particulier ; tout développeur doit en passer par là (et souvent plus d'une fois), mais soyez
assuré que les efforts seront richement récompensés.
1.2.1 Les environnements de développement
En prenant en compte la grande variété des personnalisations possibles, il existe au moins autant
d'environnements de développement que de programmeurs Rails, mais il se dégage tout de même deux
méthodes principales : les environnements à base d'éditeur de texte/ligne de commande, et les environnements
de développement intégrés (IDEs). Considérons d'abord le second.
IDEs
Les IDEs Rails ne manquent pas, incluant RadRails, RubyMine, et 3rd Rail. Tous sont « cross-platform »
(utilisables sur n'importe quel système. NdT), et j'ai entendu dire du bien de quelques uns d'entre eux. Je vous
encourage à les essayer s'ils fonctionnent pour vous, mais j'ai une confession à vous faire : je n'ai jamais trouvé
un IDE qui me permette de satisfaire tous mes besoins en matière de développement Rails — et pour certains
projets je n'ai pas même été capable de les faire fonctionner.
Éditeurs de texte et ligne de commande
Que devons-nous utiliser alors pour remplacer ces IDE tout-en-un ? Je parierai que la majorité des
développeurs Rails ont opté pour la même solution que moi : utiliser un éditeur de texte pour éditer le texte, et
une ligne de commande pour exécuter des commandes (Illustration 1.1). La combinaison que vous utiliserez
dépendra de vos goûts et de votre plate-forme :
• Macintosh OS X : comme beaucoup de développeurs Rails, j'ai une préférence pour TextMate.
D'autres options incluent Emacs et MacVim (chargé par la commande mvim), l'excellente version
Macintosh de Vim.6 J'utilise iTerm comme terminal de ligne de commande ; d'autres affectionnent
l'application native « Terminal ».
• Linux : vos options d'édition sont à la base les mêmes que pour les OS X, à l'exception 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 d'utiliser l'invite 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-using
Rails hackers. Attardez-vous spécialement sur les améliorations de rails.vim et le projet à tiroir NERD tree.
22. 22
Illustration 1.1: Un environnement de développement éditeur de texte/ligne de commande (TextMate/iTerm).
Navigateurs internet
Bien qu'on 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 d'utiliser l'add-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 n'importe quelle page. Pour ceux qui n'utilisent pas Firefox, Firebug Lite
fonctionne avec la plupart des autres navigateurs, et Safari comme Chrome ont de façon native un outil
d'inspection des éléments accessible en cliquant-droit sur n'importe quelle partie de la page. Quel que soit le
navigateur utilisé, l'expérience démontre que le temps passé à apprendre à se servir d'un outil d'inspection 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
d'apprentissage 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 d'une 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
1.2.2 Ruby, RubyGems, Rails, et Git
Maintenant, il est temps d'installer Ruby et Rails. La source canonique et actualisée est la page de
téléchargement de Ruby on Rails. Vous pouvez y aller dès à présent ; les parties de ce livre peuvent être lues
avec profit sans être connecté à par celle-ci. Car je vais injecter certains commentaires personnels sur cette
étape.
Installeur Rails (Windows)
L'installation 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 — l'installation de Rails et des logiciels
afférents sur Windows est maintenant incroyablement facilitée. Si vous êtes sous Windows, allez au Rails
Installer (http://railsinstaller.org/) et téléchargez l'exécutable Rails Installer. Double-cliquez l'exécutable et
suivez les instructions d'installation 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 l'installation terminée, vous pouvez directement passer à la création de la première application à la
section 1.2.3.
Installation de Git
Le plus gros de l'écosystème Rails repose d'une manière ou d'une autre sur un système de contrôle de version
appelé Git (couvert plus en détail dans la section 1.3). Puisque son usage est omniprésent, vous devriez installer
Git même à ce point de départ ; je vous suggère de suivre les instructions d'installation propres à votre plate-
forme que vous trouverez à cette adresse : Installing Git section of Pro Git.
Installer Ruby
L'étape suivante consiste à installer Ruby. Il est possible que votre système le possède déjà ; essayez d'exécuter
la 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 mieux
avec 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 Ruby
peut relever du challenge. Vous devrez compter alors sur les instructions les plus actualisées qu'on trouve en
24. 24
ligne. Ce qui suit est une série d'étapes que j'ai exécutées pour le fonctionnement sur mon système (Macintosh
OS X), mais vous aurez peut-être à chercher à droite et à gauche pour qu'elles fonctionnent sur le vôtre.
Dans le cadre de l'installation de Ruby, si vous utilisez OS X ou Linux je recommande fortement l'installation de
Ruby en utilisant le Ruby Version Manager (RVM), qui vous permet d'installer 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 l'utilisation 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 l'installation 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 à l'installation 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, j'ai découvert que j'avais besoin du « patchlevel »
numéro 174 :
$ rvm install 1.8.7-p174
Quand de telles choses surviennent, c'est toujours très frustrant (Oh que oui ! NdT), mais au moins, vous saurez
que ça n'arrive 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
d'elle :
25. 25
$ rvm --create 1.8.7-p174@rails2tutorial
$ rvm --create use 1.9.2@rails3tutorial
La première commande crée le gemset rails2tutorial associé à Ruby 1.8.7-p174, tandis que la seconde
commande crée le gemset rails3tutorial associé à Ruby 1.9.2 et l'utilise (via la commande use) en même
temps. RVM supporte une large variété de commandes pour manipuler les gemsets ; voyez la documentation à
l'adresse 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 pouvons
définir comme suit :
$ rvm --default use 1.9.2@rails3tutorial
Cela 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 devraient
vous permettre de retrouver toutes vos facultés :
$ rvm --help
$ rvm gemset --help
Installation de RubyGems
RubyGems est un gestionnaire de packages pour les projets Ruby, et il y a légion d'excellentes librairies (Rails
inclus) accessibles comme packages Ruby, ou comme gems. L'installation de RubyGems devrait être facile une
fois Ruby installé. En fait, si vous avez installé RVM, vous avez déjà RubyGems, puisque RVM l'inclut
automatiquement :
$ which gem
/Users/mhartl/.rvm/rubies/ruby-head/bin/gem
Si vous ne l'avez pas encore, vous devez télécharger RubyGems, l'extraire, puis aller dans le dossier rubygems
pour lancer le programme d'installation :
$ [sudo] ruby setup.rb
Si RubyGems est déjà installé, vous pouvez vouloir actualiser votre système avec la dernière version :
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 l'installation.
Installer Rails
Une fois RubyGems installé, l'installation de Rails 3.0 devrait être un jeu d'enfant :
$ [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 l'application 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
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 l'un 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 quelqu'un d'autre. 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 l'application (app), incluant des modèles (models), des vues (views), des contrôleurs (controllers), et
app/ des « assistants » (helpers)
28. 28
config/ Configuration de l'application
db/ Fichiers pour manipuler la base de données
doc/ Documentation pour l'application
lib/ Modules libraries
log/ Journaux (logs) de l'application
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 l'application (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 l'application
Rakefile Tâches utiles accessibles par le biais de la commande rake
Gemfile Les Gems requis par l'application
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 d'un dossier Rails.
1.2.4 Bundler
Après avoir créé une nouvelle application Rails, on utilise Bundler pour installer et inclure les gems utiles à
l'application. Cela consiste à ouvrir le fichier Gemfile avec votre éditeur de texte favori :
$ cd first_app/
$ mate Gemfile
Le résultat devrait ressembler à l'illustration 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
# 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 l'application 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'
# end
La plupart de ces lignes sont commentés par le symbole dièse (#) ; elles sont là pour vous montrer certains des
gems les plus communs et donner des exemples de la syntaxe Bundler. Pour le moment, nous n'aurons besoin
d'aucun gem autres que ceux par défaut : Rails lui-même, et le gem pour l'interface Ruby pour la base de
données SQLite.
Même si vous spécifiez un numéro de version pour la commande gem, Bundler installera toujours
automatiquement la dernière version. Malheureusement, les actualisations des gems causent souvent des
ruptures mineures mais potentiellement perturbantes, donc dans ce tutoriel nous ajouterons en général un
numéro de version explicite connu, comme le montre l'illustration 1.3.9
Illustration 1.3. Un fichier Gemfile avec un numéro de version du gem sqlite3-ruby explicite.
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 l'extrait 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 d'autre 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 à l'exé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
$ 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 server
Ce code nous dit que l'application est lancée sur le port 300014 à l'adresse 0.0.0.0. Cette adresse dit à
l'ordinateur d'écouter toutes les adresses IP accessibles et configurées sur la machine spécifiques ; en
particulier, nous pouvons voir l'application en utilisant l'adresse spéciale 127.0.0.1, connue aussi sous la
forme localhost. Nous pouvons voir le résultat en visitant l'adresse http://localhost:3000/
de l'illustration 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 application's
environment ». Le résultat est montré dans l'illustration 1.4.16
32. 32
Illustration 1.4: La page par défaut (http://localhost:3000/) avec l'environnement de
l'application.
Bien sûr, nous n'avons pas besoin de la page par défaut de Rails très longtemps, mais il est sympa de voir qu'elle
fonctionne pour le moment. Nous détruirons la page par défaut et la remplacerons par une page d'accueil
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 d'avoir un aperçu de haut-niveau de comment fonctionne les
applications Rails (Illustration 1.5). Vous pouvez avoir noté que la structure standard d'une application Rails
(Illustration 1.2) possède un dossier appelé app/ contenant trois sous-dossiers : models (Modèles), views
(Vues), and controllers (Contrôleurs). C'est l'indice 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
représente un élément du site (tel qu'un utilisateur) et est en charge de la communication avec la base de
données. Après l'invocation du modèle, le contrôleur produit alors une vue et retourne la page web achevée au
navigateur sous forme de code HTML.
Illustration 1.5: Une représentation schématique de l'architecture 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 ferons
fréquemment référence. Addionnellement, la section 2.2.2 contient une discussion plus détaillée sur le MVC
dans le contexte de l'Application démo. Pour finir, l'Application 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 la
section 6.1, et nous verrons comment les trois fonctionnent ensemble dans la section 6.3.2.
1.3 Contrôle de version avec Git
Maintenant que nous avons une application Rails fraiche et fonctionnelle, nous allons prendre le temps pour
une étape qui, bien que techniquement optionnelle, est considérée par de nombreux développeurs Rails comme
pratiquement essentielle, à savoir placer le code source de votre application sous contrôle de version. Les
systèmes de contrôle de version nous permettent de procéder à des modifications du code de notre projet, de
collaborer plus aisément avec d'autres développeurs, et de revenir en arrière en cas d'erreur (comme la
suppression accidentelle de fichiers). Savoir utiliser un système de contrôle de version est une compétence que
doit acquérir tout développeur.
34. 34
Il y a beaucoup d'options 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 l'effleurer 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 c'est 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 d'installer Git si vous n'avez pas suivi les étapes de la section 1.2.2.2 (comme
indiqué dans la section, cela implique d'avoir 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 n'avez à les faire qu'une fois par ordinateur :
$ git config --global user.name "Votre Nom"
$ git config --global user.email youremail@example.com
J'aime 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 n'ont pas
configuré ce co, mais dans la vie réelle j'utilise presque toujours git co pour contrôler la sortie d'un 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 d'utiliser 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.
35. 35
Initialisation des réglages du repository
Nous allons maintenant effectuer quelques opérations nécessaires chaque fois que vous créez un nouveau
repository — un nouveau « système de contrôle », ou un dossier, où vous allez déposer vos versions de
l'application . NdT — (ce qui n'arrive qu'une fois dans ce livre, mais qui est susceptible de se reproduire un
jour). Commencez par naviguer dans le dossier racine de la première application et initialisez un nouveau
repository :
$ git init
Initialized empty Git repository in
/Users/mhartl/rails_projects/first_app/.git/
La prochaine étape consiste à ajouter les fichiers du projet au repository. Il y a une complication mineure,
cependant : par défaut, Git piste les changements de tous les fichiers du dossier, même ceux que nous ne
voulons pas pister. Par exemple, Rails crée des journaux (logs) pour enregistrer le comportement de
l'application ; ces fichiers changent fréquemment, et nous ne voulons pas que notre système de contrôle de
version les actualise en permanence. Git possède un mécanisme simple pour ignorer de tels fichiers : ajoutez
simplement dans le dossier racine de Rails un fichier appelé .gitignore contenant quelques règles précisant
à Git les fichiers à ignorer.
En consultant à nouveau la Table 1.1, nous voyons que la commande rails crée un fichier .gitignore par
défaut dans le dossier racine de Rails, comme le montre l'illustration 1.4.
Illustration 1.4. Le fichier par défaut .gitignore créé par la commande rails.
.bundle
db/*.sqlite3
log/*.log
tmp/**/*
L'illustration 1.4 contraint Git à ignorer les fichiers tels que les journaux (log), les fichiers temporaires de Rails
(tmp), et les bases de données SQLite (par exemple, pour ignorer les journaux, qui se trouvent dans le dossier
log/, nous utilisons le code log/*.log pour ignorer tous les fichiers d'extension .log). La plupart de ces
fichiers ignorés changent fréquemment et automatiquement, donc les inclure dans le contrôle de version est
gênant ; plus encore, lors d'une collaboration, ils peuvent entrainer des conflits frustrants et inutiles.
Le fichier .gitignore de l'extrait 1.4 est suffisant pour ce tutoriel, mais en fonction de votre système vous
pourrez trouver le code de l'extrait 1.5 plus adapté.18 Ce fichier .gitignore augmenté est défini pour ignorer
les fichiers de documentation Rails, les fichiers swap Vim et Emacs, (et pour les utilisateurs OS X) les fichiers de
dossier .DS_Store créés par le finder du Mac. Si vous voulez appliquer ce réglage plus large de fichiers