https://lea-linux.org/docs/api.php?action=feedcontributions&feedformat=atom&user=GedsismikLea Linux - Contributions [fr]2026-04-06T02:07:08ZContributionsMediaWiki 1.40.1https://lea-linux.org/docs/index.php?title=Mod%C3%A8le:Copy&diff=13927Modèle:Copy2006-11-02T19:07:41Z<p>Gedsismik : /* Copyright */</p>
<hr />
<div>= Copyright =<br />
Copyright &copy; 2006, Misc<br />
{{CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Ruby_On_Rails&diff=13867Ruby On Rails2006-10-19T20:12:20Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Ruby On Rails =<br />
<br />
<div class="leatitre">Ruby On Rails</div><br />
<div class="leapar">par [mailto:gedsismik_at_free_point_fr GEDsismik]</div><br />
<div class="leadesc">Monter un projet Ruby On Rails (RoR) pas à pas.</div><br />
----<br />
<br />
== Avant propos ==<br />
<br />
Ruby On Rails (RoR) est un framework web écrit en ruby. Ce document vous présente comment faire un petit projet Ruby On Rails.<br />
<br />
On supposera installé et correctement configuré :<br />
- un SGBD supporté par RoR (personnellement, j'utilise MySQL)<br />
- Ruby<br />
- Rails et ses dépendances<br />
<br />
Il vous faudra aussi des notions de ruby.<br />
<br />
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.<br />
<br />
== Mise en place de l'environnement ==<br />
<br />
<code>$ rails monsite<br />
create <br />
create app/controllers<br />
create app/helpers<br />
create app/models<br />
create app/views/layouts<br />
[...]<br />
</code><br />
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.<br />
Normalement, il devrait contenir les fichiers et répertoires suivants : <br />
<code>app<br />
components<br />
config<br />
db<br />
doc<br />
lib<br />
log<br />
public<br />
Rakefile<br />
README<br />
script<br />
test<br />
tmp<br />
vendor<br />
</code><br />
<br />
== Configuration ==<br />
<br />
Si vous n'avez pas de base de donnée, créez-en :<br />
<code>mysql> create database monsite_development;<br />
mysql> create database monsite_test;<br />
mysql> create database monsite_production;</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte : <br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: root<br />
password:<br />
host: localhost</code><br />
Avec :<br />
* adapter le type de base de donnée (mysql, postgres, sqlite...)<br />
* database le nom de la base de donnée<br />
* username le nom de l'utilisateur de la base de donnée<br />
* password le mot de passe à la base de donnée<br />
* host le serveur de base de donnée<br />
Dans le cas de sqlite, on a :<br />
* adapter le type de base de donnée (sqlite)<br />
* dbfile nom du fichier de base de donnée <br />
<br />
Editez-le en fonction des paramètres de votre base de donnée. Exemple :<br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: gedsismik<br />
password: mypassword<br />
host: localhost<br />
socket: /var/run/mysql/mysql.sock</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
== Modèle MVC ==<br />
<br />
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :<br />
- 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.<br />
- 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).<br />
- 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.<br />
<br />
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.<br />
<br />
== Création des modèles ==<br />
<br />
=== Génération des fichiers relatifs à la table ===<br />
<br />
On va utilisez le script <code>./script/generate</code> pour générer la première table.<br />
<br />
<code>$ ./script/generate model livre<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/livre.rb<br />
create test/unit/livre_test.rb<br />
create test/fixtures/livres.yml<br />
create db/migrate<br />
create db/migrate/001_create_livres.rb<br />
$ ./script/generate model auteur<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/auteur.rb<br />
create test/unit/auteur_test.rb<br />
create test/fixtures/auteurs.yml<br />
exists db/migrate<br />
create db/migrate/002_create_auteurs.rb<br />
</code><br />
<br />
=== Fichiers de migration ===<br />
<br />
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.<br />
<div class="aparte"><br />
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.<br />
</div><br />
<br />
==== Fichier ./db/migrate/001_create_livres.rb ====<br />
<br />
<code>class CreateLivres < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
end<br />
end<br />
</code><br />
<br />
==== Fichier ./db/migrate/002_create_auteurs.rb ====<br />
<br />
<code>class CreateAuteurs < ActiveRecord::Migration<br />
def self.up<br />
create_table :auteurs do |t|<br />
t.column :nom, :string<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :auteurs<br />
end<br />
end</code><br />
<br />
<br />
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :<br />
./db/migrate/001_initial.rb<br />
<code>class Initial < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
create_table :auteurs do |t|<br />
t.column :nom, :string, :null => false<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
drop_table :auteurs<br />
end<br />
end</code></div><br />
<br />
=== Génération des tables ===<br />
<br />
Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.<br />
<code>$ rake migrate<br />
(in /home/gedsismik/monsite)<br />
== CreateLivres: migrating ====================================================<br />
-- create_table(:livres)<br />
-> 0.0441s<br />
== CreateLivres: migrated (0.0442s) ===========================================<br />
<br />
== CreateAuteurs: migrating ===================================================<br />
-- create_table(:auteurs)<br />
-> 0.0457s<br />
== CreateAuteurs: migrated (0.0458s) ==========================================<br />
</code><br />
<br />
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :<br />
- auteurs<br />
- livres<br />
- schema_info<br />
<br />
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.<br />
<br />
=== Edition des modèles ===<br />
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 :<br />
<code>class Auteur < ActiveRecord::Base<br />
has_many :livre<br />
end</code><br />
<br />
En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <code>./app/models/livre.rb</code> en :<br />
<code>class Livre < ActiveRecord::Base<br />
belongs_to :auteur<br />
end</code><br />
<br />
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.<br />
<br />
== Création d'un contrôleur ==<br />
Tout d'abord, utilisons, comme pour les modèles, le script <code>./script/generate</code> :<br />
<code>$ ./script/generate controller bibliotheque<br />
exists app/controllers/<br />
exists app/helpers/<br />
create app/views/bibliotheque<br />
exists test/functional/<br />
create app/controllers/bibliotheque_controller.rb<br />
create test/functional/bibliotheque_controller_test.rb<br />
create app/helpers/bibliotheque_helper.rb</code><br />
<br />
Editons maintenant <code>./app/controllers/bibliotheque_controller.rb</code>. Par défaut, vous avez :<br />
<code>class BibliothequeController < ApplicationController<br />
end</code><br />
<br />
Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeAuteur<br />
render_action 'listeAuteur'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
# ajoutAuteur n'a pas besoin de vue. Une fois l'auteur ajouté<br />
# on réaffiche la liste <br />
redirect_to :action => 'listeAuteur'<br />
end<br />
end<br />
</code><br />
<br />
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.<br />
<br />
== Mise en place des vues ==<br />
<br />
=== Le layout ===<br />
<br />
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>.<br />
<code>$ touch app/views/layouts/bibliotheque.rhtml<br />
</code><br />
Editons maintenant ce fichier :<br />
<code><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd"><br />
<html><br />
<head><br />
<title>Biblioth&egrave;que - <%= controller.action_name %></title><br />
<meta name="author" content="GEDsismik"><br />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15"><br />
</head><br />
<body><br />
<h1>Biblioth&egrave;que</h1><br />
<br/><br />
<div class="all"><br />
<p style="color: green"><%= flash[:notice] %></p><br />
<%= @content_for_layout %><br />
</div><br />
</body><br />
</html></code><br />
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>.<br />
<br />
<code><%= @content_for_layout %></code> affichera la partie propre à l'action.<br />
<br />
=== La vue ===<br />
<br />
Les vues sont dans un répertoire de la forme <code>./app/views/<contrôleur>/</code> et porte le nom <code><action>.rhtml</code><br />
<br />
Créons donc le fichier <code>./app/views/bibliotheque/listeAuteur.rhtml</code> :<br />
<br />
<code><h2>Liste des auteurs</h2><br />
<ul><br />
<%<br />
@auteurs.each do |auteur|<br />
%><li><%= auteur.nom + " " + auteur.prenom %></li><%<br />
end<br />
%><br />
</ul><br />
<br />
<h2>Ajout d'un auteur</h2><br />
<%= start_form_tag :action => "ajoutAuteur" %><br />
<p><label>Pr&eacute;nom : <%= text_field 'auteur', 'prenom' %></label></p><br />
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %></code><br />
<br />
== WebRick ==<br />
<br />
Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <code>./script/server </code><br />
<code>$ ./script/server <br />
=> Booting WEBrick...<br />
=> Rails application started on http://0.0.0.0:3000<br />
=> Ctrl-C to shutdown server; call with --help for options<br />
[2006-10-19 18:32:57] INFO WEBrick 1.3.1<br />
[2006-10-19 18:32:57] INFO ruby 1.8.5 (2006-08-25) [i686-linux]<br />
[2006-10-19 18:32:57] INFO WEBrick::HTTPServer#start: pid=26166 port=3000</code><br />
<br />
Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <code>http://localhost:3000</code>.<br />
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>.<br />
<br />
== Pour aller un peu plus loin ==<br />
Ajoutons le support des livres dans <code>./app/controllers/bibliotheque_controller.rb</code> :<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeLivre<br />
render_action 'listeLivre'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def listeLivre<br />
@livres = Livre.find(:all, :order => "titre")<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom").map{ |u| [ u.nom + " (" + u.prenom + ")", u.id] }<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
redirect_to :action => 'listeAuteur'<br />
end<br />
<br />
def ajoutLivre<br />
param = @params['livre']<br />
livre = Livre.new(param)<br />
if livre.save<br />
flash[:ok] = "Le livre a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout du livre"<br />
end<br />
redirect_to :action => 'listeLivre'<br />
end<br />
end<br />
</code><br />
<br />
Créons du même coup la vue correspondante à listeLivre <code>./app/views/bibliotheque/listeLivre.rhtml</code> :<br />
<code><% if @livres.blank? %><br />
<h2>Liste des ouvrages</h2><br />
<ul><br />
<%<br />
@livres.each do |livre|<br />
%><li><%= livre.titre %> - <%= livre.auteur.prenom + " " + livre.auteur.nom %></li><%<br />
end<br />
%><br />
</ul><br />
<% else %><br />
<i>La bibliothèque ne contient aucun livre.</i><br />
<% end %><br />
<br />
<% unless @auteurs.blank? %><br />
<h2>Ajout d'un livre</h2><br />
<%= start_form_tag :action => "ajoutLivre" %><br />
<p><label>Titre : <%= text_field 'livre', 'titre' %></label></p><br />
<p><label>Nombre d'exemplaire : <%= text_field 'livre', 'quantite' %></label></p><br />
<p><label>Auteur : <%= select('livre', 'auteur_id', @auteurs) %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %><br />
<% end %></code><br />
<br />
== Les environnements ==<br />
Pour utiliser les différents environnements, vous devez manipuler la variable <code>RAILS_ENV</code>. Par défaut, vous êtes dans le premier environnement du fichier <code>./config/database.yml</code> (à savoir en général development). Pour un <code>rake migrate</code> en production par exemple :<br />
<code>RAILS_ENV=production rake migrate<br />
</code><br />
notez que l'environnement <code>test</code> efface les tables à chaque <code>rake</code> et que l'environnement <code>production</code> n'affiche aucune information en cas d'exception (vous devez alors vous reportez aux fichiers de log <code>./log/<environnement>.log</code>).<br />
<br />
= Copyright =<br />
Copyright &copy; 19/10/2006, GEDsismik<br />
{{CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Ruby_On_Rails&diff=13866Ruby On Rails2006-10-19T19:41:07Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Ruby On Rails =<br />
<br />
<div class="leatitre">Ruby On Rails</div><br />
<div class="leapar">par [mailto:gedsismik_at_free_point_fr GEDsismik]</div><br />
<div class="leadesc">Monter un projet Ruby On Rails (RoR) pas à pas.</div><br />
----<br />
<br />
== Avant propos ==<br />
<br />
Ruby On Rails (RoR) est un framework web écrit en ruby. Ce document vous présente comment faire un petit projet Ruby On Rails.<br />
<br />
On supposera installé et correctement configuré :<br />
- un SGBD supporté par RoR (personnellement, j'utilise MySQL)<br />
- Ruby<br />
- Rails et ses dépendances<br />
<br />
Il vous faudra aussi des notions de ruby.<br />
<br />
== Mise en place de l'environnement ==<br />
<br />
<code>$ rails monsite<br />
create <br />
create app/controllers<br />
create app/helpers<br />
create app/models<br />
create app/views/layouts<br />
[...]<br />
</code><br />
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.<br />
Normalement, il devrait contenir les fichiers et répertoires suivants : <br />
<code>app<br />
components<br />
config<br />
db<br />
doc<br />
lib<br />
log<br />
public<br />
Rakefile<br />
README<br />
script<br />
test<br />
tmp<br />
vendor<br />
</code><br />
<br />
== Configuration ==<br />
<br />
Si vous n'avez pas de base de donnée, créez-en :<br />
<code>mysql> create database monsite_development;<br />
mysql> create database monsite_test;<br />
mysql> create database monsite_production;</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte : <br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: root<br />
password:<br />
host: localhost</code><br />
Editez-le en fonction des paramètres de votre base de donnée<br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: gedsismik<br />
password: mypassord<br />
host: localhost<br />
socket: /var/run/mysql/mysql.sock</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
== Modèle MVC ==<br />
<br />
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :<br />
- 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.<br />
- 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).<br />
- 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.<br />
<br />
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.<br />
<br />
== Création des modèles ==<br />
<br />
=== Génération des fichiers relatifs à la table ===<br />
<br />
On va utilisez le script <code>./script/generate</code> pour générer la première table.<br />
<br />
<code>$ ./script/generate model livre<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/livre.rb<br />
create test/unit/livre_test.rb<br />
create test/fixtures/livres.yml<br />
create db/migrate<br />
create db/migrate/001_create_livres.rb<br />
$ ./script/generate model auteur<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/auteur.rb<br />
create test/unit/auteur_test.rb<br />
create test/fixtures/auteurs.yml<br />
exists db/migrate<br />
create db/migrate/002_create_auteurs.rb<br />
</code><br />
<br />
=== Fichiers de migration ===<br />
<br />
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.<br />
<div class="aparte"><br />
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.<br />
</div><br />
<br />
==== Fichier ./db/migrate/001_create_livres.rb ====<br />
<br />
<code>class CreateLivres < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
end<br />
end<br />
</code><br />
<br />
==== Fichier ./db/migrate/002_create_auteurs.rb ====<br />
<br />
<code>class CreateAuteurs < ActiveRecord::Migration<br />
def self.up<br />
create_table :auteurs do |t|<br />
t.column :nom, :string<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :auteurs<br />
end<br />
end</code><br />
<br />
<br />
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :<br />
./db/migrate/001_initial.rb<br />
<code>class Initial < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
create_table :auteurs do |t|<br />
t.column :nom, :string, :null => false<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
drop_table :auteurs<br />
end<br />
end</code></div><br />
<br />
=== Génération des tables ===<br />
<br />
Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.<br />
<code>$ rake migrate<br />
(in /home/gedsismik/monsite)<br />
== CreateLivres: migrating ====================================================<br />
-- create_table(:livres)<br />
-> 0.0441s<br />
== CreateLivres: migrated (0.0442s) ===========================================<br />
<br />
== CreateAuteurs: migrating ===================================================<br />
-- create_table(:auteurs)<br />
-> 0.0457s<br />
== CreateAuteurs: migrated (0.0458s) ==========================================<br />
</code><br />
<br />
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :<br />
- auteurs<br />
- livres<br />
- schema_info<br />
<br />
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.<br />
<br />
=== Edition des modèles ===<br />
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 :<br />
<code>class Auteur < ActiveRecord::Base<br />
has_many :livre<br />
end</code><br />
<br />
En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <code>./app/models/livre.rb</code> en :<br />
<code>class Livre < ActiveRecord::Base<br />
belongs_to :auteur<br />
end</code><br />
<br />
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.<br />
<br />
== Création d'un contrôleur ==<br />
Tout d'abord, utilisons, comme pour les modèles, le script <code>./script/generate</code> :<br />
<code>$ ./script/generate controller bibliotheque<br />
exists app/controllers/<br />
exists app/helpers/<br />
create app/views/bibliotheque<br />
exists test/functional/<br />
create app/controllers/bibliotheque_controller.rb<br />
create test/functional/bibliotheque_controller_test.rb<br />
create app/helpers/bibliotheque_helper.rb</code><br />
<br />
Editons maintenant <code>./app/controllers/bibliotheque_controller.rb</code>. Par défaut, vous avez :<br />
<code>class BibliothequeController < ApplicationController<br />
end</code><br />
<br />
Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeAuteur<br />
render_action 'listeAuteur'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
# ajoutAuteur n'a pas besoin de vue. Une fois l'auteur ajouté<br />
# on réaffiche la liste <br />
redirect_to :action => 'listeAuteur'<br />
end<br />
end<br />
</code><br />
<br />
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.<br />
<br />
== Mise en place des vues ==<br />
<br />
=== Le layout ===<br />
<br />
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>.<br />
<code>$ touch app/views/layouts/bibliotheque.rhtml<br />
</code><br />
Editons maintenant ce fichier :<br />
<code><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd"><br />
<html><br />
<head><br />
<title>Biblioth&egrave;que - <%= controller.action_name %></title><br />
<meta name="author" content="GEDsismik"><br />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15"><br />
</head><br />
<body><br />
<h1>Biblioth&egrave;que</h1><br />
<br/><br />
<div class="all"><br />
<p style="color: green"><%= flash[:notice] %></p><br />
<%= @content_for_layout %><br />
</div><br />
</body><br />
</html></code><br />
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>.<br />
<br />
<code><%= @content_for_layout %></code> affichera la partie propre à l'action.<br />
<br />
=== La vue ===<br />
<br />
Les vues sont dans un répertoire de la forme <code>./app/views/<contrôleur>/</code> et porte le nom <code><action>.rhtml</code><br />
<br />
Créons donc le fichier <code>./app/views/bibliotheque/listeAuteur.rhtml</code> :<br />
<br />
<code><h2>Liste des auteurs</h2><br />
<ul><br />
<%<br />
@auteurs.each do |auteur|<br />
%><li><%= auteur.nom + " " + auteur.prenom %></li><%<br />
end<br />
%><br />
</ul><br />
<br />
<h2>Ajout d'un auteur</h2><br />
<%= start_form_tag :action => "ajoutAuteur" %><br />
<p><label>Pr&eacute;nom : <%= text_field 'auteur', 'prenom' %></label></p><br />
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %></code><br />
<br />
== WebRick ==<br />
<br />
Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <code>./script/server </code><br />
<code>$ ./script/server <br />
=> Booting WEBrick...<br />
=> Rails application started on http://0.0.0.0:3000<br />
=> Ctrl-C to shutdown server; call with --help for options<br />
[2006-10-19 18:32:57] INFO WEBrick 1.3.1<br />
[2006-10-19 18:32:57] INFO ruby 1.8.5 (2006-08-25) [i686-linux]<br />
[2006-10-19 18:32:57] INFO WEBrick::HTTPServer#start: pid=26166 port=3000</code><br />
<br />
Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <code>http://localhost:3000</code>.<br />
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>.<br />
<br />
== Pour aller un peu plus loin ==<br />
Ajoutons le support des livres dans <code>./app/controllers/bibliotheque_controller.rb</code> :<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeLivre<br />
render_action 'listeLivre'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def listeLivre<br />
@livres = Livre.find(:all, :order => "titre")<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom").map{ |u| [ u.nom + " (" + u.prenom + ")", u.id] }<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
redirect_to :action => 'listeAuteur'<br />
end<br />
<br />
def ajoutLivre<br />
param = @params['livre']<br />
livre = Livre.new(param)<br />
if livre.save<br />
flash[:ok] = "Le livre a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout du livre"<br />
end<br />
redirect_to :action => 'listeLivre'<br />
end<br />
end<br />
</code><br />
<br />
Créons du même coup la vue correspondante à listeLivre <code>./app/views/bibliotheque/listeLivre.rhtml</code> :<br />
<code><% if @livres.blank? %><br />
<h2>Liste des ouvrages</h2><br />
<ul><br />
<%<br />
@livres.each do |livre|<br />
%><li><%= livre.titre %> - <%= livre.auteur.prenom + " " + livre.auteur.nom %></li><%<br />
end<br />
%><br />
</ul><br />
<% else %><br />
<i>La bibliothèque ne contient aucun livre.</i><br />
<% end %><br />
<br />
<% unless @auteurs.blank? %><br />
<h2>Ajout d'un livre</h2><br />
<%= start_form_tag :action => "ajoutLivre" %><br />
<p><label>Titre : <%= text_field 'livre', 'titre' %></label></p><br />
<p><label>Nombre d'exemplaire : <%= text_field 'livre', 'quantite' %></label></p><br />
<p><label>Auteur : <%= select('livre', 'auteur_id', @auteurs) %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %><br />
<% end %></code><br />
<br />
== Les environnements ==<br />
Pour utiliser les différents environnements, vous devez manipuler la variable <code>RAILS_ENV</code>. Par défaut, vous êtes dans le premier environnement du fichier <code>./config/database.yml</code> (à savoir en général development). Pour un <code>rake migrate</code> en production par exemple :<br />
<code>RAILS_ENV=production rake migrate<br />
</code><br />
notez que l'environnement <code>test</code> efface les tables à chaque <code>rake</code> et que l'environnement <code>production</code> n'affiche aucune information en cas d'exception (vous devez alors vous reportez aux fichiers de log <code>./log/<environnement>.log</code>).<br />
<br />
= Copyright =<br />
Copyright &copy; 19/10/2006, GEDsismik<br />
{{CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Mod%C3%A8le:Copy&diff=13865Modèle:Copy2006-10-19T19:40:27Z<p>Gedsismik : /* Copyright */</p>
<hr />
<div>= Copyright =<br />
Copyright &copy; 2006, GEDsismik<br />
{{CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Ruby_On_Rails&diff=13861Ruby On Rails2006-10-19T19:22:04Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Ruby On Rails =<br />
<br />
<div class="leatitre">Ruby On Rails</div><br />
<div class="leapar">par [mailto:gedsismik_at_free_point_fr GEDsismik]</div><br />
<div class="leadesc">Monter un projet Ruby On Rails (RoR) pas à pas.</div><br />
----<br />
<br />
== Avant propos ==<br />
<br />
Ruby On Rails (RoR) est un framework web écrit en ruby. Ce document vous présente comment faire un petit projet Ruby On Rails.<br />
<br />
On supposera installé et correctement configuré :<br />
- un SGBD supporté par RoR (personnellement, j'utilise MySQL)<br />
- Ruby<br />
- Rails et ses dépendances<br />
<br />
Il vous faudra aussi des notions de ruby.<br />
<br />
== Mise en place de l'environnement ==<br />
<br />
<code>$ rails monsite<br />
create <br />
create app/controllers<br />
create app/helpers<br />
create app/models<br />
create app/views/layouts<br />
[...]<br />
</code><br />
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.<br />
Normalement, il devrait contenir les fichiers et répertoires suivants : <br />
<code>app<br />
components<br />
config<br />
db<br />
doc<br />
lib<br />
log<br />
public<br />
Rakefile<br />
README<br />
script<br />
test<br />
tmp<br />
vendor<br />
</code><br />
<br />
== Configuration ==<br />
<br />
Si vous n'avez pas de base de donnée, créez-en :<br />
<code>mysql> create database monsite_development;<br />
mysql> create database monsite_test;<br />
mysql> create database monsite_production;</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte : <br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: root<br />
password:<br />
host: localhost</code><br />
Editez-le en fonction des paramètres de votre base de donnée<br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: gedsismik<br />
password: mypassord<br />
host: localhost<br />
socket: /var/run/mysql/mysql.sock</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
== Modèle MVC ==<br />
<br />
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :<br />
- 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.<br />
- 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).<br />
- 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.<br />
<br />
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.<br />
<br />
== Création des modèles ==<br />
<br />
=== Génération des fichiers relatifs à la table ===<br />
<br />
On va utilisez le script <code>./script/generate</code> pour générer la première table.<br />
<br />
<code>$ ./script/generate model livre<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/livre.rb<br />
create test/unit/livre_test.rb<br />
create test/fixtures/livres.yml<br />
create db/migrate<br />
create db/migrate/001_create_livres.rb<br />
$ ./script/generate model auteur<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/auteur.rb<br />
create test/unit/auteur_test.rb<br />
create test/fixtures/auteurs.yml<br />
exists db/migrate<br />
create db/migrate/002_create_auteurs.rb<br />
</code><br />
<br />
=== Fichiers de migration ===<br />
<br />
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.<br />
<div class="aparte"><br />
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.<br />
</div><br />
<br />
==== Fichier ./db/migrate/001_create_livres.rb ====<br />
<br />
<code>class CreateLivres < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
end<br />
end<br />
</code><br />
<br />
==== Fichier ./db/migrate/002_create_auteurs.rb ====<br />
<br />
<code>class CreateAuteurs < ActiveRecord::Migration<br />
def self.up<br />
create_table :auteurs do |t|<br />
t.column :nom, :string<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :auteurs<br />
end<br />
end</code><br />
<br />
<br />
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :<br />
./db/migrate/001_initial.rb<br />
<code>class Initial < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
create_table :auteurs do |t|<br />
t.column :nom, :string, :null => false<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
drop_table :auteurs<br />
end<br />
end</code></div><br />
<br />
=== Génération des tables ===<br />
<br />
Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.<br />
<code>$ rake migrate<br />
(in /home/gedsismik/monsite)<br />
== CreateLivres: migrating ====================================================<br />
-- create_table(:livres)<br />
-> 0.0441s<br />
== CreateLivres: migrated (0.0442s) ===========================================<br />
<br />
== CreateAuteurs: migrating ===================================================<br />
-- create_table(:auteurs)<br />
-> 0.0457s<br />
== CreateAuteurs: migrated (0.0458s) ==========================================<br />
</code><br />
<br />
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :<br />
- auteurs<br />
- livres<br />
- schema_info<br />
<br />
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.<br />
<br />
=== Edition des modèles ===<br />
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 :<br />
<code>class Auteur < ActiveRecord::Base<br />
has_many :livre<br />
end</code><br />
<br />
En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <code>./app/models/livre.rb</code> en :<br />
<code>class Livre < ActiveRecord::Base<br />
belongs_to :auteur<br />
end</code><br />
<br />
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.<br />
<br />
== Création d'un contrôleur ==<br />
Tout d'abord, utilisons, comme pour les modèles, le script <code>./script/generate</code> :<br />
<code>$ ./script/generate controller bibliotheque<br />
exists app/controllers/<br />
exists app/helpers/<br />
create app/views/bibliotheque<br />
exists test/functional/<br />
create app/controllers/bibliotheque_controller.rb<br />
create test/functional/bibliotheque_controller_test.rb<br />
create app/helpers/bibliotheque_helper.rb</code><br />
<br />
Editons maintenant <code>./app/controllers/bibliotheque_controller.rb</code>. Par défaut, vous avez :<br />
<code>class BibliothequeController < ApplicationController<br />
end</code><br />
<br />
Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeAuteur<br />
render_action 'listeAuteur'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
# ajoutAuteur n'a pas besoin de vue. Une fois l'auteur ajouté<br />
# on réaffiche la liste <br />
redirect_to :action => 'listeAuteur'<br />
end<br />
end<br />
</code><br />
<br />
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.<br />
<br />
== Mise en place des vues ==<br />
<br />
=== Le layout ===<br />
<br />
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>.<br />
<code>$ touch app/views/layouts/bibliotheque.rhtml<br />
</code><br />
Editons maintenant ce fichier :<br />
<code><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd"><br />
<html><br />
<head><br />
<title>Biblioth&egrave;que - <%= controller.action_name %></title><br />
<meta name="author" content="GEDsismik"><br />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15"><br />
</head><br />
<body><br />
<h1>Biblioth&egrave;que</h1><br />
<br/><br />
<div class="all"><br />
<p style="color: green"><%= flash[:notice] %></p><br />
<%= @content_for_layout %><br />
</div><br />
</body><br />
</html></code><br />
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>.<br />
<br />
<code><%= @content_for_layout %></code> affichera la partie propre à l'action.<br />
<br />
=== La vue ===<br />
<br />
Les vues sont dans un répertoire de la forme <code>./app/views/<contrôleur>/</code> et porte le nom <code><action>.rhtml</code><br />
<br />
Créons donc le fichier <code>./app/views/bibliotheque/listeAuteur.rhtml</code> :<br />
<br />
<code><h2>Liste des auteurs</h2><br />
<ul><br />
<%<br />
@auteurs.each do |auteur|<br />
%><li><%= auteur.nom + " " + auteur.prenom %></li><%<br />
end<br />
%><br />
</ul><br />
<br />
<h2>Ajout d'un auteur</h2><br />
<%= start_form_tag :action => "ajoutAuteur" %><br />
<p><label>Pr&eacute;nom : <%= text_field 'auteur', 'prenom' %></label></p><br />
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %></code><br />
<br />
== WebRick ==<br />
<br />
Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <code>./script/server </code><br />
<code>$ ./script/server <br />
=> Booting WEBrick...<br />
=> Rails application started on http://0.0.0.0:3000<br />
=> Ctrl-C to shutdown server; call with --help for options<br />
[2006-10-19 18:32:57] INFO WEBrick 1.3.1<br />
[2006-10-19 18:32:57] INFO ruby 1.8.5 (2006-08-25) [i686-linux]<br />
[2006-10-19 18:32:57] INFO WEBrick::HTTPServer#start: pid=26166 port=3000</code><br />
<br />
Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <code>http://localhost:3000</code>.<br />
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>.<br />
<br />
== Pour aller un peu plus loin ==<br />
Ajoutons le support des livres dans <code>./app/controllers/bibliotheque_controller.rb</code> :<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeLivre<br />
render_action 'listeLivre'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def listeLivre<br />
@livres = Livre.find(:all, :order => "titre")<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom").map{ |u| [ u.nom + " (" + u.prenom + ")", u.id] }<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
redirect_to :action => 'listeAuteur'<br />
end<br />
<br />
def ajoutLivre<br />
param = @params['livre']<br />
livre = Livre.new(param)<br />
if livre.save<br />
flash[:ok] = "Le livre a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout du livre"<br />
end<br />
redirect_to :action => 'listeLivre'<br />
end<br />
end<br />
</code><br />
<br />
Créons du même coup la vue correspondante à listeLivre <code>./app/views/bibliotheque/listeLivre.rhtml</code> :<br />
<code><% if @livres.blank? %><br />
<h2>Liste des ouvrages</h2><br />
<ul><br />
<%<br />
@livres.each do |livre|<br />
%><li><%= livre.titre %> - <%= livre.auteur.prenom + " " + livre.auteur.nom %></li><%<br />
end<br />
%><br />
</ul><br />
<% else %><br />
<i>La bibliothèque ne contient aucun livre.</i><br />
<% end %><br />
<br />
<% unless @auteurs.blank? %><br />
<h2>Ajout d'un livre</h2><br />
<%= start_form_tag :action => "ajoutLivre" %><br />
<p><label>Titre : <%= text_field 'livre', 'titre' %></label></p><br />
<p><label>Nombre d'exemplaire : <%= text_field 'livre', 'quantite' %></label></p><br />
<p><label>Auteur : <%= select('livre', 'auteur_id', @auteurs) %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %><br />
<% end %></code><br />
<br />
== Les environnements ==<br />
Pour utiliser les différents environnements, vous devez manipuler la variable <code>RAILS_ENV</code>. Par défaut, vous êtes dans le premier environnement du fichier <code>./config/database.yml</code> (à savoir en général development). Pour un <code>rake migrate</code> en production par exemple :<br />
<code>RAILS_ENV=production rake migrate<br />
</code><br />
notez que l'environnement <code>test</code> efface les tables à chaque <code>rake</code> et que l'environnement <code>production</code> n'affiche aucune information en cas d'exception (vous devez alors vous reportez aux fichiers de log <code>./log/<environnement>.log</code>).<br />
<br />
= Copyright =<br />
Copyright &copy; 19/10/2006, GEDsismik<br />
{{CC-BY-NC-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Ruby_On_Rails&diff=13860Ruby On Rails2006-10-19T19:12:12Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Ruby On Rails =<br />
<br />
<div class="leatitre">Ruby On Rails</div><br />
<div class="leapar">par [mailto:gedsismik_at_free_point_fr GEDsismik]</div><br />
<div class="leadesc">Monter un projet Ruby On Rails (RoR) pas à pas.</div><br />
----<br />
<br />
== Avant propos ==<br />
<br />
Ruby On Rails (RoR) est un framework web écrit en ruby. Ce document vous présente comment faire un petit projet Ruby On Rails.<br />
<br />
On supposera installé et correctement configuré :<br />
- un SGBD supporté par RoR (personnellement, j'utilise MySQL)<br />
- Ruby<br />
- Rails et ses dépendances<br />
<br />
Il vous faudra aussi des notions de ruby.<br />
<br />
== Mise en place de l'environnement ==<br />
<br />
<code>$ rails monsite<br />
create <br />
create app/controllers<br />
create app/helpers<br />
create app/models<br />
create app/views/layouts<br />
[...]<br />
</code><br />
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.<br />
Normalement, il devrait contenir les fichiers et répertoires suivants : <br />
<code>app<br />
components<br />
config<br />
db<br />
doc<br />
lib<br />
log<br />
public<br />
Rakefile<br />
README<br />
script<br />
test<br />
tmp<br />
vendor<br />
</code><br />
<br />
== Configuration ==<br />
<br />
Si vous n'avez pas de base de donnée, créez-en :<br />
<code>mysql> create database monsite_development;<br />
mysql> create database monsite_test;<br />
mysql> create database monsite_production;</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte : <br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: root<br />
password:<br />
host: localhost</code><br />
Editez-le en fonction des paramètres de votre base de donnée<br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: gedsismik<br />
password: mypassord<br />
host: localhost<br />
socket: /var/run/mysql/mysql.sock</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
== Modèle MVC ==<br />
<br />
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :<br />
- 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.<br />
- 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).<br />
- 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.<br />
<br />
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.<br />
<br />
== Création des modèles ==<br />
<br />
=== Génération des fichiers relatifs à la table ===<br />
<br />
On va utilisez le script <code>./script/generate</code> pour générer la première table.<br />
<br />
<code>$ ./script/generate model livre<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/livre.rb<br />
create test/unit/livre_test.rb<br />
create test/fixtures/livres.yml<br />
create db/migrate<br />
create db/migrate/001_create_livres.rb<br />
$ ./script/generate model auteur<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/auteur.rb<br />
create test/unit/auteur_test.rb<br />
create test/fixtures/auteurs.yml<br />
exists db/migrate<br />
create db/migrate/002_create_auteurs.rb<br />
</code><br />
<br />
=== Fichiers de migration ===<br />
<br />
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.<br />
<div class="aparte"><br />
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.<br />
</div><br />
<br />
==== Fichier ./db/migrate/001_create_livres.rb ====<br />
<br />
<code>class CreateLivres < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
end<br />
end<br />
</code><br />
<br />
==== Fichier ./db/migrate/002_create_auteurs.rb ====<br />
<br />
<code>class CreateAuteurs < ActiveRecord::Migration<br />
def self.up<br />
create_table :auteurs do |t|<br />
t.column :nom, :string<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :auteurs<br />
end<br />
end</code><br />
<br />
<br />
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :<br />
./db/migrate/001_initial.rb<br />
<code>class Initial < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
create_table :auteurs do |t|<br />
t.column :nom, :string, :null => false<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
drop_table :auteurs<br />
end<br />
end</code></div><br />
<br />
=== Génération des tables ===<br />
<br />
Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.<br />
<code>$ rake migrate<br />
(in /home/gedsismik/monsite)<br />
== CreateLivres: migrating ====================================================<br />
-- create_table(:livres)<br />
-> 0.0441s<br />
== CreateLivres: migrated (0.0442s) ===========================================<br />
<br />
== CreateAuteurs: migrating ===================================================<br />
-- create_table(:auteurs)<br />
-> 0.0457s<br />
== CreateAuteurs: migrated (0.0458s) ==========================================<br />
</code><br />
<br />
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :<br />
- auteurs<br />
- livres<br />
- schema_info<br />
<br />
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.<br />
<br />
=== Edition des modèles ===<br />
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 :<br />
<code>class Auteur < ActiveRecord::Base<br />
has_many :livre<br />
end</code><br />
<br />
En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <code>./app/models/livre.rb</code> en :<br />
<code>class Livre < ActiveRecord::Base<br />
belongs_to :auteur<br />
end</code><br />
<br />
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.<br />
<br />
== Création d'un contrôleur ==<br />
Tout d'abord, utilisons, comme pour les modèles, le script <code>./script/generate</code> :<br />
<code>$ ./script/generate controller bibliotheque<br />
exists app/controllers/<br />
exists app/helpers/<br />
create app/views/bibliotheque<br />
exists test/functional/<br />
create app/controllers/bibliotheque_controller.rb<br />
create test/functional/bibliotheque_controller_test.rb<br />
create app/helpers/bibliotheque_helper.rb</code><br />
<br />
Editons maintenant <code>./app/controllers/bibliotheque_controller.rb</code>. Par défaut, vous avez :<br />
<code>class BibliothequeController < ApplicationController<br />
end</code><br />
<br />
Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeAuteur<br />
render_action 'listeAuteur'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
# ajoutAuteur n'a pas besoin de vue. Une fois l'auteur ajouté<br />
# on réaffiche la liste <br />
redirect_to :action => 'listeAuteur'<br />
end<br />
end<br />
</code><br />
<br />
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.<br />
<br />
== Mise en place des vues ==<br />
<br />
=== Le layout ===<br />
<br />
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>.<br />
<code>$ touch app/views/layouts/bibliotheque.rhtml<br />
</code><br />
Editons maintenant ce fichier :<br />
<code><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd"><br />
<html><br />
<head><br />
<title>Biblioth&egrave;que - <%= controller.action_name %></title><br />
<meta name="author" content="GEDsismik"><br />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15"><br />
</head><br />
<body><br />
<h1>Biblioth&egrave;que</h1><br />
<br/><br />
<div class="all"><br />
<p style="color: green"><%= flash[:notice] %></p><br />
<%= @content_for_layout %><br />
</div><br />
</body><br />
</html></code><br />
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>.<br />
<br />
<code><%= @content_for_layout %></code> affichera la partie propre à l'action.<br />
<br />
=== La vue ===<br />
<br />
Les vues sont dans un répertoire de la forme <code>./app/views/<contrôleur>/</code> et porte le nom <code><action>.rhtml</code><br />
<br />
Créons donc le fichier <code>./app/views/bibliotheque/listeAuteur.rhtml</code> :<br />
<br />
<code><h2>Liste des auteurs</h2><br />
<ul><br />
<%<br />
@auteurs.each do |auteur|<br />
%><li><%= auteur.nom + " " + auteur.prenom %></li><%<br />
end<br />
%><br />
</ul><br />
<br />
<h2>Ajout d'un auteur</h2><br />
<%= start_form_tag :action => "ajoutAuteur" %><br />
<p><label>Pr&eacute;nom : <%= text_field 'auteur', 'prenom' %></label></p><br />
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %></code><br />
<br />
== WebRick ==<br />
<br />
Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <code>./script/server </code><br />
<code>$ ./script/server <br />
=> Booting WEBrick...<br />
=> Rails application started on http://0.0.0.0:3000<br />
=> Ctrl-C to shutdown server; call with --help for options<br />
[2006-10-19 18:32:57] INFO WEBrick 1.3.1<br />
[2006-10-19 18:32:57] INFO ruby 1.8.5 (2006-08-25) [i686-linux]<br />
[2006-10-19 18:32:57] INFO WEBrick::HTTPServer#start: pid=26166 port=3000</code><br />
<br />
Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <code>http://localhost:3000</code>.<br />
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>.<br />
<br />
== Les environnements ==<br />
Pour utiliser les différents environnements, vous devez manipuler la variable <code>RAILS_ENV</code>. Par défaut, vous êtes dans le premier environnement du fichier <code>./config/database.yml</code> (à savoir en général development). Pour un <code>rake migrate</code> en production par exemple :<br />
<code>RAILS_ENV=production rake migrate<br />
</code><br />
notez que l'environnement <code>test</code> efface les tables à chaque <code>rake</code> et que l'environnement <code>production</code> n'affiche aucune information en cas d'exception (vous devez alors vous reportez aux fichiers de log <code>./log/<environnement>.log</code>).<br />
<br />
= Copyright =<br />
Copyright &copy; 19/10/2006, GEDsismik<br />
{{CC-BY-NC-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Ruby_On_Rails&diff=13859Ruby On Rails2006-10-19T19:01:19Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Ruby On Rails =<br />
<br />
<div class="leatitre">Ruby On Rails</div><br />
<div class="leapar">par [mailto:gedsismik_at_free_point_fr GEDsismik]</div><br />
<div class="leadesc">Monter un projet Ruby On Rails (RoR) pas à pas.</div><br />
----<br />
<br />
== Avant propos ==<br />
<br />
Ruby On Rails (RoR) est un framework web écrit en ruby. Ce document vous présente comment faire un petit projet Ruby On Rails.<br />
<br />
On supposera installé et correctement configuré :<br />
- un SGBD supporté par RoR (personnellement, j'utilise MySQL)<br />
- Ruby<br />
- Rails et ses dépendances<br />
<br />
Il vous faudra aussi des notions de ruby.<br />
<br />
== Mise en place de l'environnement ==<br />
<br />
<code>$ rails monsite<br />
create <br />
create app/controllers<br />
create app/helpers<br />
create app/models<br />
create app/views/layouts<br />
[...]<br />
</code><br />
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.<br />
Normalement, il devrait contenir les fichiers et répertoires suivants : <br />
<code>app<br />
components<br />
config<br />
db<br />
doc<br />
lib<br />
log<br />
public<br />
Rakefile<br />
README<br />
script<br />
test<br />
tmp<br />
vendor<br />
</code><br />
<br />
== Configuration ==<br />
<br />
Si vous n'avez pas de base de donnée, créez-en :<br />
<code>mysql> create database monsite_development;<br />
mysql> create database monsite_test;<br />
mysql> create database monsite_production;</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte : <br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: root<br />
password:<br />
host: localhost</code><br />
Editez-le en fonction des paramètres de votre base de donnée<br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: gedsismik<br />
password: mypassord<br />
host: localhost<br />
socket: /var/run/mysql/mysql.sock</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
== Modèle MVC ==<br />
<br />
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :<br />
- 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.<br />
- 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).<br />
- 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.<br />
<br />
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.<br />
<br />
== Création des modèles ==<br />
<br />
=== Génération des fichiers relatifs à la table ===<br />
<br />
On va utilisez le script <code>./script/generate</code> pour générer la première table.<br />
<br />
<code>$ ./script/generate model livre<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/livre.rb<br />
create test/unit/livre_test.rb<br />
create test/fixtures/livres.yml<br />
create db/migrate<br />
create db/migrate/001_create_livres.rb<br />
$ ./script/generate model auteur<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/auteur.rb<br />
create test/unit/auteur_test.rb<br />
create test/fixtures/auteurs.yml<br />
exists db/migrate<br />
create db/migrate/002_create_auteurs.rb<br />
</code><br />
<br />
=== Fichiers de migration ===<br />
<br />
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.<br />
<div class="aparte"><br />
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.<br />
</div><br />
<br />
==== Fichier ./db/migrate/001_create_livres.rb ====<br />
<br />
<code>class CreateLivres < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
end<br />
end<br />
</code><br />
<br />
==== Fichier ./db/migrate/002_create_auteurs.rb ====<br />
<br />
<code>class CreateAuteurs < ActiveRecord::Migration<br />
def self.up<br />
create_table :auteurs do |t|<br />
t.column :nom, :string<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :auteurs<br />
end<br />
end</code><br />
<br />
<br />
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :<br />
./db/migrate/001_initial.rb<br />
<code>class Initial < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
create_table :auteurs do |t|<br />
t.column :nom, :string, :null => false<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
drop_table :auteurs<br />
end<br />
end</code></div><br />
<br />
=== Génération des tables ===<br />
<br />
Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.<br />
<code>$ rake migrate<br />
(in /home/gedsismik/monsite)<br />
== CreateLivres: migrating ====================================================<br />
-- create_table(:livres)<br />
-> 0.0441s<br />
== CreateLivres: migrated (0.0442s) ===========================================<br />
<br />
== CreateAuteurs: migrating ===================================================<br />
-- create_table(:auteurs)<br />
-> 0.0457s<br />
== CreateAuteurs: migrated (0.0458s) ==========================================<br />
</code><br />
<br />
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :<br />
- auteurs<br />
- livres<br />
- schema_info<br />
<br />
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.<br />
<br />
=== Edition des modèles ===<br />
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 :<br />
<code>class Auteur < ActiveRecord::Base<br />
has_many :livre<br />
end</code><br />
<br />
En contrepartie, on peut avoir besoin d'accéder à l'auteur d'un livre. Modifions donc <code>./app/models/livre.rb</code> en :<br />
<code>class Livre < ActiveRecord::Base<br />
belongs_to :auteur<br />
end</code><br />
<br />
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.<br />
<br />
== Création d'un contrôleur ==<br />
Tout d'abord, utilisons, comme pour les modèles, le script <code>./script/generate</code> :<br />
<code>$ ./script/generate controller bibliotheque<br />
exists app/controllers/<br />
exists app/helpers/<br />
create app/views/bibliotheque<br />
exists test/functional/<br />
create app/controllers/bibliotheque_controller.rb<br />
create test/functional/bibliotheque_controller_test.rb<br />
create app/helpers/bibliotheque_helper.rb</code><br />
<br />
Editons maintenant <code>./app/controllers/bibliotheque_controller.rb</code>. Par défaut, vous avez :<br />
<code>class BibliothequeController < ApplicationController<br />
end</code><br />
<br />
Nous allons créer des actions. Un contrôleur peut comporter plusieurs actions.<br />
<code>class BibliothequeController < ApplicationController<br />
def index<br />
listeAuteur<br />
render_action 'listeAuteur'<br />
end<br />
<br />
def listeAuteur<br />
@auteurs = Auteur.find(:all, :order => "nom,prenom")<br />
end<br />
<br />
def ajoutAuteur<br />
param = @params['auteur']<br />
auteur = Auteur.new(param)<br />
if auteur.save<br />
flash[:ok] = "L'auteur a &eacute;t&eacute; ajout&eacute;"<br />
else<br />
flash[:error] = "Probl&egrave;me à l'ajout de l'auteur"<br />
end<br />
# ajoutAuteur n'a pas besoin de vue. Une fois l'auteur ajouté<br />
# on réaffiche la liste <br />
redirect_to :action => 'listeAuteur'<br />
end<br />
end<br />
</code><br />
<br />
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.<br />
<br />
== Mise en place des vues ==<br />
<br />
=== Le layout ===<br />
<br />
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>.<br />
<code>$ touch app/views/layouts/bibliotheque.rhtml<br />
</code><br />
Editons maintenant ce fichier :<br />
<code><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//FR" "http://www.w3.org/TR/html4/loose.dtd"><br />
<html><br />
<head><br />
<title>Biblioth&egrave;que - <%= controller.action_name %></title><br />
<meta name="author" content="GEDsismik"><br />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15"><br />
</head><br />
<body><br />
<h1>Biblioth&egrave;que</h1><br />
<br/><br />
<div class="all"><br />
<p style="color: green"><%= flash[:notice] %></p><br />
<%= @content_for_layout %><br />
</div><br />
</body><br />
</html></code><br />
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>.<br />
<br />
<code><%= @content_for_layout %></code> affichera la partie propre à l'action.<br />
<br />
=== La vue ===<br />
<br />
Les vues sont dans un répertoire de la forme <code>./app/views/<contrôleur>/</code> et porte le nom <code><action>.rhtml</code><br />
<br />
Créons donc le fichier <code>./app/views/bibliotheque/listeAuteur.rhtml</code> :<br />
<br />
<code><h2>Liste des auteurs</h2><br />
<ul><br />
<%<br />
@auteurs.each do |auteur|<br />
%><li><%= auteur.nom + " " + auteur.prenom %></li><%<br />
end<br />
%><br />
</ul><br />
<br />
<h2>Ajout d'un auteur</h2><br />
<%= start_form_tag :action => "ajoutAuteur" %><br />
<p><label>Pr&eacute;nom : <%= text_field 'auteur', 'prenom' %></label></p><br />
<p><label>Nom : <%= text_field 'auteur', 'nom' %></label></p><br />
<%= submit_tag("Ajouter") %><br />
<%= end_form_tag %></code><br />
<br />
== WebRick ==<br />
<br />
Vous disposez d'un serveur de test appellé WebRick. Pour le lancez, tapez <code>./script/server </code><br />
<code>$ ./script/server <br />
=> Booting WEBrick...<br />
=> Rails application started on http://0.0.0.0:3000<br />
=> Ctrl-C to shutdown server; call with --help for options<br />
[2006-10-19 18:32:57] INFO WEBrick 1.3.1<br />
[2006-10-19 18:32:57] INFO ruby 1.8.5 (2006-08-25) [i686-linux]<br />
[2006-10-19 18:32:57] INFO WEBrick::HTTPServer#start: pid=26166 port=3000</code><br />
<br />
Par défaut, ce serveur écoute le port 3000. Ouvrez donc un navigateur et tapez : <code>http://localhost:3000</code>.<br />
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>.<br />
<br />
== Les environnements ==<br />
<br />
= Copyright =<br />
Copyright &copy; 19/10/2006, GEDsismik<br />
{{CC-BY-NC-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Ruby_On_Rails&diff=13858Ruby On Rails2006-10-19T16:11:13Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Ruby On Rails =<br />
<br />
<div class="leatitre">Ruby On Rails</div><br />
<div class="leapar">par [mailto:gedsismik_at_free_point_fr GEDsismik]</div><br />
<div class="leadesc">Monter un projet Ruby On Rails (RoR) pas à pas.</div><br />
----<br />
<br />
== Avant propos ==<br />
<br />
On supposera installé et correctement configuré :<br />
- un SGBD supporté par RoR (personnellement, j'utilise MySQL)<br />
- Ruby<br />
- Rails et ses dépendances<br />
<br />
Il vous faudra aussi des notions de ruby.<br />
<br />
== Mise en place de l'environnement ==<br />
<br />
<code>$ rails monsite<br />
create <br />
create app/controllers<br />
create app/helpers<br />
create app/models<br />
create app/views/layouts<br />
[...]<br />
</code><br />
Le répertoire monsite vient d'être créé ainsi que la structure initiale du projet. Entrez maintenant dans ce répertoire.<br />
<br />
<code>app<br />
components<br />
config<br />
db<br />
doc<br />
lib<br />
log<br />
public<br />
Rakefile<br />
README<br />
script<br />
test<br />
tmp<br />
vendor<br />
</code><br />
<br />
== Configuration ==<br />
<br />
Si vous n'avez pas de base de donnée, créez-en :<br />
<code>mysql> create database monsite_development;<br />
mysql> create database monsite_test;<br />
mysql> create database monsite_production;</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
Nous allons ensuite éditer ./config/database.yml. Vous avez 3 environnements de pré-configurées de la sorte : <br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: root<br />
password:<br />
host: localhost</code><br />
Editez-le en fonction des paramètres de votre base de donnée<br />
<code>production:<br />
adapter: mysql<br />
database: monsite_production<br />
username: gedsismik<br />
password: mypassord<br />
host: localhost<br />
socket: /var/run/mysql/mysql.sock</code><br />
<div class="aparte"><br />
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.<br />
</div><br />
<br />
== Modèle MVC ==<br />
<br />
Ruby On Rails utilise le motif de conception MVC (modèle-vue-contrôleur). Je m'explique : dans un projet RoR, vous séparez :<br />
- 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.<br />
- 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).<br />
- 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.<br />
<br />
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.<br />
<br />
== Création des modèles ==<br />
<br />
=== Génération des fichiers relatifs à la table ===<br />
<br />
On va utilisez le script <code>./script/generate</code> pour générer la première table.<br />
<br />
<code>$ ./script/generate model livre<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/livre.rb<br />
create test/unit/livre_test.rb<br />
create test/fixtures/livres.yml<br />
create db/migrate<br />
create db/migrate/001_create_livres.rb<br />
$ ./script/generate model auteur<br />
exists app/models/<br />
exists test/unit/<br />
exists test/fixtures/<br />
create app/models/auteur.rb<br />
create test/unit/auteur_test.rb<br />
create test/fixtures/auteurs.yml<br />
exists db/migrate<br />
create db/migrate/002_create_auteurs.rb<br />
</code><br />
<br />
=== Fichiers de migration ===<br />
<br />
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.<br />
<div class="aparte"><br />
Note : ne faites pas de champ "id", ils sont automatiquement créés et gérer par Rails.<br />
</div><br />
<br />
==== Fichier ./db/migrate/001_create_livres.rb ====<br />
<br />
<code>class CreateLivres < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
end<br />
end<br />
</code><br />
<br />
==== Fichier ./db/migrate/002_create_auteurs.rb ====<br />
<br />
<code>class CreateAuteurs < ActiveRecord::Migration<br />
def self.up<br />
create_table :auteurs do |t|<br />
t.column :nom, :string<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :auteurs<br />
end<br />
end</code><br />
<br />
<br />
<div class="aparte">Notez que vous pouvez réunir les deux fichiers en un seul :<br />
./db/migrate/001_initial.rb<br />
<code>class Initial < ActiveRecord::Migration<br />
def self.up<br />
create_table :livres do |t|<br />
t.column :titre, :string, :null => false<br />
t.column :auteur_id, :integer, :null => false<br />
t.column :quantite, :integer, :default => "1"<br />
end<br />
create_table :auteurs do |t|<br />
t.column :nom, :string, :null => false<br />
t.column :prenom, :string<br />
end<br />
end<br />
<br />
def self.down<br />
drop_table :livres<br />
drop_table :auteurs<br />
end<br />
end</code></div><br />
<br />
=== Génération des tables ===<br />
<br />
Toujours dans le repertoire monsite, exécutez <code>rake migrate</code>.<br />
<code>$ rake migrate<br />
(in /home/gedsismik/monsite)<br />
== CreateLivres: migrating ====================================================<br />
-- create_table(:livres)<br />
-> 0.0441s<br />
== CreateLivres: migrated (0.0442s) ===========================================<br />
<br />
== CreateAuteurs: migrating ===================================================<br />
-- create_table(:auteurs)<br />
-> 0.0457s<br />
== CreateAuteurs: migrated (0.0458s) ==========================================<br />
</code><br />
<br />
Si vous regardez dans votre base de donnée, vous trouverez donc 3 tables :<br />
- auteurs<br />
- livres<br />
- schema_info<br />
<br />
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.<br />
<br />
=== Edition des modèles ===<br />
<br />
<br />
<br />
== Création du/des controleur(s) ==<br />
<br />
== Mise en place des vues ==</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=NFS&diff=13097NFS2006-07-19T07:55:43Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Partager ses fichiers]]<br />
= Installation d'un serveur NFS =<br />
<br />
<div class="leatitre">Installation d'un serveur NFS</div><div class="leapar">Guillaume Pierronnet</div><div class="leadesc">NFS, ou le partage des ressources selon Unix.</div><br />
----<br />
<br />
== Introduction ==<br />
<br />
NFS signifie Network File System. C'est, comme son nom l'indique, un système de fichiers en réseau qui permet de partager ses données principalement entre systèmes UNIX. À la différence de SAMBA, NFS gère les permissions sur les fichiers et on peut donc l'utiliser de manière totalement transparente dans son arborescence Linux.<br />
<br />
'''ATTENTION !'''<br />
<br />
Comme toute application réseau, NFS ouvre des trous dans la sécurité du système. Je vous invite donc à consulter les liens à la fin de cet article pour des précisions sur la sécurité ([http://www.linuxselfhelp.com/HOWTO/NFS-HOWTO/security.html celui-ci], en anglais, indique quelques règles à suivre, en parallèle des démarches indiquées [http://people.via.ecp.fr/~alexis/formation-linux/nfs.html dans ce guide nfs pour Debian] ou ci-dessous). <br /><br />
<br />
== Les softs ==<br />
<br />
=== Les modules du noyau ===<br />
<br />
Dans la configuration du noyau, on va dans la section "'''File systems ---> Network File Systems'''"<br />
<br />
* <u>Pour le client:</u><br />
<br /><tt>NFS file system support et Provide NFSv3 client support</tt><br />
CONFIG_NFS_FS=y ou m<br />
CONFIG_NFS_V3=y<br />
* <u>Pour le serveur:</u><br />
<br /><tt>NFS server support et Provide NFSv3 server support</tt><br />
CONFIG_NFSD=y ou m<br />
CONFIG_NFSD_V3=y<br />
<br />
À partir du noyau 2.2.18, les modules supportent entièrement la version 3 du protocole ainsi que différentes corrections de bug. <br />Il serait temps d'upgrader si tu ne l'as pas déjà fait! (profites-en pour passer au 2.4, ce sera réglé :)<br />
<br />
=== Les packages ===<br />
<br />
Les packages (sur ma Debian) sont :<br />
<br />
* <tt>nfs-common</tt><br />
* <tt>nfs-user-server</tt> pour le serveur.<br />
<br />
Tu peux toujours récupérer les sources qui se trouvent sur http://nfs.sourceforge.net/.<br />
<br />
On va aussi installer le ''wrapper'' TCP pour un minimum de sécurité. Toujours sur ma Debian, le paquet s'appelle <tt>tcpd</tt>. Les sources se trouvent [ftp://ftp.porcupine.org/pub/security/index.html ici].<br />
<br />
== Le serveur ==<br />
<br />
Les 3 fichiers de configuration principaux sont <tt>/etc/exports</tt>, <tt>/etc/hosts.deny</tt> et <tt>/etc/hosts.allow</tt>.<br />
<br />
=== /etc/exports ===<br />
<br />
Le fichier <tt>/etc/exports</tt> est très simple :<br />
<br />
<tt>répertoire machine1(option11,option12) machine2(option21,option22)</tt><br />
<br />
par exemple :<br />
<br />
<tt>/home 192.168.0.10(rw) 192.168.0.25(ro)</tt><br />
<br />
signifie que l'on autorisera la machine ''192.168.0.10'' à accéder à notre répertoire <tt>/home</tt> en lecture et écriture (<tt>rw</tt>) ainsi que la machine ''192.168.0.25'' mais uniquement en lecture (<tt>ro</tt>).<br />
<br />
* <tt><u>répertoire</u></tt> :<br /> le répertoire du serveur à partager.<br /> <br />
* <tt><u>machine</u></tt> :<br /> Une liste de machines séparée par des virgules et autorisées à monter ce répertoire (utilisez des adresses IP plutôt que des noms à cause des problèmes de "''dns spoofing''").<br /> <br />
* <tt><u>options</u></tt> : <br />
** '''ro''' : <br />C'est la valeur par défaut, lecture seule.<br />
** '''rw''' : <br />La machine à un accès en lecture/écriture au répertoire.<br />
** '''no_root_squash''' : <br />Les accès par l'utilisateur root sur le serveur se font sous l'identité root, au contraire de nobody (par défaut)<br /> À UTILISER AVEC PRÉCAUTION<br />
** '''sync''' : <u>uniquement NFS v2</u><br />Ne diffère pas les écritures physiques au volume, augmente la fiabilité en cas de mauvais démontage. La version 3 dispose d'un mécanisme de ''commit-rollback'' donc cette option n'est pas utile.<br />
<br />
Un point important, pour un bon fonctionnement : tu dois avoir les mêmes numéros de groupes et d'utilisateurs sur les deux machines. <br />Des systèmes permettent de gérer çà, NIS (assez ancien) ou LDAP (plus récent). Avec peu d'utilisateurs, tu peux tout simplement éditer <tt>/etc/group</tt> et <tt>/etc/passwd</tt> pour synchroniser ces numéros.<br />
<br />
Il n'est pas recommandé d'exporter un système DOS ou VFAT à cause de leurs absences de gestion multi-utilisateurs ; ils ne sont pas fait pour être partagés avec NFS. <br /> <br />
<br />
=== /etc/hosts.deny ===<br />
<br />
On va interdire toutes les machines qui ne sont pas autorisées explicitement dans le <tt>/etc/hosts.allow</tt>. <br />Un bon vieux "<tt>ALL: ALL</tt>" interdira l'accès à tous les services à partir de toutes les machines. On peut cependant être plus précis en écrivant :<br />
<br />
portmap:ALL<br />
lockd:ALL<br />
mountd:ALL<br />
rquotad:ALL<br />
statd:ALL<br />
<br />
<br />
<br />
=== /etc/hosts.allow ===<br />
<br />
Dans le même esprit que pour le <tt>/etc/hosts.deny</tt>, ce fichier a l'architecture suivante :<br />
<br />
[service]: [IP de la machine client]<br />
<br />
Donc pour autoriser 192.168.1.34 à se connecter à un partage NFS, on écrira :<br />
<br />
portmap:192.168.1.34<br />
lockd:192.168.1.34<br />
mountd:192.168.1.34<br />
rquotad:192.168.1.34<br />
statd:192.168.1.34<br />
<br />
On va pouvoir lancer les services ; sur ma Debian, je lance :<br />
<br />
<nowiki># /etc/init.d/nfs-server start</nowiki><br />
<br />
Pour Slackware, ce serait<br />
<br />
<nowiki># /etc/rc.d/rc.nfsd start</nowiki><br />
<br />
La commande <tt>rpcinfo -p</tt> permet de vérifier que les services fonctionnent. Elle devrait produire un résultat dans cet esprit :<br />
<br />
cacahuete:~# rpcinfo -p<br />
program vers proto port<br />
100000 2 tcp 111 portmapper<br />
100000 2 udp 111 portmapper<br />
100024 1 udp 737 status<br />
100024 1 tcp 739 status<br />
100011 1 udp 851 rquotad<br />
100011 2 udp 851 rquotad<br />
100003 2 udp 2049 nfs<br />
100003 2 tcp 2049 nfs<br />
100005 1 udp 872 mountd<br />
100005 2 udp 872 mountd<br />
100005 1 tcp 875 mountd<br />
100005 2 tcp 875 mountd<br />
cacahuete:~#<br />
<br />
Pour recharger les services NFS (par exemple après une modification du fichier de config) :<br />
<br />
cacahuete:~# killall -HUP nfsd<br />
<br />
le serveur est prêt ! <br /> <br />
<br />
== Le client ==<br />
<br />
Pour utiliser NFS v3, il faut au minimum la version 2.10m du programme <tt>mount</tt>. Pour voir sa version, taper :<br />
<br />
cacahuete:~# mount -V<br />
mount: mount-2.11h<br />
cacahuete:~#<br />
<br />
On va maintenant pouvoir monter notre partage!<br />
<br />
cacahuete:~# mount mon.serveur.nfs:/home /mnt/home<br />
cacahuete:~#<br />
<br />
En principe tout devrait bien se dérouler.<br />
<br />
Pour monter ce partage définitivement à chaque démarrage de la machine, éditons notre <tt>/etc/fstab</tt><nowiki>: </nowiki><br />
<br />
<nowiki># device mountpoint fs-type options dump fsckorder<br />
...<br />
master.foo.com:/home /mnt nfs rw 0 0<br />
...</nowiki><br />
<br />
<br />
<br />
== Liens ==<br />
<br />
* Cet article est principalement basé sur le [http://www.linuxdoc.org/HOWTO/NFS-HOWTO/index.html NFS howto]<br />
* Les sources des logiciels NFS sur http://nfs.sourceforge.net/<br />
* [http://www.linuxdoc.org/HOWTO/LDAP-HOWTO.html LDAP howto]<br />
* [http://www.linuxdoc.org/HOWTO/NIS-HOWTO.html NIS howto]<br />
* Va te faire peur sur [http://www.securityfocus.com/ security focus]<br />
<br />
<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Guillaume Pierronnet le 22/10/2001.</div><br />
<br />
= Copyright =<br />
Copyright &copy; 22/10/2001, Guillaume Pierronnet<br />
{{CC-BY-NC-SA}}<br />
<br />
<br />
=Autres ressources=<br />
* Cet article est principalement basé sur le [http://www.linuxdoc.org/HOWTO/NFS-HOWTO/index.html NFS howto]<br />
* Les sources des logiciels NFS sur http://nfs.sourceforge.net/ <br />
* [http://en.tldp.org/HOWTO/LDAP-HOWTO/ LDAP howto]<br />
* [http://www.linuxdoc.org/HOWTO/NIS-HOWTO.html NIS howto]<br />
* Va te faire peur sur [http://www.securityfocus.com/ security focus]</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Discussion_Lea_Linux:AG_2005&diff=10946Discussion Lea Linux:AG 20052005-11-30T20:15:58Z<p>Gedsismik : </p>
<hr />
<div>==Inscription==<br />
Liste des inscrits pour l'AG2005 de LéaLinux :<br />
<br />
* [[Utilisateur:Ennael|Anne]] (AG + Confs + Soirée) - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] (AG + Confs + Soirée.. si train possible) - 1 personne<br />
* [[Utilisateur:Fred|Fred]] (AG + Confs + Soirée ... si hébergement) - 1 personne<br />
* [[Utilisateur:Gedsismik|GEDsismik]] (Confs - I'm a Misc Fan ;) ) - 1 personne - pas sûr<br />
* [[Utilisateur:LeaJice|Jice]] (AG + Confs + Soirée) - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] (AG + Confs) - 1 personne<br />
* <strike>[[Utilisateur: Mike-m|Mike M]] (Confs + Soirée ... si sur Paris) - 1 personne</strike><br />
* [[Utilisateur: MsK`|MsK`]] (Confs + Soirée si c'est bon, qu'est-ce qu'on mange ? :) - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] (AG + Confs) - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] (AG + Confs + Soirée) - 2 personnes<br />
* [[Utilisateur:Phlogistique|Noé Rubinstein]] (Confs) - 1 personne - pas sur<br />
* [[Utilisateur: Misc|Michael Scherer]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur:ST|ST]] (AG + Confs + Soirée) - 1 personne<br />
* [[Utilisateur: YannTech|Yann Verry]] (Soirée) - 2 personnes<br />
* [[Utilisateur: Papyrus|youss]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] (AG + Confs + Soirée) - 1 personnes<br />
<br />
===Assemblée générale===<br />
11 personnes :<br />
<br />
* [[Utilisateur:Ennael|Anne]] - 2 personnes<br />
* [[Utilisateur: Hélène|Hélène Dumur]] - 1 personne<br />
* [[Utilisateur:Fred|Fred]] - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] - 2 personnes<br />
* [[Utilisateur:ST|ST]] - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] - 1 personne<br />
<br />
===Conférence===<br />
17 personnes :<br />
<br />
* [[Utilisateur:Ennael|Anne]] - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] - 1 personne<br />
* [[Utilisateur:Fred|Fred]] - 1 personne<br />
* [[Utilisateur:Gedsismik|GEDsismik]] - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] - 1 personne<br />
* [[Utilisateur: MsK`|MsK`]] - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] - 2 personnes<br />
* [[Utilisateur:Phlogistique|Noé Rubinstein]] - 1 personne<br />
* [[Utilisateur: Misc|Michael Scherer]] - 1 personne<br />
* [[Utilisateur:ST|ST]] - 1 personne<br />
* [[Utilisateur: Papyrus|youss]] - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] - 1 personnes<br />
<br />
===Soirée===<br />
16 personnes<br />
<br />
* [[Utilisateur:Ennael|Anne]] - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] - 1 personne<br />
* [[Utilisateur:Fred|Fred]] - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] - 1 personne<br />
* [[Utilisateur: MsK`|MsK`]] - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] - 2 personnes<br />
* [[Utilisateur: Misc|Michael Scherer]] - 1 personne<br />
* [[Utilisateur:ST|ST]] - 1 personne<br />
* [[Utilisateur: YannTech|Yann Verry]] - 2 personnes<br />
* [[Utilisateur: Papyrus|youss]] - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] - 1 personnes</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Discussion_Lea_Linux:AG_2005&diff=10908Discussion Lea Linux:AG 20052005-11-28T23:36:57Z<p>Gedsismik : </p>
<hr />
<div>==Inscription==<br />
Liste des inscrits pour l'AG2005 de LéaLinux :<br />
<br />
* [[Utilisateur:Ennael|Anne]] (AG + Confs + Soirée) - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] (AG + Confs + Soirée.. si train possible) - 1 personne<br />
* [[Utilisateur:Fred|Fred]] (AG + Confs + Soirée ... si hébergement) - 1 personne<br />
* [[Utilisateur:Gedsismik|GEDsismik]] (Confs - I'm a Misc Fan ;) ) - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] (AG + Confs + Soirée) - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] (AG + Confs + Soirée) - 1 personne<br />
* <strike>[[Utilisateur: Mike-m|Mike M]] (Confs + Soirée ... si sur Paris) - 1 personne</strike><br />
* [[Utilisateur: MsK`|MsK`]] (Confs + Soirée si c'est bon, qu'est-ce qu'on mange ? :) - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] (AG + Confs) - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] (AG + Confs + Soirée) - 2 personnes<br />
* [[Utilisateur:Phlogistique|Noé Rubinstein]] (Confs) - 1 personne - pas sur<br />
* [[Utilisateur: Misc|Michael Scherer]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur:ST|ST]] (AG + Confs + Soirée) - 1 personne<br />
* [[Utilisateur: YannTech|Yann Verry]] (Soirée) - 2 personnes<br />
* [[Utilisateur: Papyrus|youss]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] (AG + Confs + Soirée) - 1 personnes<br />
<br />
===Assemblée générale===<br />
11 personnes :<br />
<br />
* [[Utilisateur:Ennael|Anne]] - 2 personnes<br />
* [[Utilisateur: Hélène|Hélène Dumur]] - 1 personne<br />
* [[Utilisateur:Fred|Fred]] - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] - 2 personnes<br />
* [[Utilisateur:ST|ST]] - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] - 1 personne<br />
<br />
===Conférence===<br />
17 personnes :<br />
<br />
* [[Utilisateur:Ennael|Anne]] - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] - 1 personne<br />
* [[Utilisateur:Fred|Fred]] - 1 personne<br />
* [[Utilisateur:Gedsismik|GEDsismik]] - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] - 1 personne<br />
* [[Utilisateur: MsK`|MsK`]] - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] - 2 personnes<br />
* [[Utilisateur:Phlogistique|Noé Rubinstein]] - 1 personne<br />
* [[Utilisateur: Misc|Michael Scherer]] - 1 personne<br />
* [[Utilisateur:ST|ST]] - 1 personne<br />
* [[Utilisateur: Papyrus|youss]] - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] - 1 personnes<br />
<br />
===Soirée===<br />
16 personnes<br />
<br />
* [[Utilisateur:Ennael|Anne]] - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] - 1 personne<br />
* [[Utilisateur:Fred|Fred]] - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] - 1 personne<br />
* [[Utilisateur: MsK`|MsK`]] - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] - 2 personnes<br />
* [[Utilisateur: Misc|Michael Scherer]] - 1 personne<br />
* [[Utilisateur:ST|ST]] - 1 personne<br />
* [[Utilisateur: YannTech|Yann Verry]] - 2 personnes<br />
* [[Utilisateur: Papyrus|youss]] - 1 personne<br />
* [[Utilisateur:Zragg|Zragg]] - 1 personnes</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Discussion_Lea_Linux:AG_2005&diff=10907Discussion Lea Linux:AG 20052005-11-28T23:07:07Z<p>Gedsismik : </p>
<hr />
<div>* [[Utilisateur:Ennael|Anne]] (AG + Confs + Soirée) - 2 personnes<br />
* [[Utilisateur:Pterjan|CMoi]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur: Hélène|Hélène Dumur]] (AG + Confs + Soirée.. si train possible) - 1 personne<br />
* [[Utilisateur:Fred|Fred]] (AG + Confs + Soirée ... si hébergement) - 1 personne<br />
* [[Utilisateur:Gedsismik|GEDsismik]] (Confs - I'm a Misc Fan ;) ) - 1 personne<br />
* [[Utilisateur:LeaJice|Jice]] (AG + Confs + Soirée) - 1 personne<br />
* [[Utilisateur:Maston28|Maston28]] (AG + Confs + Soirée) - 1 personne<br />
* <strike>[[Utilisateur: Mike-m|Mike M]] (Confs + Soirée ... si sur Paris) - 1 personne</strike><br />
* [[Utilisateur: MsK`|MsK`]] (Confs + Soirée si c'est bon, qu'est-ce qu'on mange ? :) - 1 personne<br />
* [[Utilisateur: Papyrus|youss]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur: miaouzz32|Pascalc]] (AG + Confs) - 1 personne<br />
* [[Utilisateur:Philheap|Philheap]] (AG + Confs + Soirée) - 2 personnes<br />
* [[Utilisateur:Phlogistique|Noé Rubinstein]] (Confs) - 1 personne - pas sur<br />
* [[Utilisateur: Misc|Michael Scherer]] (Confs + Soirée) - 1 personne<br />
* [[Utilisateur:ST|ST]] (AG + Confs + Soirée) - 1 personne<br />
* [[Utilisateur: YannTech|Yann Verry]] (Soirée) - 2 personnes<br />
* [[Utilisateur:Zragg|Zragg]] (AG + Confs + Soirée) - 1 personnes</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Python&diff=10293Python2005-10-31T01:06:31Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Python =<br />
<br />
<div class="leatitre">Python</div><div class="leapar">par [mailto:gedsismik@free.fr GEDsismik]</div><div class="leadesc">Introduction à Python.</div><br />
<br />
== Présentation ==<br />
<br />
Python est un langage orienté objet interprété prenant de plus en plus d'importance ces dernières années. Parmi les nombreuses particularités syntaxiques, nous noterons que ce langage utilise l'identation plutot que des accolades pour les blocs d'instructions et que les variables ne sont pas typés explicitement.<br />
<br />
== Installation ==<br />
<br />
Vérifiez tout d'abord si Python est déjà installé. Pour cela, tapez <code>python -V</code> dans une console. Si l'interpreteur Python est installé, vous obtiendez un message du genre :<br />
<code multi><br />
$ python -V <br />
Python 2.4.2<br />
</code> <br />
Si il n'est pas installé, vous obtiendrez un message du genre :<br />
<code multi><br />
$ python -V <br />
bash: python: command not found<br />
</code><br />
<br />
=== Installation à l'aide de paquetage... ===<br />
Pour installer Python, vous pouvez utiliser le système de paquetage de votre distribution GNU/Linux préféré :<br />
* Debian : <code>apt-get install python</code><br />
* Fedeora : <code>yum install python</code><br />
* Mandriva : <code> urpmi python</code><br />
* Slackware : <code>swaret --install python</code><br />
<br />
=== ... ou compilation ===<br />
Sinon, vous pouvez opter pour la compilation. Python étant libre, vous trouverez ses sources sur http://www.python.org. Une fois le paquetage récupéré, vous pourrez le compiler à l'aide de la méthode habituelle :<br />
<code multi><br />
$ tar -zxvf python-2.4.2.tgz<br />
$ cd python-2.4.2<br />
$ ./configure<br />
$ make<br />
$ su<br />
# make install<br />
</code><br />
<br />
== Script de base ==<br />
Vous allez maintenant découvrir votre première instruction :<br />
Pour écrire un message, on utilise : <code>print "Avec votre texte entre guillemets"</code>. <br />
On teste ? Tapez donc dans un éditeur : <br />
<div class=code>print "Vive le python !"</div><br />
Enregistrez-le au format texte brut (par défaut normalement) suivi de l'extension py. Je l'appellerais hello.py personnellement. Pour exécuter<br />
un script python, on utilise python (nan, sans dec' ?). Dans notre exemple, on fait donc :<br />
<div class='code'>bash$ python hello.py<br><br />
Vive le python !</div><br><br />
Et vala ! Ca marche !<br />
<div class=note><b>Note :</b> Il est pratique de commencer un script (quelque soit le langage) par le chemin de l'interpreteur (<code>#!/usr/bin/python</code>) et le codage (<code># -*- coding: utf-8 -*-</code>) :<br />
<div class=code><br />
<div class=comment>#!/usr/bin/python<br># -*- coding: utf-8 -*-</div>print "Vive le python !"<br />
</div><br><br />
Ca permet notamment de pouvoir lancer directement le script (en ayant prit soit de vérifier les permissions d'execution) : <br />
<div class='code'>bash$ ./hello.py<br><br />
Vive le python !</div><br />
</div><br />
<br />
<div class=note><b>Note 2 :</b> A cette étape du document, assurez-vous de mettre toutes les lignes du script au même niveau (à la même identation).<br />
</div><br />
<br />
== L'interpreteur ==<br />
Plutôt qu'enregistrer votre script dans un fichier, vous pouvez lancer directement <code>python</code> et taper<br />
vos commandes. Tout se déroule "en direct". C'est pratique pour tester une commande mais quand vous avez tout un code, c'est pas génial vu que ce n'est pas réutilisable.<br />
<br />
<div class='code'><br />
bash$ python <br><br />
Python 2.4.1 (#1, Apr 10 2005, 22:30:36) <br><br />
[GCC 3.3.5] on linux2<br><br />
Type "help", "copyright", "credits" or "license" for more information.<br><br />
&gt;&gt;&gt; print "Vive les chips !"<br><br />
Vive les chips !<br><br />
&gt;&gt;&gt;<br />
</div><br />
<br />
== Commentaires ==<br />
Il vous est possible d'ajouter à tout moment votre script un commentaire. Ce commentaire ne sera pas pris en compte par l'interpreteur mais vous servira éventuellement à vous organiser dans votre programme (notamment si celui-ci prend de l'ampleur). Le commentaire se note ainsi :<br />
<div class='code'><div class=comment># Vos commentaires</div></div><br />
<br />
== Variables ==<br />
Les variables sont "faiblement typées" en Python. C'est-à-dire qu'elles ont un type mais il n'est pas forcement connu et leur déclaration n'est pas stricte. Je m'explique : il n'y a pas de déclaration des variables (contrairement à la plupart des langages). Exemple : on peut taper directement <code>x=3</code> et x sera un entier de valeur 3.</p><br />
<br />
Les principaux types sont : réel, entier et chaine de caractère.<br />
<div class='code'><br />
<div class=comment>#!/usr/bin/python<br><br />
# x est un entier</div><br />
x=2<br />
<div class=comment># i est un réel</div><br />
i=2.0<br />
<div class=comment># bibi est une chaine de caractère</div><br />
bibi="Vive les chips"<br />
<div class=comment># on affiche tout le monde</div><br />
print "x vaut ", x<br><br />
print "i vaut ", i<br><br />
print "bibi = ", bibi<br />
</div><br><br />
<br />
Ce qui donne :<br />
<div class='code'><br />
bash-3.00$ python test_var.py<br><br />
x vaut 2<br><br />
i vaut 2.0<br><br />
bibi = Vive les chips<br />
</div><br />
<br />
=== Opérations (entier/réel) ===<br />
<br />
Les 4 opérations de base sont :<br />
<br />
* <b>+</b> l'addition<br />
* <b>-</b> la soustraction<br />
* <b>*</b> la multiplication<br />
* <b>/</b> la division<br />
<br />
Oui, je sais, ca parait con mais faut le préciser.<br />
<br />
<br />
Des opérations entre entiers donne des entiers.<br><br />
Des opérations entre réels donne des réels.<br><br />
Des opérations entre entier et réel donne des réels.<br />
<br />
<div class='code'><br />
<div class=comment>#!/usr/bin/python<br><br />
# -*- coding: utf-8 -*-<br><br><br />
<br />
# on prend 4 variables</div><br />
x=2.0<br><br />
y=3.0<br><br />
a=5<br><br />
b=2<br><br />
<div class=comment># on affiche leurs types</div><br />
print type(x)<br><br />
print type(y)<br><br />
print type(a)<br><br />
print type(b)<br><br><br />
<br />
c=a+b<br><br />
d=x*a<br><br />
x=x*y<br><br><br />
<br />
print "c vaut ", c, " et est de type", type(c)<br><br />
print "d vaut ", d, " et est de type", type(d)<br><br />
print "x vaut maintenant ", x ," et est de type", type(x)<br />
</div><br />
<br />
<div class=note><b>Note : </b> <code>type(<i>var</i>)</code> revoit le type d'une variable</div><br><br />
<br />
Ce qui renvoit :<br />
<div class='code'><br />
bash-3.00$ python test_type.py <br />
<type 'float'><br />
&lt;type 'float'&gt;<br />
&lt;type 'int'&gt;<br />
&lt;type 'int'&gt;<br />
c vaut 7 et est de type &lt;type 'int'&gt;<br><br />
d vaut 10.0 et est de type &lt;type 'float'&gt;<br><br />
x vaut maintenant 6.0 et est de type &lt;type 'float'&gt;<br />
</div><br />
<div class=note><b>Note : </b> <code>int</code> (integer) signifie entier et <code>float</code> (flottant) signifie réel </div><br><br />
<br />
<br />
{{Copy|2005|GEDsismik|CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Python&diff=10292Python2005-10-31T00:56:25Z<p>Gedsismik : </p>
<hr />
<div>[[Category:Développer sous Linux]]<br />
= Python =<br />
<br />
<div class="leatitre">Python</div><div class="leapar">par [mailto:gedsismik@free.fr GEDsismik]</div><div class="leadesc">Introduction à Python.</div><br />
<br />
== Présentation ==<br />
<br />
Python est un langage orienté objet interprété prenant de plus en plus d'importance ces dernières années. Parmi les nombreuses particularités syntaxiques, nous noterons que ce langage utilise l'identation plutot que des accolades pour les blocs d'instructions et que les variables ne sont pas typés explicitement.<br />
<br />
== Installation ==<br />
<br />
Vérifiez tout d'abord si Python est déjà installé. Pour cela, tapez <code>python -V</code> dans une console. Si l'interpreteur Python est installé, vous obtiendez un message du genre :<br />
<code multi><br />
$ python -V <br />
Python 2.4.2<br />
</code> <br />
Si il n'est pas installé, vous obtiendrez un message du genre :<br />
<code multi><br />
$ python -V <br />
bash: python: command not found<br />
</code><br />
<br />
=== Installation à l'aide de paquetage... ===<br />
Pour installer Python, vous pouvez utiliser le système de paquetage de votre distribution GNU/Linux préféré :<br />
* Debian : <code>apt-get install python</code><br />
* Fedeora : <code>yum install python</code><br />
* Mandriva : <code> urpmi python</code><br />
* Slackware : <code>swaret --install python</code><br />
<br />
=== ... ou compilation ===<br />
Sinon, vous pouvez opter pour la compilation. Python étant libre, vous trouverez ses sources sur http://www.python.org. Une fois le paquetage récupéré, vous pourrez le compiler à l'aide de la méthode habituelle :<br />
<code multi><br />
$ tar -zxvf python-2.4.2.tgz<br />
$ cd python-2.4.2<br />
$ ./configure<br />
$ make<br />
$ su<br />
# make install<br />
</code><br />
<br />
== Script de base ==<br />
Vous allez maintenant découvrir votre première instruction :<br />
Pour écrire un message, on utilise : <code>print "Avec votre texte entre guillemets"</code>. <br />
On teste ? Tapez donc dans un éditeur : <br />
<div class=code>print "Vive le python !"</div><br />
Enregistrez-le au format texte brut (par défaut normalement) suivi de l'extension py. Je l'appellerais hello.py personnellement. Pour exécuter<br />
un script python, on utilise python (nan, sans dec' ?). Dans notre exemple, on fait donc :<br />
<div class='code'>bash$ python hello.py<br><br />
Vive le python !</div><br><br />
Et vala ! Ca marche !<br />
<div class=note><b>Note :</b> Il est pratique de commencer un script (quelque soit le langage) par le chemin de l'interpreteur (<code>#!/usr/bin/python</code>) et le codage (<code># -*- coding: utf-8 -*-</code>) :<br />
<div class=code><br />
<div class=comment>#!/usr/bin/python<br># -*- coding: utf-8 -*-</div>print "Vive le python !"<br />
</div><br><br />
Ca permet notamment de pouvoir lancer directement le script (en ayant prit soit de vérifier les permissions d'execution) : <br />
<div class='code'>bash$ ./hello.py<br><br />
Vive le python !</div><br />
</div><br />
<br />
<div class=note><b>Note 2 :</b> A cette étape du document, assurez-vous de mettre toutes les lignes du script au même niveau (à la même identation).<br />
</div></div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10291Utilisateur:Gedsismik2005-10-31T00:21:25Z<p>Gedsismik : </p>
<hr />
<div>== Fonctions ==<br />
<br />
* Contributeur aux articles (mais surtout [http://lea-linux.org/fortune/ aux fortunes] ;) )<br />
* Co-administrateur de [http://bsd.lea-linux.org Bea-BSD] (si on peut considéré ce site comme dans Lea)<br />
* Troll sur IRC<br />
<br />
== Test du wiki ==<br />
<br />
Je me sers de cette page pour tester le wiki de [http://lea-linux.org Lea-Linux]. J'en profite pour passer un coucou à tous ceux que je connais et féliciter les admin' Anne, Fred et Prae.<br />
<br />
== Quelques Liens ==<br />
<br />
* Site personnel : http://gedsismik.free.fr<br />
* Site de Bea-BSD : http://bsd.lea-linux.org<br />
<br />
{{Copy|2005|GEDsismik|CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10290Utilisateur:Gedsismik2005-10-31T00:20:11Z<p>Gedsismik : Test du wiki</p>
<hr />
<div>== Fonctions ==<br />
<br />
* Contributeur aux articles (mais surtout [http://lea-linux.org/fortune/ aux fortunes] ;) )<br />
* Co-administrateur de [http://bsd.lea-linux.org Bea-BSD] (si on peut considéré ce site comme dans Lea)<br />
* Troll sur IRC<br />
<br />
== Quelques Liens ==<br />
<br />
* Site personnel : http://gedsismik.free.fr<br />
* Site de Bea-BSD : http://bsd.lea-linux.org<br />
<br />
{{Copy|2005|GEDsismik|CC-BY-SA}}<br />
<br />
== Test du wiki ==<br />
<br />
Je me sers de cette page pour tester le wiki de [http://lea-linux.org Lea-Linux]. J'en profite pour passer un coucou à tous ceux que je connais et féliciter les admin' Anne, Fred et Prae.</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10289Utilisateur:Gedsismik2005-10-31T00:17:41Z<p>Gedsismik : </p>
<hr />
<div>== Fonctions ==<br />
<br />
* Contributeur aux articles (mais surtout [http://lea-linux.org/fortune/ aux fortunes] ;) )<br />
* Co-administrateur de [http://bsd.lea-linux.org Bea-BSD] (si on peut considéré ce site comme dans Lea)<br />
* Troll sur IRC<br />
<br />
== Quelques Liens ==<br />
<br />
* Site personnel : http://gedsismik.free.fr<br />
* Site de Bea-BSD : http://bsd.lea-linux.org<br />
<br />
{{Copy|2005|GEDsismik|CC-BY-SA}}</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10288Utilisateur:Gedsismik2005-10-31T00:10:10Z<p>Gedsismik : </p>
<hr />
<div>Contributeur aux articles (mais surtout aux fortunes ;) ).<br />
Co-administrateur de Bea-BSD.<br />
<br />
<br />
- Site personnel : http://gedsismik.free.fr<br />
<br />
- Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10287Utilisateur:Gedsismik2005-10-30T22:48:19Z<p>Gedsismik : </p>
<hr />
<div> - Site personnel : http://gedsismik.free.fr<br />
- Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10286Utilisateur:Gedsismik2005-10-30T22:41:34Z<p>Gedsismik : </p>
<hr />
<div>Site personnel : http://gedsismik.free.fr\n<br />
Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10285Utilisateur:Gedsismik2005-10-30T22:35:31Z<p>Gedsismik : </p>
<hr />
<div>Site personnel : http://gedsismik.free.fr<br />
<br />
Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10284Utilisateur:Gedsismik2005-10-30T22:33:26Z<p>Gedsismik : </p>
<hr />
<div>Site personnel : http://gedsismik.free.fr<br /><br />
Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10283Utilisateur:Gedsismik2005-10-30T22:32:53Z<p>Gedsismik : </p>
<hr />
<div>Site personnel : http://gedsismik.free.fr<br />
<br />
Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismikhttps://lea-linux.org/docs/index.php?title=Utilisateur:Gedsismik&diff=10282Utilisateur:Gedsismik2005-10-30T22:32:33Z<p>Gedsismik : </p>
<hr />
<div><br />
Site personnel : http://gedsismik.free.fr<br />
Site de Bea-BSD : http://bsd.lea-linux.org</div>Gedsismik