Developpez.com

Une très vaste base de connaissances en informatique avec
plus de 100 FAQ et 10 000 réponses à vos questions

Developpez.com - Ruby & Rails
X

Choisissez d'abord la catégorieensuite la rubrique :


Commencer avec Ruby on Rails

Ruby on Rails par la pratique
Ruby on Rails

Date de publication : 15/05/2009 , Date de mise à jour : 15/05/2009

Par Vincent Dubois (v-dubois.developpez.com) (Blog)
 

Dans cet article, découvrez les différents composants de Ruby on Rails et prenez en main le framework. Découvrez les atouts de ce framework qui ne laisse pas indifférent.
 

               Version PDF (Miroir)   Version hors-ligne (Miroir)

1. Introduction
2. Recommandations
3. Qu'est ce que Rails ?
3.1. L'architecture MVC
3.2. Les différents composants de Rails
3.3. REST
4. Création d'un projet Rails
4.1. Installation de Rails
4.2. Création de l'application « Mes Contacts »
4.3. Configuration de la base de données
4.4. Création de la base de données
5. Bonjour, Rails !
5.1. Démarrage du serveur
5.2. Positionnement de la page par défaut
6. Le système de « scaffolding »
6.1. Création des contacts
6.2. La console Rails
7. Remerciements


1. 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 !


2. 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 :

3. 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 :

3.1. L'architecture MVC

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

3.2. 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.


3.3. REST

Les principes de base de REST sont les suivants :


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

  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"


4. Création d'un projet Rails


4.1. 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 :

  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.


4.2. 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 :

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

  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 :

  rails mycontacts -d mysql
        
Positionnez-vous maintenant dans le dossier de l'application avec la commande :

  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

4.3. 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 :

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

  # 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 :

  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.


4.4. 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 :

  rake db:create
        
info 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 ».

5. 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 :

  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

  <h1>Bonjour, Rails!</h1>
      

5.1. 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 :

  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 :

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


5.2. 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 :

  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

  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 :

  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.


6. 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é.


6.1. 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 :

  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 :

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

  map.root :controller => "contacts"
        
Voici maintenant la nouvelle page d'accueil de l'application :

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.


6.2. 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 :

  ruby script/console
        
Ensuite, vous pouvez par exemple lister les contacts existants :

  >> 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 :

  >> 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 :

  >> 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.


7. Remerciements

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



               Version PDF (Miroir)   Version hors-ligne (Miroir)

Valid XHTML 1.1!Valid CSS!

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2009 Vincent Dubois. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Contacter le responsable de la rubrique Ruby & Rails