Cet article décrit la mise en place d'un environnement simple mais néanmoins complet de développement Ruby et Rails. Il se termine par le traditionnel "Hello World" sous Rails pour s'assurer que l'environnement est bien en place.
Cet article décrit la mise en place d'un environnement simple mais néanmoins complet de développement Ruby et Rails. Il se termine par le traditionnel "Hello World" sous Rails pour s'assurer que l'environnement est bien en place.
Ce dernier exemple, décrit par conséquent les actions initiales pour mettre en place tout projet de développement d'une application web en Ruby.
Le système d'exploitation utilisé ici est Debian GNU/Linux version Etch. Vu la simplicité des exemples illustrés, ils sont facilement adaptables à tout environnement Linux/UNIX/BSD.
Pour une petite configuration, pour ceux qui ne peuvent se passer de vim comme moi, et pour éviter de perdre son temps à lancer les éléments constituants l'environnement complet, cet humble script illustre plutôt une "façon de faire". En soi, il n'apporte pas grand chose vu sa simplicité. C'est la philosophie UNIX, avoir ou développer des petits outils qui font peu de choses, mais ce qu'ils font, ils le font bien. Ensuite chacun peut piocher dans ces briques logicielles et les rassembler à façon afin d'obtenir un ensemble riche et parfaitement adapté à ses besoins!
Nous voulons assembler un environnement de développement complet qui se raproche des fonctionnalités d'un IDE. Pour cela, les éléments suivants sont assemblés en un script, i.e. un éditeur puissant, le langage de script Ruby, le framework de développement Rails, un outil pour des petits tests ruby en ligne de commande (irb), un environnement d'aide sur le langage ruby, son API, un environnement d'aide pour le framework Rails et ses classes, accéder de façon dynamique à l'application en cours de développement...
Tableau des logiciels à installer pour constituer cet environnement :
| ruby | le langage autour duquel sont assemblées les briques constitutives de notre environnement de développement. |
| Ruby On Rails | Le framework de développement d'applications web en langage Ruby. |
| gvim | Vim un éditeur puissant, |
| ctags | pour naviguer à travers les sources d'une application au sein de vim. |
| rox | Un navigateur de fichiers légers. Il n'est pas indispensable pour la navigation dans les sources de ruby quand vim et ctags sont déjà là, mais pour naviguer dans l'ensemble des fichiers d'un projet il apporte un petit plus avec son confort d'utilisation. |
| Firefox | Un navigateur web, permettant de naviguer sur la doc de ruby et Rails, de tester son application web et plus si affinités... |
| irb | un shell ruby permettant de réaliser toute sorte de tests ruby en lignes de commandes. Indispensable. |
| xfce4-terminal | Un terminal, c'est celui que j'utilise par défaut sur le bureau XFCE4. son intérêt est de gérer plusieurs terminaux avec des onglets. Ce n'est pas le seul qui fait cela, alors n'importe lequel fait l'affaire comme gnome-terminal sous Gnome ou équivalent sous KDE. |
Les choix que j'ai réalisés sont bien sûr très personnels. L'orientation est donnée à la légèreté et au dynamisme de l'ensemble, qui ne mettra pas 2 minutes à se lancer, mais quelques secondes. Enfin, petite exception, Firefox ne représente pas la légèreté, mais vu le nombre d'extensions destinées au tests et facilités pour le développement d'applications web, je me suis permis une petite incartade dans le monde des poids lourds ;)
Les paquets debian etch à installer pour obtenir le panel d'applicatifs décrit ci dessus
Suggestions pour quelques paquets supplémentaires :
Installation d'un paquet :
root# apt-get install nom_du_paquet
Le sript de démarrage de l'environnement est très simple, il se contente de de lancer les différentes briques constitutives de l'environnement de développement :
#!/bin/sh
# Fichier : envrails
# Objet : Lancement d'un environnement de développement Rails
# Date : mercredi 9 août 2006, 20:34:46 (UTC+0200)
# Auteur : Yann Le Thieis
#------------------------------------------------------------------------------
# Usage: envrails nom_de_l_application
###############################################################################
ENVRAILS=/home/yann/perso/projet/espace_rails/$1
export ENVRAILS
cd $ENVRAILS
/usr/bin/xfce4-terminal \
--geometry=90x21+0-0 \
--default-working-directory=$ENVRAILS \
--command="irb --simple-prompt" \
--tab \
--tab \
--execute /usr/bin/gvim -geometry 87x26+0+27 * &
/usr/bin/rox $ENVRAILS
/usr/bin/firefox file:///usr/share/doc/ruby/faq/rubyfaq.html file:///usr/share/doc/ruby/manual/index.html file:///usr/share/doc/rails/html/index.html http://127.0.0.1:3000 &
Je développe les applications rails dans un même espace /home/yann/perso/projet/espace_rails/. Dans cet espace, se trouvent des répertoires dont chaque nom de répertoire correspond au nom de l'application rails proprement dite.
Aussi, pour lancer l'environnement de développement sur une application rails, il me suffit de lancer la commande :
yann@yuluth: ~ $ envrails nom_de_l_application
Pour simplifier le lancement de l'environnement de développement, le contexte et la localisation du script sont :
yann@yuluth: ~ $ export PATH=$PATH:$HOME/bin
yann@yuluth: ~ $ ls $HOME/bin/envrails
/home/yann/bin/envrails
Le script lance un terminal XFCE, avec deux onglets, localisé dans l'espace de l'application. Un terminal onglet fait tourner irb et l'autre un shell.
Un éditeur gvim est lancé à partir du répertoire de l'application web.
Le gestionnaire de fichiers rox est lancé.
Enfin le navigateur web firefox est lancé directement avec plusieurs onglets, un onglet sur une faq ruby, un onglet sur la doc ruby, un onglet sur la doc de rails et un onglet sur l'application web (au démarrage du script elle n'est pas lancée.
Voici le résultat sur l'application exemple, développée par la suite :
L'exemple bateau par excellence, mais qui permet sous n'importe quel langage d'aphréhender les bases de la mise en oeuvre d'un programme.
Tout d'abords, plaçons nous sur l'espace de travail de Rails, et générons la base de ce qui va être notre application demo "Hello World" (certes statiques ici) :
yann@yuluth: ~ $ cd perso/projet/espace_rails/
yann@yuluth: espace_rails $ rails demo
create
create app/controllers
create app/helpers
create app/models
create app/views/layouts
create config/environments
create components
create db
create doc
create lib
create lib/tasks
create log
create public/images
create public/javascripts
create public/stylesheets
create script/performance
create script/process
create test/fixtures
create test/functional
create test/integration
create test/mocks/development
create test/mocks/test
create test/unit
create vendor
create vendor/plugins
create tmp/sessions
create tmp/sockets
create tmp/cache
create Rakefile
create README
create app/controllers/application.rb
create app/helpers/application_helper.rb
create test/test_helper.rb
create config/database.yml
create config/routes.rb
create public/.htaccess
create config/boot.rb
create config/environment.rb
create config/environments/production.rb
create config/environments/development.rb
create config/environments/test.rb
create script/about
create script/breakpointer
create script/console
create script/destroy
create script/generate
create script/performance/benchmarker
create script/performance/profiler
create script/process/reaper
create script/process/spawner
create script/runner
create script/server
create script/plugin
create public/dispatch.rb
create public/dispatch.cgi
create public/dispatch.fcgi
create public/404.html
create public/500.html
create public/index.html
create public/favicon.ico
create public/robots.txt
create public/images/rails.png
create public/javascripts/prototype.js
create public/javascripts/effects.js
create public/javascripts/dragdrop.js
create public/javascripts/controls.js
create public/javascripts/application.js
create doc/README_FOR_APP
create log/server.log
create log/production.log
create log/development.log
create log/test.log
yann@yuluth: espace_rails $
Un répertoire du nom de l'application demo est créé, et toute une sous arborescence de fichiers et de répertoires. Cela peut paraitre beaucoup pour un résultat qui va se contenter d'un affichage "Bonjour le monde!" sur notre navigateur. Il faudra pousser votre étude de Ruby on Rails, un peu plus loin que la portée de cet article pour vous apercevoir de la richesse que vous apporte cette construction par défaut ;)
Deux répertoires vont nous intéresser pour la suite, app et script.
Nous venons de générer les bases de notre applications web. Le développement d'applications Rails s'appuie sur le modèle MVC. La partie modèle ne nous intéressera pas ici (nous n'avons pas besoin de bases de données). Par contre, nous avons besoin d'un controleur pour traiter la requête url envoyée par le navigateur (l'accès à notre application). Nous appelerons ce contrôleur "Dire" et nous allons le créer comme ceci :
yann@yuluth: espace_rails $ cd demo
yann@yuluth: demo $ ./script/generate controller Dire
exists app/controllers/
exists app/helpers/
create app/views/dire
exists test/functional/
create app/controllers/dire_controller.rb
create test/functional/dire_controller_test.rb
create app/helpers/dire_helper.rb
Le controleur est créé, c'est une classe contenue dans le fichier app/controllers/dire_controller.rb :
yann@yuluth: demo $ cat app/controllers/dire_controller.rb
class DireController < ApplicationController
end
La classe est vide, et pour faire la jonction entre le contrôleur et une vue qui sera envoyée au navigateur, il nous faut une méthode que nous nommons "bonjour". Cette méthode, permet de réaliser une configuration et certaines actions avant d'appeler la vue. Pour nous, elle sera vide, étant donné que nous avons une vue statique :
yann@yuluth: demo $ cat app/controllers/dire_controller.rb
class DireController < ApplicationController
def bonjour
end
end
Maintenant, occupons nous de la vue qui est appelée par la méthode bonjour du contrôleur Dire. Rails fait le rapprochement automatiquement entre nom de la méthode et un fichier dans app/views/dire (répertoire portant le nom du contrôleur) portant le même nom que la méthode avec une extension .rhtml. Ce fichier est un fichier "format" (ou modèle "template"), qui dans notre cas d'étude est statique et ne contientra que du html :
yann@yuluth: demo $ vi app/views/dire/bonjour.rhtml
yann@yuluth: demo $ cat app/views/dire/bonjour.rhtml
<html>
<head>
<title>Notre bonjour au monde</title>
</head>
<body>
<h1>Bonjour le monde !</h1>
</body>
</html>
Et voilà, notre application demo est finie, il ne reste plus qu'à l'essayer. Une des richesses de Rails, c'est qu'il possède son serveur web intégré WebRick, bien pratique sur un poste de développement, nous pouvons tester notre application de suite sans installer de serveur web comme Apache.
Pour cela, il est pratique de dédier un onglet du terminal, pour le lancement et les traces de fonctionnement du serveur web intégré (il se trouve dans les sources générées pour notre application demo, dans le répertoire script :
yann@yuluth: demo $ ./script/server
=> Booting WEBrick...
=> Rails application started on http://127.0.0.1:3000
=> Ctrl-C to shutdown server; call with --help for options
[2006-08-10 16:49:28] INFO WEBrick 1.3.1
[2006-08-10 16:49:28] INFO ruby 1.8.4 (2005-12-24) [i486-linux]
[2006-08-10 16:49:28] INFO WEBrick::HTTPServer#start: pid=10369 port=3000
De plus, à son lancement, il nous indique comment accéder à l'application, ici via l'url http://127.0.0.1:3000.
Enfin pour obtenir la vue "bonjour" qui nous intéresse, il nous faut pour l'instant indiquer l'url complète qui prend en compte le nom du contrôleur et la méthode appelée : http://127.0.0.1:3000/dire/bonjour.
