« Ruby On Rails » : différence entre les versions

De Lea Linux
Aller à la navigation Aller à la recherche
Aucun résumé des modifications
(balises code)
(10 versions intermédiaires par 4 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
[[Category:Développer sous Linux]]
[[Catégorie:Développement]]
 
= Ruby On Rails =
= Ruby On Rails =


Ligne 17 : Ligne 18 :


Il vous faudra aussi des notions de ruby.
Il vous faudra aussi des notions de ruby.
Dans ce document, je mettrais en place un gestionnaire de livre rudimentaire. Le but est de présenter les bases d'un projet Rails. Il est évident que ces informations sont loin d'être exhaustives vue que RoR peut remplir tout un livre de 500 pages.


== Mise en place de l'environnement ==
== Mise en place de l'environnement ==


<code>$ rails monsite
<div class="code">$ rails monsite
       create   
       create   
       create  app/controllers
       create  app/controllers
Ligne 27 : Ligne 30 :
       create  app/views/layouts
       create  app/views/layouts
[...]
[...]
</code>
</div>
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.
Normalement, il devrait contenir les fichiers et répertoires suivants :  
Normalement, il devrait contenir les fichiers et répertoires suivants :  
<code>app
<div class="code">app
components
components
config
config
Ligne 44 : Ligne 47 :
tmp
tmp
vendor
vendor
</code>
</div>


== Configuration ==
== Configuration ==


Si vous n'avez pas de base de donnée, créez-en :
Si vous n'avez pas de base de donnée, créez-en :
<code>mysql> create database monsite_development;
<div class="code">mysql> create database monsite_development;
mysql> create database monsite_test;
mysql> create database monsite_test;
mysql> create database monsite_production;</code>
mysql> create database monsite_production;</div>
<div class="aparte">
<div class="aparte">
Note : J'en ai crée 3 pour pouvoir utiliser 3 environnements différents. Une seule peut suffir, ca dépend de ce que vous voulez faire.
Note : J'en ai crée 3 pour pouvoir utiliser 3 environnements différents. Une seule peut suffir, ca dépend de ce que vous voulez faire.
Ligne 57 : Ligne 60 :


Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte :  
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte :  
<code>production:
<div class="code">production:
   adapter: mysql
   adapter: mysql
   database: monsite_production
   database: monsite_production
   username: root
   username: root
   password:
   password:
   host: localhost</code>
   host: localhost</div>
Editez-le en fonction des paramètres de votre base de donnée
Avec :
<code>production:
* adapter le type de base de donnée (mysql, postgres, sqlite...)
* database le nom de la base de donnée
* username le nom de l'utilisateur de la base de donnée
* password le mot de passe à la base de donnée
* host le serveur de base de donnée
Dans le cas de sqlite, on a :
* adapter le type de base de donnée (sqlite)
* dbfile nom du fichier de base de donnée
 
Editez-le en fonction des paramètres de votre base de donnée. Exemple :
<div class="code">production:
   adapter: mysql
   adapter: mysql
   database: monsite_production
   database: monsite_production
   username: gedsismik
   username: gedsismik
   password: mypassord
   password: mypassword
   host: localhost
   host: localhost
   socket: /var/run/mysql/mysql.sock</code>
   socket: /var/run/mysql/mysql.sock</div>
<div class="aparte">
<div class="aparte">
Note : Sous Slackware, j'ai du ajouter la ligne <code>socket: /var/run/mysql/mysql.sock</code> sinon il ne trouve pas la socket MySQL.
Note : Sous Slackware, j'ai du ajouter la ligne <div class="code">socket: /var/run/mysql/mysql.sock</div> sinon il ne trouve pas la socket MySQL.
</div>
</div>


Ligne 78 : Ligne 91 :


Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :
  - les modèles (répertoire <code>./app/models</code>) : ce qui concerne les données. Dans notre cas, c'est donc principalement les tables des bases de données.
  - les modèles (répertoire <div class="code">./app/models</div>) : ce qui concerne les données.
  - les vues (répertoire <code>./app/views</code>) : ce qui concerne l'interface. Dans notre cas, il s'agit de la présentation des pages (en HTML et Ruby embarqué, nous verrons ça plus tard).
 
  - les contrôleurs (répertoire <code>./app/controllers</code>) : concerne la gestion des évenements. Dans notre cas, ce sont les classes qui feront le lien entre les tables (models) et le html (views). Ce qui revient aux appels aux tables via les modèles et la création de variables dont le contenu sera affiché dans les vues.
Dans notre cas, c'est donc principalement les tables des bases de données.
  - les vues (répertoire <div class="code">./app/views</div>) : ce qui concerne l'interface.
 
Dans notre cas, il s'agit de la présentation des pages (en HTML et Ruby embarqué, nous verrons ça plus tard).
  - les contrôleurs (répertoire <div class="code">./app/controllers</div>) : concerne la gestion des évenements.


Pour palier à certaines fonctions qui ne peuvent pas suivre le modèle MVC à la lettre, Rails dispose d'une partie appelée helpers (<code>./app/helpers</code>) qui contient des classes accessibles aux vues et qui contient du code ayant accès aux modèles sans passer par les contrôleurs.
Dans notre cas, ce sont les classes qui feront le lien entre les tables (models) et le html (views).Ce qui revient aux appels aux tables via les modèles et la création de variables dont le contenu sera affiché dans les vues.
 
Pour palier à certaines fonctions qui ne peuvent pas suivre le modèle MVC à la lettre, Rails dispose d'une partie appelée helpers (<div class="code">./app/helpers</div>) qui contient des classes accessibles aux vues et qui contient du code ayant accès aux modèles sans passer par les contrôleurs.


== Création des modèles ==
== Création des modèles ==
Ligne 88 : Ligne 107 :
=== Génération des fichiers relatifs à la table ===
=== Génération des fichiers relatifs à la table ===


On va utilisez le script <code>./script/generate</code> pour générer la première table.
On va utilisez le script <div class="code">./script/generate</div> pour générer la première table.


<code>$ ./script/generate model livre
<div class="code">$ ./script/generate model livre
       exists  app/models/
       exists  app/models/
       exists  test/unit/
       exists  test/unit/
Ligne 108 : Ligne 127 :
       exists  db/migrate
       exists  db/migrate
       create  db/migrate/002_create_auteurs.rb
       create  db/migrate/002_create_auteurs.rb
</code>
</div>


=== Fichiers de migration ===
=== Fichiers de migration ===


Les fichiers de migration/création de table se trouvent dans <code>./db/migrate</code>. Il va falloir les éditez pour ajoutez les champs que vous voulez.
Les fichiers de migration/création de table se trouvent dans <div class="code">./db/migrate</div>. Il va falloir les éditez pour ajoutez les champs que vous voulez.
<div class="aparte">
<div class="aparte">
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.
</div>
</div>


==== Fichier ./db/migrate/001_create_livres.rb ====
==== create_livres.rb ====
 
Fichier ./db/migrate/001_create_livres.rb
<code>class CreateLivres < ActiveRecord::Migration
<div class="code">class CreateLivres < ActiveRecord::Migration
def self.up
def self.up
create_table :livres do |t|
create_table :livres do |t|
Ligne 132 : Ligne 151 :
end
end
end
end
</code>
</div>
 
==== Fichier ./db/migrate/002_create_auteurs.rb ====


<code>class CreateAuteurs < ActiveRecord::Migration
==== create_auteurs.rb ====
Fichier ./db/migrate/002_create_auteurs.rb
<div class="code">class CreateAuteurs < ActiveRecord::Migration
def self.up
def self.up
create_table :auteurs do |t|
create_table :auteurs do |t|
Ligne 147 : Ligne 166 :
drop_table :auteurs
drop_table :auteurs
end
end
end</code>
end</div>




<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :
./db/migrate/001_initial.rb
./db/migrate/001_initial.rb
<code>class Initial < ActiveRecord::Migration
<div class="code">class Initial < ActiveRecord::Migration
def self.up
def self.up
create_table :livres do |t|
create_table :livres do |t|
Ligne 169 : Ligne 188 :
drop_table :auteurs
drop_table :auteurs
end
end
end</code></div>
end</div></div>


=== Génération des tables ===
=== Génération des tables ===


Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.
Toujours dans le repertoire monsite, exécutez <div class="code">rake migrate</div>.
<code>$ rake migrate
<div class="code">$ rake migrate
(in /home/gedsismik/monsite)
(in /home/gedsismik/monsite)
== CreateLivres: migrating ====================================================
** CreateLivres: migrating ************************
-- create_table(:livres)
-- create_table(:livres)
   -> 0.0441s
   -> 0.0441s
== CreateLivres: migrated (0.0442s) ===========================================
** CreateLivres: migrated (0.0442s) ************************


== CreateAuteurs: migrating ===================================================
** CreateAuteurs: migrating ************************
-- create_table(:auteurs)
-- create_table(:auteurs)
   -> 0.0457s
   -> 0.0457s
== CreateAuteurs: migrated (0.0458s) ==========================================
** CreateAuteurs: migrated (0.0458s) ************************
</code>
</div>


Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :
Ligne 192 : Ligne 211 :
  - schema_info
  - schema_info


Cette dernière table contient en fait la version de la base de donnée. Les versions sont incrémentées lors du <code>./script/generate model <nom table></code> et sont contenus dans le nom du fichier <code>./db/migrate/001_initial.rb</code> est donc la version 1 de la base.
Cette dernière table contient en fait la version de la base de donnée. Les versions sont incrémentées lors du <div class="code">./script/generate model <nom table></div> et sont contenus dans le nom du fichier <div class="code">./db/migrate/001_initial.rb</div> est donc la version 1 de la base.


=== Edition des modèles ===
=== Edition des modèles ===
Intéressons-nous aux fichiers <code>./app/models/auteur.rb</code> et <code>./app/models/livre.rb</code>. Ces classes héritant de ActiveRecord::Base, presque tout est déjà fait. Nous allons juste ajouter la relation : "un auteur écrit plusieurs livres". Cette relation se traduit dans <code>./app/models/auteur.rb</code> par :
Intéressons-nous aux fichiers <div class="code">./app/models/auteur.rb</div> et <div class="code">./app/models/livre.rb</div>. Ces classes héritant de ActiveRecord::Base, presque tout est déjà fait. Nous allons juste ajouter la relation : "un auteur écrit plusieurs livres". Cette relation se traduit dans <div class="code">./app/models/auteur.rb</div> par :
<code>class Auteur < ActiveRecord::Base
<div class="code">class Auteur < ActiveRecord::Base
has_many :livre
has_many :livre
end</code>
end</div>


En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <code>./app/models/livre.rb</code> en :
En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <div class="code">./app/models/livre.rb</div> en :
<code>class Livre < ActiveRecord::Base
<div class="code">class Livre < ActiveRecord::Base
belongs_to :auteur
belongs_to :auteur
end</code>
end</div>


Et voilà ! Ca devrait suffir pour les modèles. En effet, Rails fera tout seul le lien entre les deux tables grâce à auteur_id.
Et voilà ! Ca devrait suffir pour les modèles. En effet, Rails fera tout seul le lien entre les deux tables grâce à auteur_id.


== Création d'un contrôleur ==
== Création d'un contrôleur ==
Tout d'abord, utilisons, comme pour les modèles, le script <code>./script/generate</code> :
Tout d'abord, utilisons, comme pour les modèles, le script <div class="code">./script/generate</div> :
<code>$ ./script/generate controller bibliotheque
<div class="code">$ ./script/generate controller bibliotheque
       exists  app/controllers/
       exists  app/controllers/
       exists  app/helpers/
       exists  app/helpers/
Ligne 216 : Ligne 235 :
       create  app/controllers/bibliotheque_controller.rb
       create  app/controllers/bibliotheque_controller.rb
       create  test/functional/bibliotheque_controller_test.rb
       create  test/functional/bibliotheque_controller_test.rb
       create  app/helpers/bibliotheque_helper.rb</code>
       create  app/helpers/bibliotheque_helper.rb</div>


Editons maintenant <code>./app/controllers/bibliotheque_controller.rb</code>. Par défaut, vous avez :
Editons maintenant <div class="code">./app/controllers/bibliotheque_controller.rb</div>. Par défaut, vous avez :
<code>class BibliothequeController < ApplicationController
<div class="code">class BibliothequeController < ApplicationController
end</code>
end</div>


Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.
Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.
<code>class BibliothequeController < ApplicationController
<div class="code">class BibliothequeController < ApplicationController
def index
def index
listeAuteur
listeAuteur
Ligne 246 : Ligne 265 :
end
end
end
end
</code>
</div>


L'action index est l'action par défaut. L'action listeAuteur donnera la liste des auteurs. On constate ici qu'on peut largement se passer d'écrire du SQL dans Rails. @auteurs est une variable qui contiendra tous les auteurs.
L'action index est l'action par défaut. L'action listeAuteur donnera la liste des auteurs. On constate ici qu'on peut largement se passer d'écrire du SQL dans Rails. @auteurs est une variable qui contiendra tous les auteurs.
Ligne 254 : Ligne 273 :
=== Le layout ===
=== Le layout ===


Tout d'abord, créons une layout. Le layout est la structure commune à toutes les pages. Ils se trouvent dans <code>./app/views/layouts/</code>.
Tout d'abord, créons une layout. Le layout est la structure commune à toutes les pages. Ils se trouvent dans <div class="code">./app/views/layouts/</div>.
<code>$ touch app/views/layouts/bibliotheque.rhtml
<div class="code">$ touch app/views/layouts/bibliotheque.rhtml
</code>
</div>
Editons maintenant ce fichier :
Editons maintenant ce fichier :
<code><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd">
<div class="code"><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<html>
<head>
<head>
Ligne 273 : Ligne 292 :
         </div>
         </div>
</body>
</body>
</html></code>
</html></div>
C'est du Ruby embarqué dans du HTML. Pour ceux qui connaissent, c'est un peu le même principe que le PHP. On écrit du HTML et aux endroits où on veut mettre du ruby, on place le code dans une balise <code><% #code %></code>. Si on veut afficher la sortie du code, on place le code dans une balise <code><%= #code %></code>.
C'est du Ruby embarqué dans du HTML. Pour ceux qui connaissent, c'est un peu le même principe que le PHP. On écrit du HTML et aux endroits où on veut mettre du ruby, on place le code dans une balise <div class="code"><% #code %></div>. Si on veut afficher la sortie du code, on place le code dans une balise <div class="code"><%= #code %></div>.


<code><%= @content_for_layout %></code> affichera la partie propre à l'action.
<div class="code"><%= @content_for_layout %></div> affichera la partie propre à l'action.


=== La vue ===
=== La vue ===


Les vues sont dans un répertoire de la forme <code>./app/views/<contrôleur>/</code> et porte le nom <code><action>.rhtml</code>
Les vues sont dans un répertoire de la forme <div class="code">./app/views/<contrôleur>/</div> et porte le nom <div class="code"><action>.rhtml</div>


Créons donc le fichier <code>./app/views/bibliotheque/listeAuteur.rhtml</code> :
Créons donc le fichier <div class="code">./app/views/bibliotheque/listeAuteur.rhtml</div> :


<code><h2>Liste des auteurs</h2>
<div class="code"><h2>Liste des auteurs</h2>
<ul>
<ul>
<%
<%
Ligne 298 : Ligne 317 :
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p>
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p>
<%= submit_tag("Ajouter") %>
<%= submit_tag("Ajouter") %>
<%= end_form_tag %></code>
<%= end_form_tag %></div>


== WebRick ==
== WebRick ==


Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <code>./script/server </code>
Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <div class="code">./script/server </div>
<code>$ ./script/server  
<div class="code">$ ./script/server  
=> Booting WEBrick...
=> Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Rails application started on http://0.0.0.0:3000
Ligne 309 : Ligne 328 :
[2006-10-19 18:32:57] INFO  WEBrick 1.3.1
[2006-10-19 18:32:57] INFO  WEBrick 1.3.1
[2006-10-19 18:32:57] INFO  ruby 1.8.5 (2006-08-25) [i686-linux]
[2006-10-19 18:32:57] INFO  ruby 1.8.5 (2006-08-25) [i686-linux]
[2006-10-19 18:32:57] INFO  WEBrick::HTTPServer#start: pid=26166 port=3000</code>
[2006-10-19 18:32:57] INFO  WEBrick::HTTPServer#start: pid=26166 port=3000</div>
 
Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <div class="code">http://localhost:3000</div>.
Normalement, vous devriez obtenir une page de test. Les url de Rails par défaut se décompose de la sorte <div class="code">http://localhost:3000/<contrôleur>/<action>[/<parametres>]</div>. Tapez donc dans votre navigateur <div class="code">http://localhost:3000/bibliotheque/listeAuteur</div>.


Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <code>http://localhost:3000</code>.
== Pour aller un peu plus loin ==
Normalement, vous devriez obtenir une page de test. Les url de Rails par défaut se décompose de la sorte <code>http://localhost:3000/<contrôleur>/<action>[/<parametres>]</code>. Tapez donc dans votre navigateur <code>http://localhost:3000/bibliotheque/listeAuteur</code>.
Ajoutons le support des livres dans <div class="code">./app/controllers/bibliotheque_controller.rb</div> :
<div class="code">class BibliothequeController < ApplicationController
def index
listeLivre
render_action 'listeLivre'
end
def listeAuteur
@auteurs = Auteur.find(:all, :order => "nom,prenom")
end
 
def listeLivre
@livres = Livre.find(:all, :order => "titre")
@auteurs = Auteur.find(:all, :order => "nom,prenom").map{ |u| [ u.nom + " (" + u.prenom + ")", u.id] }
end
def ajoutAuteur
param = @params['auteur']
auteur = Auteur.new(param)
if auteur.save
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"
else
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"
end
redirect_to :action => 'listeAuteur'
end
def ajoutLivre
param = @params['livre']
livre = Livre.new(param)
if livre.save
flash[:ok] = "Le livre a &eacute;t&eacute; ajout&eacute;"
else
flash[:error] = "Probl&egrave;me à l'ajout du livre"
end
redirect_to :action => 'listeLivre'
end
end
</div>
 
Créons du même coup la vue correspondante à listeLivre <div class="code">./app/views/bibliotheque/listeLivre.rhtml</div> :
<div class="code"><% if @livres.blank? %>
<h2>Liste des ouvrages</h2>
<ul>
<%
@livres.each do |livre|
%><li><%= livre.titre %> - <%= livre.auteur.prenom + " " + livre.auteur.nom %></li><%
end
%>
</ul>
<% else %>
<i>La bibliothèque ne contient aucun livre.</i>
<% end %>
 
<% unless @auteurs.blank? %>
<h2>Ajout d'un livre</h2>
<%= start_form_tag :action => "ajoutLivre" %>
<p><label>Titre : <%= text_field 'livre', 'titre' %></label></p>
<p><label>Nombre d'exemplaire : <%= text_field 'livre', 'quantite' %></label></p>
<p><label>Auteur : <%= select('livre', 'auteur_id', @auteurs) %></label></p>
<%= submit_tag("Ajouter") %>
<%= end_form_tag %>
<% end %></div>


== Les environnements ==
== Les environnements ==
Pour utiliser les différents environnements, vous devez manipuler la variable <div class="code">RAILS_ENV</div>. Par défaut, vous êtes dans le premier environnement du fichier <div class="code">./config/database.yml</div> (à savoir en général development). Pour un <div class="code">rake migrate</div> en production par exemple :
<div class="code">RAILS_ENV=production rake migrate
</div>
notez que l'environnement <div class="code">test</div> efface les tables à chaque <div class="code">rake</div> et que l'environnement <div class="code">production</div> n'affiche aucune information en cas d'exception (vous devez alors vous reportez aux fichiers de log <div class="code">./log/<environnement>.log</div>).
<br/>
<br/>
'''<b>[[Dev-index|@ Retour à la rubrique Développement]]</b>'''
<br/>


= Copyright =
= Copyright =
Copyright &copy; 19/10/2006, GEDsismik
Copyright &copy; 19/10/2006, GEDsismik
{{CC-BY-NC-SA}}
{{CC-BY-SA}}

Version du 5 juin 2012 à 15:41


Ruby On Rails

Ruby On Rails
Monter un projet Ruby On Rails (RoR) pas à pas.

Avant propos

Ruby On Rails (RoR) est un framework web écrit en ruby. Ce document vous présente comment faire un petit projet Ruby On Rails.

On supposera installé et correctement configuré :

- un SGBD supporté par RoR (personnellement, j'utilise MySQL)
- Ruby
- Rails et ses dépendances

Il vous faudra aussi des notions de ruby.

Dans ce document, je mettrais en place un gestionnaire de livre rudimentaire. Le but est de présenter les bases d'un projet Rails. Il est évident que ces informations sont loin d'être exhaustives vue que RoR peut remplir tout un livre de 500 pages.

Mise en place de l'environnement

$ rails monsite
     create  
     create  app/controllers
     create  app/helpers
     create  app/models
     create  app/views/layouts

[...]

Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire. Normalement, il devrait contenir les fichiers et répertoires suivants :

app

components config db doc lib log public Rakefile README script test tmp vendor

Configuration

Si vous n'avez pas de base de donnée, créez-en :

mysql> create database monsite_development;

mysql> create database monsite_test;

mysql> create database monsite_production;

Note : J'en ai crée 3 pour pouvoir utiliser 3 environnements différents. Une seule peut suffir, ca dépend de ce que vous voulez faire.

Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte :

production:
 adapter: mysql
 database: monsite_production
 username: root
 password:
host: localhost

Avec :

  • adapter le type de base de donnée (mysql, postgres, sqlite...)
  • database le nom de la base de donnée
  • username le nom de l'utilisateur de la base de donnée
  • password le mot de passe à la base de donnée
  • host le serveur de base de donnée

Dans le cas de sqlite, on a :

  • adapter le type de base de donnée (sqlite)
  • dbfile nom du fichier de base de donnée

Editez-le en fonction des paramètres de votre base de donnée. Exemple :

production:
 adapter: mysql
 database: monsite_production
 username: gedsismik
 password: mypassword
 host: localhost
socket: /var/run/mysql/mysql.sock
Note : Sous Slackware, j'ai du ajouter la ligne
socket: /var/run/mysql/mysql.sock
sinon il ne trouve pas la socket MySQL.

Modèle MVC

Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :

- les modèles (répertoire

./app/models

) : ce qui concerne les données.

Dans notre cas, c'est donc principalement les tables des bases de données.

- les vues (répertoire

./app/views

) : ce qui concerne l'interface.

Dans notre cas, il s'agit de la présentation des pages (en HTML et Ruby embarqué, nous verrons ça plus tard).

- les contrôleurs (répertoire

./app/controllers

) : concerne la gestion des évenements.

Dans notre cas, ce sont les classes qui feront le lien entre les tables (models) et le html (views).Ce qui revient aux appels aux tables via les modèles et la création de variables dont le contenu sera affiché dans les vues.

Pour palier à certaines fonctions qui ne peuvent pas suivre le modèle MVC à la lettre, Rails dispose d'une partie appelée helpers (

./app/helpers

) qui contient des classes accessibles aux vues et qui contient du code ayant accès aux modèles sans passer par les contrôleurs.

Création des modèles

Génération des fichiers relatifs à la table

On va utilisez le script

./script/generate

pour générer la première table.

$ ./script/generate model livre
     exists  app/models/
     exists  test/unit/
     exists  test/fixtures/
     create  app/models/livre.rb
     create  test/unit/livre_test.rb
     create  test/fixtures/livres.yml
     create  db/migrate
     create  db/migrate/001_create_livres.rb

$ ./script/generate model auteur

     exists  app/models/
     exists  test/unit/
     exists  test/fixtures/
     create  app/models/auteur.rb
     create  test/unit/auteur_test.rb
     create  test/fixtures/auteurs.yml
     exists  db/migrate
     create  db/migrate/002_create_auteurs.rb

Fichiers de migration

Les fichiers de migration/création de table se trouvent dans

./db/migrate

. Il va falloir les éditez pour ajoutez les champs que vous voulez.

Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.

create_livres.rb

Fichier ./db/migrate/001_create_livres.rb

class CreateLivres < ActiveRecord::Migration

def self.up create_table :livres do |t| t.column :titre, :string, :null => false t.column :auteur_id, :integer, :null => false t.column :quantite, :integer, :default => "1" end end

def self.down drop_table :livres end end

create_auteurs.rb

Fichier ./db/migrate/002_create_auteurs.rb

class CreateAuteurs < ActiveRecord::Migration

def self.up create_table :auteurs do |t| t.column :nom, :string t.column :prenom, :string end end

def self.down drop_table :auteurs end

end


Notez que vous pouvez réunir les deux fichiers en un seul :

./db/migrate/001_initial.rb

class Initial < ActiveRecord::Migration

def self.up create_table :livres do |t| t.column :titre, :string, :null => false t.column :auteur_id, :integer, :null => false t.column :quantite, :integer, :default => "1" end create_table :auteurs do |t| t.column :nom, :string, :null => false t.column :prenom, :string end end

def self.down drop_table :livres drop_table :auteurs end

end

Génération des tables

Toujours dans le repertoire monsite, exécutez

rake migrate

.

$ rake migrate

(in /home/gedsismik/monsite)

    • CreateLivres: migrating ************************

-- create_table(:livres)

  -> 0.0441s
    • CreateLivres: migrated (0.0442s) ************************
    • CreateAuteurs: migrating ************************

-- create_table(:auteurs)

  -> 0.0457s
    • CreateAuteurs: migrated (0.0458s) ************************

Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :

- auteurs
- livres
- schema_info

Cette dernière table contient en fait la version de la base de donnée. Les versions sont incrémentées lors du

./script/generate model <nom table>

et sont contenus dans le nom du fichier

./db/migrate/001_initial.rb

est donc la version 1 de la base.

Edition des modèles

Intéressons-nous aux fichiers

./app/models/auteur.rb

et

./app/models/livre.rb

. Ces classes héritant de ActiveRecord::Base, presque tout est déjà fait. Nous allons juste ajouter la relation : "un auteur écrit plusieurs livres". Cette relation se traduit dans

./app/models/auteur.rb

par :

class Auteur < ActiveRecord::Base

has_many :livre

end

En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc

./app/models/livre.rb

en :

class Livre < ActiveRecord::Base

belongs_to :auteur

end

Et voilà ! Ca devrait suffir pour les modèles. En effet, Rails fera tout seul le lien entre les deux tables grâce à auteur_id.

Création d'un contrôleur

Tout d'abord, utilisons, comme pour les modèles, le script

./script/generate

 :

$ ./script/generate controller bibliotheque
     exists  app/controllers/
     exists  app/helpers/
     create  app/views/bibliotheque
     exists  test/functional/
     create  app/controllers/bibliotheque_controller.rb
     create  test/functional/bibliotheque_controller_test.rb
create app/helpers/bibliotheque_helper.rb

Editons maintenant

./app/controllers/bibliotheque_controller.rb

. Par défaut, vous avez :

class BibliothequeController < ApplicationController end

Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.

class BibliothequeController < ApplicationController

def index listeAuteur render_action 'listeAuteur' end

def listeAuteur @auteurs = Auteur.find(:all, :order => "nom,prenom") end

def ajoutAuteur param = @params['auteur'] auteur = Auteur.new(param) if auteur.save flash[:ok] = "L'auteur a été ajouté" else flash[:error] = "Problème à l'ajout de l'auteur" end # ajoutAuteur n'a pas besoin de vue. Une fois l'auteur ajouté # on réaffiche la liste redirect_to :action => 'listeAuteur' end end

L'action index est l'action par défaut. L'action listeAuteur donnera la liste des auteurs. On constate ici qu'on peut largement se passer d'écrire du SQL dans Rails. @auteurs est une variable qui contiendra tous les auteurs.

Mise en place des vues

Le layout

Tout d'abord, créons une layout. Le layout est la structure commune à toutes les pages. Ils se trouvent dans

./app/views/layouts/

.

$ touch app/views/layouts/bibliotheque.rhtml

Editons maintenant ce fichier :

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd">

<html> <head>

       <title>Bibliothèque - <%= controller.action_name %></title>
       <meta name="author" content="GEDsismik">
       <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15">

</head> <body>

Bibliothèque

       

<%= flash[:notice] %>

       <%= @content_for_layout %>

</body>

</html>

C'est du Ruby embarqué dans du HTML. Pour ceux qui connaissent, c'est un peu le même principe que le PHP. On écrit du HTML et aux endroits où on veut mettre du ruby, on place le code dans une balise

<% #code %>

. Si on veut afficher la sortie du code, on place le code dans une balise

<%= #code %>

.

<%= @content_for_layout %>

affichera la partie propre à l'action.

La vue

Les vues sont dans un répertoire de la forme

./app/views/<contrôleur>/

et porte le nom

<action>.rhtml

Créons donc le fichier

./app/views/bibliotheque/listeAuteur.rhtml

 :

Liste des auteurs

    <% @auteurs.each do |auteur| %>
  • <%= auteur.nom + " " + auteur.prenom %>
  • <% end %>

Ajout d'un auteur

<%= start_form_tag :action => "ajoutAuteur" %>

<label>Prénom : <%= text_field 'auteur', 'prenom' %></label>

<label>Nom : <%= text_field 'auteur', 'nom' %></label>

<%= submit_tag("Ajouter") %>

<%= end_form_tag %>

WebRick

Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez

./script/server
$ ./script/server

=> Booting WEBrick... => Rails application started on http://0.0.0.0:3000 => Ctrl-C to shutdown server; call with --help for options [2006-10-19 18:32:57] INFO WEBrick 1.3.1 [2006-10-19 18:32:57] INFO ruby 1.8.5 (2006-08-25) [i686-linux]

[2006-10-19 18:32:57] INFO WEBrick::HTTPServer#start: pid=26166 port=3000

Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez :

. Normalement, vous devriez obtenir une page de test. Les url de Rails par défaut se décompose de la sorte

http://localhost:3000/<contrôleur>/<action>[/<parametres>]

. Tapez donc dans votre navigateur

.

Pour aller un peu plus loin

Ajoutons le support des livres dans

./app/controllers/bibliotheque_controller.rb

 :

class BibliothequeController < ApplicationController

def index listeLivre render_action 'listeLivre' end

def listeAuteur @auteurs = Auteur.find(:all, :order => "nom,prenom") end

def listeLivre @livres = Livre.find(:all, :order => "titre") @auteurs = Auteur.find(:all, :order => "nom,prenom").map{ |u| [ u.nom + " (" + u.prenom + ")", u.id] } end

def ajoutAuteur param = @params['auteur'] auteur = Auteur.new(param) if auteur.save flash[:ok] = "L'auteur a été ajouté" else flash[:error] = "Problème à l'ajout de l'auteur" end redirect_to :action => 'listeAuteur' end

def ajoutLivre param = @params['livre'] livre = Livre.new(param) if livre.save flash[:ok] = "Le livre a été ajouté" else flash[:error] = "Problème à l'ajout du livre" end redirect_to :action => 'listeLivre' end end

Créons du même coup la vue correspondante à listeLivre

./app/views/bibliotheque/listeLivre.rhtml

 :

<% if @livres.blank? %>

Liste des ouvrages

    <% @livres.each do |livre| %>
  • <%= livre.titre %> - <%= livre.auteur.prenom + " " + livre.auteur.nom %>
  • <% end %>

<% else %> La bibliothèque ne contient aucun livre. <% end %>

<% unless @auteurs.blank? %>

Ajout d'un livre

<%= start_form_tag :action => "ajoutLivre" %>

<label>Titre : <%= text_field 'livre', 'titre' %></label>

<label>Nombre d'exemplaire : <%= text_field 'livre', 'quantite' %></label>

<label>Auteur : <%= select('livre', 'auteur_id', @auteurs) %></label>

<%= submit_tag("Ajouter") %> <%= end_form_tag %>

<% end %>

Les environnements

Pour utiliser les différents environnements, vous devez manipuler la variable

RAILS_ENV

. Par défaut, vous êtes dans le premier environnement du fichier

./config/database.yml

(à savoir en général development). Pour un

rake migrate

en production par exemple :

RAILS_ENV=production rake migrate

notez que l'environnement

test

efface les tables à chaque

rake

et que l'environnement

production

n'affiche aucune information en cas d'exception (vous devez alors vous reportez aux fichiers de log

./log/<environnement>.log

).



@ Retour à la rubrique Développement


Copyright

Copyright © 19/10/2006, GEDsismik

Creative Commons License
Creative Commons Attribution iconCreative Commons Share Alike icon
Ce document est publié sous licence Creative Commons
Attribution, Partage à l'identique 4.0 :
https://creativecommons.org/licenses/by-sa/4.0/