I. Introduction

Ce guide s'inspire du site « Rails Guides », de mon expérience personnelle de Ruby on Rails et dans tout un tas d'autres ressources (screencasts, sites communautaires, etc...).
Ce guide est également l'occasion de constituer une application de A à Z, d'en voir tous les tenants et les aboutissants (conception, codage, déploiement, etc...). Je vous souhaite d'ores et déjà une très bonne lecture !

II. Recommandations

Dans ce guide, je pars du principe que le lecteur possède une connaissance minimale du langage Ruby. Si certaines portions de code Ruby nécessitent des précisions, j'expliquerai le plus clairement possible ces points de détail.

Pour commencer avec Ruby on Rails, il est nécessaire d'avoir au moins trois choses installées :

III. Qu'est ce que Rails ?

Rails est un framework de développement web écrit en langage Ruby. Il est conçu pour rendre le développement d'applications web le plus simple et le plus concis possible. Tous les développeurs qui se sont mis un jour à Rails s'accordent à dire que le développement avec Rails est plus fun. Ceci est lié en grande partie au fait que le langage Ruby soit si intuitif.

Le développement avec Rails nécessite l'apprentissage de bonnes pratiques de développement. Une fois ces bonnes pratiques appliquées, le développeur gagne en productivité. Si le développeur garde des réflexes de développement acquis sur d'autres langages, ou utilise des design patterns vus dans d'autres contextes, il aura une moins bonne expérience de Rails et n'en tirera pas tous les bénéfices.

La philosophie de Rails se base sur trois principes :

  • Le DRY (Don't Repeat Yourself) : Rails encourage à ne pas écrire plusieurs fois le même code. Rendre réutilisable le code de vos applications est une bonne chose !
  • Convention over configuration : Rails se base uniquement sur des conventions, non sur de la configuration (à l'inverse d'autres langages comme Java par exemple). Si vous respectez ces principes de convention, vous rendrez votre code maintenable et vous gagnerez en productivité.
  • REST : c'est le meilleur design pattern pour le développement d'applications web. Il vous permet d'organiser vos applications autour de verbes HTTP standards.

III-A. L'architecture MVC

Rails est organisé selon l'architecture MVC (Modèle-Vue-Contrôleur). Cela lui permet :

  • D'isoler la logique métier de l'interface utilisateur
  • De maintenir le code « DRY »
  • De conserver le code là où il doit résider, pour une meilleure maintenance

III-B. Les différents composants de Rails

Action Controller
C'est le composant qui gère les contrôleurs de l'application. Les services rendus par le composant sont la gestion de session, le rendu de templates, et la gestion de redirection.

Action View
Gère la partie vue de vos applications. Il permet de créer du HTML et du XML par défaut. Les services rendus par ce composant sont le rendu de templates, l'inclusion et le rendu de templates partiels (« partials »), et le support d'AJAX.

Active Record
C'est la base des modèles dans vos applications Rails. Il fournit l'indépendance vis-à-vis des bases de données, la base des fonctionnalités CRUD (Create-Retrieve-Update-Delete), et la capacité à relier les modèles entre eux par exemple.

Active Resource
Ce composant fournit un framework pour gérer la connexion entre des objets métier et des services web RESTful. Il implémente une façon de mapper des ressources web à des objets locaux avec une sémantique CRUD.

Active Support
C'est une collection extensive de classes utilitaires et d'extensions Ruby standards, utilisées à la fois dans vos applications et dans le code du framework Rails.

III-C. REST

Les principes de base de REST sont les suivants :

  • L'utilisation d'URLs pour représenter des ressources.
  • L'utilisation de verbes HTTP pour toutes les opérations nécessaires (GET, POST, PUT et DELETE)
  • L'utilisation des standards HTML et XML


Par exemple, dans une application Rails une requête du type :

 
Sélectionnez
DELETE /photos/17

fait référence à une ressource de type photo, d'identifiant 17, et l'action entreprise est de type suppression.

Si vous souhaitez plus de précisions sur REST, il est conseillé de consulter l'article "A brief introduction to REST"

IV. Création d'un projet Rails

IV-A. Installation de Rails

La première opération à effectuer avant de créer un projet Rails est évidemment d'installer Rails. Rails est disponible sous la forme d'un gem. Pour l'installer, lancer la commande :

 
Sélectionnez
gem install rails

La version de Rails utilisée lors de ce tutoriel est la version 2.3.2. Elle sert de base pour tout le reste du présent document.

IV-B. Création de l'application « Mes Contacts »

Dans le cadre de ce tutoriel, nous allons constituer une application complète de gestion des contacts. Cette application devra fournir :

  • Une gestion multi-utilisateurs
  • Une gestion personnelle de contacts avec leurs caractéristiques
  • Un moyen d'importer des contacts provenant d'autres applications (gmail, hotmail, ...)
  • Un moyen d'exporter des contacts sous plusieurs formes
  • Un code source de haute qualité répondant aux standards Rails

Procédons à la création du projet. Tout ce que vous avez à faire est de taper :

 
Sélectionnez
rails mycontacts

Lorsque vous lancez cette commande, la base de données qui va être utilisée par défaut est SQLite. Si vous souhaitez utiliser une autre base de données, il suffit de suffixer la commande avec l'option -d et le nom de la base de données. Exemple pour MySQL :

 
Sélectionnez
rails mycontacts -d mysql

Positionnez-vous maintenant dans le dossier de l'application avec la commande :

 
Sélectionnez
cd mycontacts

Si vous listez le contenu du répertoire, vous obtiendrez la structure standard d'un projet Rails. En voici le détail :

Fichier / Répertoire Description
app/ Contient le code Rails de l'application (modèles, vues, contrôleurs...)
config/ Contient le code de configuration de l'application
db/ Contient le code de description de la base de données
doc/ Contient la documentation du code de l'application
lib/ Contient les modules d'extensions éventuels de l'application
log/ Contient les traces de l'application
public/ Contient les fichiers statiques de l'application (images, javascript, css)
script/ Contient les scripts Rails nécessaires au développement
test/ Contient les tests unitaires de l'application
tmp/ Contient les fichiers temporaires générés par l'application
vendor/ Contient les gems et plugins nécessaires à l'application

IV-C. Configuration de la base de données

Notre application de gestion des contacts va reposer sur une base de données, ils nous faut donc la configurer. Lorsque nous avons créé le projet tout à l'heure, Rails a créé pour nous un fichier de configuration de la base de données, qui se situe dans config/database.yml. Ce fichier est un fichier de configuration au format YAML. YAML est le format de fichier de configuration par défaut utilisé dans tous les projets Rails. C'est un format assez simple à appréhender.

Sachez tout d'abord que tout projet Rails est créé avec trois environnements de travail par défaut :

  • development : lorsque vous développez votre application, c'est dans ce mode que vous travaillez, c'est également celui par défaut. Chaque modification que vous ferez sur votre code dans ce mode sera prise en compte « à chaud ».
  • test : c'est le mode utilisé lorsque vous souhaitez lancer vos tests unitaires d'application.
  • production : c'est le mode utilisé lorsque votre projet est finalisé. Il contient des optimisations significatives qui font la différence lors de l'exécution.

Voyons maintenant à quoi ressemble notre fichier de configuration database.yml, en ne prenant en considération que la partie de l'environnement « development » :

config/database.yml
Sélectionnez
# SQLite version 3.x
#   gem install sqlite3-ruby (not necessary on OS X Leopard)
development:
adapter: sqlite3
database: db/development.sqlite3
pool: 5
timeout: 5000

Commençons par le commentaire : on nous conseille d'installer le gem sqlite3-ruby, pour avoir le support SQLite. Faisons-le :

 
Sélectionnez
gem install sqlite3-ruby

Le paramètre « adapter » décrit le type de base de données. Il peut prendre la valeur du nom d'une quantité impressionnante de bases de données, toutes supportées par Rails. En voici une liste non exhaustive : SQLite, MySQL, PostgreSQL, Oracle, DB2, ...
Le paramètre « database » contient en général le nom de la base de données. Dans le cas de SQLite, il contient le chemin vers le fichier qui contient la base de données. Ce fichier n'existe pas encore, mais nous verrons plus loin comment le créer.
Le paramètre « pool » permet de déterminer le nombre de connexions à allouer pour la base de données.
Le paramètre « timeout », quant à lui, permet de déterminer, en millisecondes, le temps maximum à allouer à une requête sur la base de données.

IV-D. Création de la base de données

Maintenant que la base de données est configurée, nous devons la créer. Pour cela, il suffit de taper :

 
Sélectionnez
rake db:create

Rake est une commande d'usage général pour les projets Rails entre autres. Pour obtenir une liste des commandes Rake disponibles, tapez « rake -T ».

V. Bonjour, Rails !

Un des moyens d'apprendre un nouveau langage est de créer un programme court pour afficher quelque chose à l'écran. Pour effectuer cela avec Rails, vous devez créer au moins un contrôleur et une vue.

Tapez la commande suivante :

 
Sélectionnez
ruby script/generate controller home index

Rails crée ici plusieurs fichiers pour vous, dont le fichier contrôleur app/controllers/home_controller.rb, et le fichier vue app/views/home/index.html.erb. Ouvrez le fichier index.html.erb, et complétez-le avec ce qui suit :

app/views/home/index.html.erb
Sélectionnez
<h1>Bonjour, Rails!</h1>

V-A. Démarrage du serveur

Vous avez une application Rails fonctionnelle après avoir exécuté deux commandes seulement. Pas mal du tout ! Démarrez maintenant le serveur d'application Rails en lançant la commande :

 
Sélectionnez
ruby script/server

Le serveur démarre par défaut sur le port 3000. Ouvrez un navigateur internet à l'adresse : http://localhost:3000. Voici ce que vous devriez voir :

Image non disponible

Pour voir la page que vous venez de créer, ouvrez le navigateur à l'adresse : http://localhost:3000/home/index.

V-B. Positionnement de la page par défaut

Vous voudrez probablement remplacer la page d'accueil par défaut de Rails par la page que vous venez de créer. Pour cela, vous devez supprimer le fichier index.html qui se situe dans le répertoire public :

 
Sélectionnez
rm public/index.html

Ensuite, vous devez configurer ce qui s'appelle les « routes », c'est à dire les chemins qui permettent de faire le lien entre des URL et les contrôleurs de l'application. Cela se passe dans le fichier config/routes.rb. À la fin du fichier, vous trouverez la configuration des chemins par défaut :

config/routes.rb
Sélectionnez
map.connect ':controller/:action/:id'
map.connect ':controller/:action/:id.:format'

Cela signifie que le format des URLs est du style : contrôleur/action/identifiant. Par exemple, si nous voulions dans notre application de gestion des contacts supprimer un contact d'identifiant « 17 » (à compter que cette fonctionnalité soit implémentée), nous pourrions le faire via l'URL : http://localhost:3000/contacts/delete/17.

Revenons au cas de notre page par défaut. Il faut que le chemin par défaut de l'application pointe sur notre contrôleur, et plus précisément sur l'action « index ». Rajoutez ce qui suit au fichier routes.rb :

 
Sélectionnez
map.root :controller => "home"

Cela illustre le principe « convention over configuration » de Rails : nous n'avons pas précisé le nom de l'action dans la ligne ci-dessus, et pourtant la page d'accueil pointe bien maintenant sur home/index. Interrompez le serveur avec CTRL+C, relancez-le, et constatez le résultat en appelant http://localhost:3000.

VI. Le système de « scaffolding »

C'est une des fonctionnalités puissantes et un peu « magiques » de Rails. Elle permet à partir de très peu de commandes et de code d'avoir un CRUD (Create-Read-Update-Delete, les 4 fonctions basiques d'une base de données) complet sur un composant donné.

VI-A. Création des contacts

Nous allons créer maintenant la partie données représentant les contacts de notre application. Nous ne serons pas exhaustifs, car cela fera l'objet de futurs tutoriels. Pour créer l'ensemble des fichiers nécessaires au CRUD, tapez la commande suivante :

 
Sélectionnez
ruby script/generate scaffold Contact name:string email:string

Nous ne verrons pas ici le détail des fichiers générés. Nous pouvons juste voir que nous avons créé une entité « Contact » avec comme attributs un nom et un email. Avant de pouvoir profiter du CRUD, nous devons d'abord créer la table correspondant à cette entité « Contact » en base de données. Pour cela, tapons la commande :

 
Sélectionnez
rake db:migrate

Ensuite, mettons à jour le fichier routes.rb pour qu'il pointe sur le contrôleur correspondant :

config/routes.rb
Sélectionnez
map.root :controller => "contacts"

Voici maintenant la nouvelle page d'accueil de l'application :

Image non disponible

Cliquez sur « New contact » pour ajouter des contacts dans la liste, les modifier, les supprimer, ou encore les lister. Vous avez ici une première ébauche de l'application. Certes, ce n'est pas très personnalisé, mais vous n'avez pratiquement écrit aucune ligne de code.

VI-B. La console Rails

La console Rails est une invite de commandes irb qui met à notre disposition toutes les classes de l'application Rails en cours. Vous pouvez donc par exemple interagir sur la base de données à volonté. Pour la lancer, il faut taper :

 
Sélectionnez
ruby script/console

Ensuite, vous pouvez par exemple lister les contacts existants :

 
Sélectionnez
>> Contact.find(:all)
 
=> #<Contact id= "1" name= "Vincent Dubois" email= "duboisv@hotmail.com" created_at= "2009-04-18 17:26:55" updated_at= "2009-04-18 17:26:55">,
#<Contact id= "2" name= "Albert Dupont" email= "adupont@mycontacts.fr" created_at= "2009-04-19 08:05:02" updated_at= "2009-04-19 08:05:02">]

Nous pouvons aisément constater que l'appel à find(:all) a ramené le jeu complet des données de la table « contacts », dans un tableau. Vous pouvez si vous le souhaitez créer des contacts :

 
Sélectionnez
>> my_contact = Contact.new(:name => "Pierre Martin", :email => "pm@mycontacts.fr")
=> #<Contact id= nil name= "Pierre Martin" email= "pm@mycontacts.fr" created_at= nil, updated_at= nil>
 
>> my_contact.save
=> true

Ou même en supprimer :

 
Sélectionnez
>> my_contact.destroy
 
=> #<Contact id= 3, name= "Pierre Martin", email= "pm@mycontacts.fr", created_at= "2009-04-19 10:02:54", updated_at= "2009-04-19 10:02:54">

Pour sortir de la console Rails, faites-le comme dans irb, avec la commande « exit ».

Voilà, vous avez les premières clés en main pour vous lancer dans l'exploration des répertoires d'une application Rails. N'hésitez pas à vous balader, aller voir le contenu des fichiers contrôleurs, des fichiers modèles, ou encore des fichiers vues, modifiez-les, observez les résultats. Bref, faites connaissance avec les possibilités de l'API Rails. Vous trouverez toute la documentation concernant cette API à l'adresse : http://api.rubyonrails.org/.

Dans le prochain chapitre, nous entrerons en profondeur dans le sujet des bases de données. Nous étudierons le composant Active Record, et plus particulièrement les migrations. Nous en profiterons pour peaufiner notre base de données.

Vous pouvez retrouver le source de ce tutoriel ici.

VII. Remerciements

Je tiens à remercier Rodrigue Hunel pour la publication de cet article, et l'équipe Développement Web pour sa relecture.