[PDF] Cours de Ruby et Ruby on Rails | Formation informatique

Frédéric Pernias Valtech Toulouse

Ruby et Ruby on Rails

février 06

Résumé

Ruby est un langage de script orienté objet, abordable et très complet. Depuis 1995, il a su fédérer une communauté très active qui a mis à son service un grand nombre d’API. De cette communauté est né « Ruby on Rails » (RoR), un framework permettant de développer des applications web sur le modèle mvc. Ce document va présenter rapidement Ruby et son modèle objet, puis RoR, en s’intéressant plus précisément à son fonctionnement et à certaines de ses couches dont Active Record, le module de mapping objet relationnel. L’article sera appuyé par des démonstrations du langage Ruby et un exemple de mise en œuvre de RoR.

Table des matières

2.2 Les briques de RoR ...10

2.2.1 Active Controller... 10

2.2.2 Active Record... 11

Liste des Figures

Figure 1 : Un exemple de syntaxe... 4

Figure 2 : la fonction factorielle... 4

Figure 3 : la fonction factorielle... 4

Figure 4 : Manipulation d’un objet de type Fixnum ... 5

Figure 5 : Définition et utilisation de la classe Vehicule... 5

Figure 6 : Définition et utilisation de la classe Voiture, héritée de la classe Vehicule... 6

Figure 7 : Définition des niveaux de visibilité des méthodes... 7

Figure 8 : Accès aux variables d’instance ... 7

Figure 9 : Une url pour le dispatcher de RoR ... 8

Figure 10 : Le framework Ruby on Rails... 8

Figure 11 : Le framework Ruby on Rails vu par l’utlisateur. ... 9

Figure 12 : Arborescence créée par RoR... 9

Figure 13 : Exécution du script generate... 10

Figure 14 : Un exemple de contrôleur. ... 11

Figure 15 : Un exemple de mapping à l’aide du pattern Active record... 11

1. Ruby

Ruby est un langage de programmation orienté objet, créé par Yukihiro "Matz" Matsumoto en 1993 (première version disponible en 1995).Tout comme Visual basic ou javascript, il est interprété. Simple, cohérent, faiblement typé et offrant un panel complet d’objet et de modules, il simpllifie le travail de developpement.

1.1 Cohérence et simplicité

Ruby a été créé pour répondre au principe de PoLS (Principle of least surprise - principe de moindre surprise) : Éviter à l'utilisateur, de la façon la plus simple possible, toutes les (mauvaises) surprises. Le principal effort mis en œuvre lors de son développement fut donc de permettre à l’utilisateur de programmer tout en restant concentré sur le côté créatif du développement : un maximum de code utile pour un minimum de code écrit.

Ruby s’appuye sur une syntaxe qui se rapproche du langage naturel, ce qui conforte cette volonté de simplifier l’apprentissage et l’utilisation.

5.times { print ‘hello’ }

print “hello”*5

Figure 1 : Un exemple de syntaxe.

L’interprétation de ce script donne : cinq fois écrire «hello».

Ruby permet donc d’écrire des algorithmes de manière plus compréhensible aux différentes personnes les lisant. Prenons pour exemple la fonction factorielle.

def fact(n) if ( n==1 ) 1 else n * fact(n-1) end end

Figure 2 : la fonction factorielle.

Son implementation est connue de tout le monde. On pourra l’écrire aussi :

def fact(n)

return n * fact(n-1) unless n == 1 1

end

Figure 3 : la fonction factorielle.

La lecture en est plus intuitive : Pour tout n, calculer n multiplier par factoriel de n-1 à moins que n égale 1.

Toute la synthaxe bénéficie de cette simplicité et de cette cohérence, rendant Ruby intuitif à programmer.

1.2 Objet

Ruby est un langage objet. Il dispose de l’héritage de premier niveau, mais du fait de son faible typage, ne dispose pas d’interface ou de classe abstraite.

1.2.1 Un objet Ruby

En Ruby, tout est objet et hérite implicitement de la classe object : a=5

print a*5 >> 25

print a.to_s*5 >>55555

Figure 4 : Manipulation d’un objet de type Fixnum

Ruby offre une multitude d’objets allant des types de base (chaîne de caractères, booléen, flottant, entier), des collections, jusqu’à des objets beaucoup plus complexes comme des parseurs XML ou des serveurs web.

Ruby laisse évidement la possibilité de créer nous même nos propres objets

class Vehicule

def initialize(couleur)

@couleur = couleur

end

def affiche

print " Mon véhicule est " + @couleur.to_s end

end

voiture = Vehicule.new("gris") voiture.affiche

>> Mon véhicule est gris

Figure 5 : Définition et utilisation de la classe Vehicule.

Cet exemple présente comment définir un objet en utilisant le mot clef class suivit du nom de l’objet. La syntaxe Ruby impose que le nom de l’objet commence par une majuscule, comme toutes les expressions constantes du langage. La fin du bloc de définition de la classe est notifiée par l’utilisation du mot clés end. Toutes les méthodes de la classe sont définies par l’utilisation du mot clés def, suivi du nom de la méthode et des paramètres de celle-ci. Une méthode particulière est initialize. Elle définit le comportement de l’objet lors de son instanciation lors de l’appelle de la méthode new.

Cet exemple introduit aussi l’utilisation des variables d’instances de classe. Elles sont définies en utilisant le préfixe @ et sont par défaut privées.

1.2.2 L’héritage

class Voiture < Vehicule

@@nombre = 0 ;

def initialize(couleur)

super(couleur)

@@nombre += 1

end

def affiche

print " Ma voiture(numero "+@@nombre.to_s+") est " + @couleur.to_s end

end

voiture = Voiture.new("rouge") voiture.affiche

>> Ma voiture(numero 1) est rouge

voiture2 = Voiture.new("bleue") voiture2.affiche

>> Ma voiture(numero 2) est bleue

Figure 6 : Définition et utilisation de la classe Voiture, héritée de la classe Vehicule.

Cet exemple présente le mécanisme d’héritage tel qu’il est définit en Ruby : Utilisation du mot clé super pour faire référence à la classe héritée, surdéfinition des méthodes.

1.2.3 Accés et visibilité

Ruby offre aussi les attributs de visibilité sur les méthodes ainsi que des attributs pour accéder aux variables d’instances.

On pourra donc s’assurer de rendre privées, publiques ou protégées les méthodes en les préfixant des attributs private, public ou protected. Comme précédemment, Ruby offre une autre syntaxe pour fixer le niveau de visibilité des méthodes.

class Exemple

private

def methode1

. . . end

public # par defaut

def method2 . . . end protected def method3 . . . end end

class ExempleRapide private :methode1 public :methode2 protected :methode3 def methode1 . . . end def method2 . . . end def method3 . . . end end

Figure 7 : Définition des niveaux de visibilité des méthodes.

L’accès aux variables d’instance se fera en fonction des droits d’accès définis pour chaque variable.

class ExempleVariable

attr_writer :variable1 #accés à la variable d’instance en écriture

attr_reader :variable2 #accés à la variable d’instance en lecture

. . .

Figure 8 : Accès aux variables d’instance

1.3 Mais aussi…

Ruby offre aussi tout un panel de fonctionnalités avancées au travers de multiple librairies : - Expressions régulières,

- Exceptions, - XML,

- Gestion des threads,

- Accés au système d’exploitation,

- Interopérabilité avec d’autres langages de programmation (dotnet, java), - Accés aux protocoles de communication (tcp, ftp, http…) ,

2. Ruby on Rails

Ruby on Rails (RoR) est un framework de développement d’applications web, créé en juillet 2004 et basé sur le langage Ruby. Il s’appuie sur deux grands principes: "Ne pas se répéter" et "Convention plutôt que Configuration" :

"Convention plutôt que Configuration" signifie que l’on peut configurer de manière implicite les liens entre les différentes couches. Par exemple, le dispatcher n’utilise pas de fichier de configuration, la convention utilisée par RoR est simple : l’url passée au dispatcher doit contenir le nom du controller et le nom de l’action à utiliser.

http://localhost:3000/controller/action

Figure 9 : Une url pour le dispatcher de RoR

Il invoquera la méthode action du contrôleur controller.

- "Ne pas se répéter" signifie qu’il n’est pas nécessaire de répéter les différentes définitions. Pour reprendre l’exemple précédent, il n’est pas nécessaire de spécifier les différentes colonnes de la table users dans le modèle User, elles seront accessibles directement. L’architecture de RoR est celle d’un MVC classique :

Il est composé de six briques :

- le serveur web, généralement WEBrick, un serveur web écrit en Ruby. - le Dispatcher, qui permet d’appeler l’action demandée par l’utilisateur - Active Controller

- Active Record (mapping objet relationnel) - Action View (au travers du RHTML)

- Action Mailler, qui permet d’envoyer ou de recevoir des mails.

RoR permet de rendre cette architecture transparente pour l’utilisateur pour qu’il n’accède qu’aux trois parties d’un modèle mvc classique : le contrôleur, le modèle et la vue.

Figure 11 : Le framework Ruby on Rails vu par l’utlisateur.

Pour se faire, il propose de nombreux scripts, pour créer les différentes briques de l’application, et des conventions de codages pour permettre le lien entre elles.

Par exemple, la définition de la méthode list dans le contrôleur User aura pour conséquence directe l’utilisation d’une vue list.rhtml s’il elle existe. En effet, le lien entre cette action et cette vue se fait par le nom des fichiers. Il faut donc une structure de fichier très stricte qui est construite en utilisant les scripts offerts par RoR :

Ces différents répertoires contiennent les éléments nécessaires au bon fonctionnement du site : • Public contient l’arborescence du site

• Script, les scripts de création des modèles, vues et contrôleurs,

• Config, les fichiers de configuration de l’application (principalement la configuration de l’accès de la base de données)

• App, l’arborescence des répertoires et fichiers des contrôleurs, vues et modèles…

L’exécution du script Generate permet de créer un contrôleur et les vues associées ainsi que des classes outils telles que les classes de test.

Figure 13 : Exécution du script generate.

Un contrôleur Test_controller.rb a été généré, contenant le squelette d’un contrôleur RoR et de la méthode list. Il se situe dans le répertoire app/controllers/. De même, une vue liste.rhtml a été créée dans le répertoire views/test/.

2.2 Les briques de RoR

Comme vue précédemment, RoR est formé de 6 briques. Dans cette partie, nous allons détailler le contrôleur, Active Record, l’outil de mapping objet relationnel et le Rhtml, le langage de script utilisé pour la vue de RoR.

2.2.1 Active Controller

RoR permet de mapper automatiquement un contrôleur à une table ou une vue de la base de données en utilisant le mot clé scaffold. RoR associe alors la table ou vue sélectionnée et permet l’utilisation de méthode d’accès à la base. L’utilisation du mot clé Scaffold induira aussi la création des méthodes de toutes application CRUD (Create, Read, Update, Delete).

class RecipeController < ApplicationController

# scaffold (mapping automatique avec la table) et creation des méthodes # new, delete, create, update et list

# est inhibié des la definition d'une nouvelle action #

scaffold :recipe

# le mapping par defaut d'une action vers sa vue se fait par le nom de # l'action.

# s'il existe un fichier model list.rhtml, il sera utilisé. #

def list

end end

Figure 14 : Un exemple de contrôleur.

Dans cet exemple, la variable d’instance @recipes contient la listes des enregistrements de la table Recipes. Cette variable est accessible directement dans la vue list.rhtml.

2.2.2 Active Record

Active record, pattern proposé par Martin Fowler, permet de connecter les objets métiers de l’application et les tables ou des vues de la base de données. Il couple de manière étroite les données et la logique de domaine avec la logique d’accès aux données. Un modèle Active Record type inclut le code requis pour:

- insérer, mettre à jour et supprimer une instance spécifique de l’objet, - trouver et charger un objet spécifique, ainsi que tout objet associé,

- constituer des collections fortement typées d’objets extraits de la base de données à l’aide d’une méthode statique.

Figure 15 : Un exemple de mapping à l’aide du pattern Active record.

2.2.3 RHTML

Le rhtml est le langage de script proposé par RoR. A l’instar des Java et ses jsp, rhtml permet l’insertion de scriptlet dans du code html. Ces scriptlets, permettent d’accéder aux données du modèle manipulé dans les actions des contrôleurs.

<html>

<head>

<title>All Recipes</title> </head>

<body>

<h1>Online Cookbook - All Recipes</h1> <table border="1"> <tr> <td width="80%"><p align="center"><i><b>Recipe</b></i></td> <td width="20%"><p align="center"><i><b>Date</b></i></td> </tr> <% @recipes.each do |recipe| %> <tr>

<td><%= link_to recipe.title, :action => "show", :id => recipe.id %></td> <td><%= recipe.date %></td> </tr> <% end %> </table> </body> </html>

Figure 16 : La vue list.rhtml, associée a l’action list du contrôleur recipe.

Les symboles spécifiques <%, %>, <%= %> permettent d’insérer du code Ruby. Un série de tags prédéfinis permettent de réaliser des boucles, d’insérer des évaluations de scripts.