Cours gratuits » Cours informatique » Cours développement web » Cours Ruby » Cours d introduction à Ruby on Rails

Cours d introduction à Ruby on Rails

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Commencer avec Ruby on Rails

Ruby on Rails par la pratique

 

par Vincent Dubois(Blog)

Date de publication : 26/05/2009

Dernière mise à jour : 26/05/2009

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.

 
 

Ce guide s'inspire du site « », 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 !


Dans ce guide, je pars du pri

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

•     (version 1.8.7 dans le cas de ce guide)

•     (version 1.3.2 dans le cas de ce guide)

•     , , ou

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.

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

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.

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 :

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


4  - Création d'un projet 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 . 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.

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 :

  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

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 . Ce fichier est un fichier de configuration au format . 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 , en ne prenant en considération que la partie de l'environnement « development » :

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

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

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

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 , et le fichier vue app/ . Ouvrez le fichier , et complétez-le avec ce qui suit :

  <h1>Bonjour, Rails!</h1>

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 : . Voici ce que vous devriez voir :

 

Pour voir la page que vous venez de créer, ouvrez le navigateur à l'adresse : .

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 qui se situe dans le répertoire public :

  rm         

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 . À la fin du fichier, vous trouverez la configuration des chemins par défaut :

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

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 :

  :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, relancezle, et constatez le résultat en appelant .


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 (Create-Read-Update-Delete, les 4 fonctions basiques d'une base de données) complet sur un composant donné.

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 pour qu'il pointe sur le contrôleur correspondant :

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

  >> (:all)

  => #<Contact id= "1" name= "Vincent Dubois" email= "" created_at= "2009-04-18 17:26:55" updat   #<Contact id= "2" name= "Albert Dupont" email= "" created_at= "2009-04-19 08:05:02" updated

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 = (:name => "Pierre Martin", :email => "")

  => #<Contact id= nil name= "Pierre Martin" email= "" created_at= nil, updated_at= nil>

  >>

  => true

Ou même en supprimer :

  >> my_contact.destroy

  => #<Contact id= 3, name= "Pierre Martin", email= "", created_at= "2009-04-19 10:02:54", updated

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, modifiezles, 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 : .

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 .

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


92