La dernière fois, nous avons créé le projet et lancé l’application (Pibou, rails & premier déploiement). Il est temps de réaliser notre première page et de comprendre un peu mieux les rouages du projet.

La magie du scaffolding

Le scaffolding est tout simplement un outil de génération de code dont nous allons nous servir pour créer nos premiers fichiers. La structure sera la plus simple possible: un film possède un titre. Avant de commencer, il faut savoir que Rails utilise un pattern MVC pour la structure du projet.

$rails generate scaffold Movie title:string

On peut revenir en arrière via la commande :

$rails destroy scaffold Movie

Mais intéressons nous plutôt aux fichiers créés ou modifiés lors du generate.

Les données

La génération commence par la création d’un fichier de migration dans « pibou/db/migrate ». Le nom du fichier généré utilise un timestamp et le nom de l’action (create movies). Ce fichier de migration est utilisé pour la mise à jour de la base de données.

Nous allons appliquer la migration via la commande lancée à la racine du projet :

$rake db:migrate

Cette commande permet d’appliquer les migrations au schéma de la base dans « pibou/db/schema.rb ». Pour de plus amples informations sur ces mécanismes : http://guides.rubyonrails.org/migrations.html.

Le model

Dans « pibou/app/models/ », on retrouve notre modèle, dont notre objet  fraîchement créé « movie.rb ».

class Movie < ActiveRecord::Base
end

Le contenu de ce fichier peut être déroutant, en fait il est pratiquement vide. Il faut s’habituer à avoir tous les attributs présents dans le schéma de la base : « pibou/db/schema.rb ».

ActiveRecord::Schema.define(:version => 20120311175909) do

  create_table "movies", :force => true do |t|
	t.string   "title"
	t.datetime "created_at", :null => false
	t.datetime "updated_at", :null => false
  end

end

Les tests

Les tests unitaires se situent dans « pibou/test/unit/ », ils utilisent par défaut des fichiers yaml présent dans « pibou/test/fixtures/ ». Il existe également des tests pour les contrôleurs dans « pibou/test/functionnal/ ». Pour aller plus loin : http://guides.rubyonrails.org/testing.html.

Les contrôleurs

Ils sont présents dans « pibou/app/controllers ». Pour l’instant nous avons 2 contrôleurs :

• application_controller.rb qui est le contrôleur dont hérite tous les autres contrôleurs.
• movies_contoller.rb qui fourni le comportement et le rendu associé

Le scaffolding a généré toutes les méthodes de bases. Pour plus de détails : http://guides.rubyonrails.org/action_controller_overview.html.

Les vues

Elles se trouvent dans « pibou/app/views/ ». Pour chaque objet du model, on va retrouver un répertoire qui contient le rendu des différentes actions :

• « pibou/app/views/movies/index.html.erb » => liste des films
• « pibou/app/views/movies/edit.html.erb » => edition d’un film
• « pibou/app/views/movies/show.html.erb » => visualisation d’un film
• « pibou/app/views/movies/new.html.erb » => création d’un film
• « pibou/app/views/movies/_form.html.erb » => le _ indique un partial, pour faire simple un template de formulaire réutilisable.

Les helpers

Ils trouvent dans « pibou/app/helpers » et sont, comme leur nom l’indique, des classes fournissant des méthodes d’aide réutilisables dans les vues (formatages etc…). Dans notre cas, « pibou/app/helpers/movies_helper.rb ». Les tests des helpers sont dans « pibou/tests/helpers ».

Les assets

Trois fichiers sont générés :

• « pibou/app/assets/stylesheets/movies.css.scss » pour la feuille de style (sass) spécifique aux films
• « pibou/app/assets/stylesheets/scaffolds.css.scss » pour la feuille de style (sass) générale
• « pibou/app/assets/javascripts/movies.js.coffee » pour le javascript (coffescript)

Vous avez pu remarquer les extensions « doubles » sur les fichiers telles que .css.scss ou .html.erb, il s’agit d’une convention bien pratique. Prenons le cas .html.erb => il faut lire fichier en erb qui génère du html.

Les routes

Il s’agit du fichier « pibou/config/routes.rb ». Ce fichier est très important et vous aurez à le manipuler avec soin. Il permet de définir la gestion des url : qui répond à quoi. Dans notre cas, la génération a ajouté

resources :movies

Cette ligne spécifie que toutes les opérations de bases sont routées. Pour en avoir le coeur net, une petite commande que vous utiliserez souvent (à la racine du projet):

$rake routes

Vous avez maintenant la liste des url et actions http associées avec un contrôleur. Par exemple :

movies     GET     /movies(.:format)    movies#index

Lire qu’un get sur movies quelque soit le format est redirigé sur la méthode index du contrôleur de movies. Pour simplifier, http://127.0.0.1:3000/movies est traité par la méthode index de movies_controller. Pour plus d’informations : http://guides.rubyonrails.org/routing.html.

L’application

Bon, c’est bien joli tout ça, mais au final on a quoi ? Je vous propose de lancer votre serveur et d’aller voir l’application :

$rails server

Dans votre navigateur favori : http://127.0.0.1:3000/movies.

Bienvenue dans votre application, vous pouvez ajouter des films, les voir et les supprimer. Vos données sont sauvegardées dans « pibou/db/development.sqlite3 ». Nous approfondirons dans un prochain article.

Et après ?

Maintenant que nous avons quelque chose à partager, le prochain article abordera l’utilisation de Git et GitHub.

@bientôt