Positionnez-vous dans le répertoire de votre application, puis tapez le code suivant :

ruby script/generate controller erreur404

Créez à présent un fichier "index.rhtml" dans "app/views/erreur404" et personnalisez-le.

Il ne reste plus qu'à éditer le fichier routes.rb dans config/ et à rajouter cette ligne à la fin :

map.connect '*erreur', :controller=>"erreur404"

Il va falloir utiliser les filtres, afin d'envoyer les bonnes entêtes au navigateur. Modifiez votre fichier app/controllers/application.rb comme suit :

class ApplicationController < ActionController::Base
  before_filter :headers_iso
 
  def headers_iso
    headers["content-type"]= "text/html; charset=iso-8859-1"
  end
end

Vous pouvez également le gérer via l'encodage des fichiers en UTF-8. Dans RadRails / Eclipse, faites un clic-droit sur la racine du projet, puis "Properties". Vous aurez alors un champs "text file encoding". Forcez la valeur "UTF-8", et voilà.

Il existe plusieurs plugins :

• auth_generator, qui ajoute directement le code d'autentification dans l'application
• act_as_athentificate (AAA), qui fait en sorte que le modèle utilisateur ait les méthodes d'authentification
• Authorization Plugin, que l'on peut également associer à AAA
• Rbac, qui est une engine (un type de plugin spécial qui a la propriété d'être indépendant de l'application), et qui va apporter une gestion fine des rôles (définition de ses propres rôles)
• etc.

Supposons le tableau suivant :

tableau = ["Gérard","Maitre",1]

Génération en rhtml :

<select>
   <% tableau.each do |elements|%>
      <option ><%= elements %></option>
   <% end %>
</select>

Génération en ruby :

<%= select :p, :nomSelect ,tableau%>
 
#:p représente le nom id()
#:nomSelect représente le nom du select
#tableau vaut le tableau

Supposons le hash suivant :

tableau_assoc = {
  "Gérard"=>"Beau",
  "Maitre"=>"Pylos",
  1=>2
}

Génération en rhtml :

<select>
  <% tableau_assoc.each do |cles,valeur|%>
  <option value="<%=valeur%>" > <%= cles %></option>
  <% end %>
</select>

Génération en ruby :

<%= select :p, :nomSelect ,tableau_assoc %>
 
#:p représente le nom id()
#:nomSelect représente le nom du select
#tableau vaut le tableau

Les flash sont de très proches cousins des sessions. Ils permettent de faire transiter de l'information d'une action à une autre.

La seule différence réside dans le fait qu'une fois passés à la seconde action, les flash ne se transmettront pas à une troisième (sauf à utiliser la méthode flash.keep).

Dans le fichier modele (app/modele/exemple.rb), on selectionne la table par "set_table_name" :

class Exemple < ActiveRecord::Base
  set_table_name "nomTable"
end

Il suffit de rajouter ":class" dans la partie html_option :

<%= button_to "Voir", {:action=> 'show', :id=>motsphrase}, :class=>"boutonvert" %>

Ce qui donnera le code source suivant :

<form method="post" action="/admin/show/1" class="button-to">
   <div>
      <input class="boutonvert" type="submit" value="Voir" />
   </div>
</form>

Tout d'abord, installez SQLite (vous pouvez télécharger SQLite sur le site officiel). Sous windows, copiez simplement le fichier "sqlite3.dll" dans le répertoire bin de ruby.

Installez maintenant les librairies SQLite pour ruby :

gem install sqlite3-ruby

J'ai choisi le deuxième choix (2. sqlite3-ruby 1.2.1 (mswin32)).

Il ne vous reste plus qu'à vous connecter à votre base.
Paramétrez votre fichier config/database.yml comme suit :

development:
  adapter: sqlite3
  database: db/test
  #username: root
  #password:
  #host: localhost

Vous l'aurez compris, la base de données s'appelle "test", et est placée dans le répertoire "db" de l'application Rails.

Si vous souhaitez un outil graphique pour gérer vos bases, vous pouvez télécharger l'excellent SQLite Database Browser.

Supposons que vous vouliez afficher directement votre controller admin(app/controller/admin).

Supprimez le fichier "index.html" dans le dossier "public/".

Modifier le fichier "/config/routes.rb" et commentez la ligne suivante (si cela n'est déjà pas fait) :

map.connect '', :controller => "welcome"

Ajoutez la ligne suivante (toujours dans le fichier "/config/routes.rb") :

map.connect '', :controller => "admin"

Au prochain démarrage à l'adresse http://localhost:3000, votre controller admin apparaitra.

Dans le répertoire de votre application Rails, tapez simplement la ligne suivante en ligne de commande (cela suppose que le fichier "config/database.yml" soit bien configuré) :

rake db:schema:dump

Il ne vous restera plus qu'à aller regarder le fichier "schema.rb" situé dans le répertoire "db" de votre application.

Pour créer une table "utilisateurs", placez-vous dans le répertoire de votre application Rails, et tapez la ligne de commande suivante :

ruby script/generate model utilisateur

Rails vous génèrera alors plusieurs fichiers :

create app/models/utilisateur.rb
create test/unit/utilisateur_test.rb
create test/fixtures/utilisateurs.yml
exists db/migrate
create db/migrate/XXX_create_utilisateurs.rb

Avec XXX un numéro de migration autoincrémenté.

Il ne vous reste plus qu'à effectuer votre migration.

Dans le répertoire de votre application Rails, tapez la ligne suivante en ligne de commande :

rake db:migrate VERSION=XXX

Avec XXX le numéro de version vers lequel vous souhaitez migrer (dans un sens ou dans l'autre).

A noter tout de même : Rails exécutera tous les fichiers de migration situés entre le numéro de migration actuel et le numéro de migration final.

Il suffit de créer un nouveau fichier de migration.
Pour l'exemple, nous allons ajouter un champs "nom" à la table "personnes".

Placez-vous dans le répertoire de votre application Rails, et tapez la ligne suivante dans l'invite de commande :

ruby script/generate migration ajout_champ_nom_personnes

Rails va vous créer le fichier suivant :

db/migrate/XXX_ajout_champ_nom_personnes.rb

XXX étant le numéro de la migration, généré automatiquement par Rails.

Il ne vous reste plus qu'à éditer ce fichier comme suit :

class AjoutChampNomPersonnes < ActiveRecord::Migration
  def self.up
    add_column :personnes, :nom, :string, :limit=>50
  end
 
  def self.down
    remove_column :personnes, :nom
  end
end

Puis à effectuer votre migration.

Il suffit de créer un fichier "application.rhtml" dans la répertoire "views/layouts", et d'y insérer la code html de la page web :

Exemple :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" *"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta http-equiv=Content-Type content="text/html; charset=utf-8" />
    <title>Ma page Web</title>
    <%= stylesheet_link_tag "Style" %>
    <%= javascript_include_tag "default" %>
</head>
<body>
    <%= yield %>
</body>
</html>

La balise stylesheet_link_tag "Style" permet de définir le fichier CSS suivant : /public/stylesheets/Style.css.
On remarquera qu'avec les balises rails, nul besoin de mettre l'extension .css.

La balise javascript_include_tag "default" permet d'insérer les fichiers javascript fournis par rails ou par vous. "default", insère automatiquement tous ceux fournis par Rails.

La balise yield est la plus importante. C'est ici que seront interprétés tous vos controllers.

Il suffit de rajouter le code suivant dans le fichier config/environment.rb :

	ActiveRecord::Base.pluralize_table_names = false

Saisissez le code suivant dans la vue :

<%= form_tag({:action => 'upload'}, {:multipart => true}) %>
	<%= file_field_tag :fichier %>
<%= end_form_tag %>

Et le code suivant dans votre controlleur :

def upload
	file = params[:fichier]
	if file.size > 0
		File.open("#{RAILS_ROOT}/public/images/#{file.original_filename}", 'w+') do |f|
			f.write(file.read)
		end
	end
end

Cela enregistre le fichier dans le dossier /public/images de votre application Rails, à vous de modifier en fonction de votre besoin.

Il suffit de passer les paramêtres comme suit :

<%= image_submit_tag "edit.gif", :onmousedown=>"this.src='/images/edit_down.gif'", :onmouseup=>"this.src='/images/edit.gif'", :onmouseout=>"this.src='/images/edit.gif'" %>

Attention, à part pour le premier paramètre, il faudra préciser le chemin complet de l'image !

Dans un contrôleur, il suffit de mettre la ligne suivante :

scaffold :[le_nom_du_modèle]

Lancez une console ruby depuis votre projet

$ruby script/console
>> "cheval".pluralize
=> "chevals"
>> "man".pluralize
=> "men"

Par exemple, pour ajouter des exceptions telles que "cheval / chevaux" ou "scenario /scenarii", editez "/config/environnement.rb" et rajoutez à la fin :

# Add new inflection rules using the following format
Inflector.inflections do |inflect|
	inflect.irregular 'cheval', 'chevaux'
	inflect.irregular 'scenario', 'scenarii'
end

Note : il est possible d'ajouter des règles de type "al"/"aux", mais on peut se demander s'il n'est pas plus simple de se contenter d'ajouter les exceptions dont on aura besoin vu que :

• ces considérations restent locales à un projet
• le nombre de cas à traiter est en principe peu important pour un même projet
• qu'il doit être possible de compléter le fichier d'exceptions mais quid lors d'une évolution de ruby

Ajoutez l'option "-c [mon_charset]" à la commande rdoc.

Exemple pour une application rails "Personnes", sous windows, dont le charset est positionné sur "utf-8" :

C:\rails\personnes\rdoc -c utf-8

Il faut utiliser "super".
Dans l'exemple suivant :

• On suppose une table "personnes" contenant un champ "nom".
• Dans le modèle nous redéfinissons l'accesseur au champ, afin d'encadrer le comportement initial (super) par notre propre traitement

class Personne < ActiveRecord::Base
 
	#redéfinition de l'accesseur en ecriture de l'attribut "nom" 
	def nom=(value)
		#Avant affectation (pour test en console)
		s = self.nom || "nil"; 	puts('avant [' + s + ']')
 
		#Rails stp, fait ce que tu as à faire 
		#(et que tu faisais si bien avant que je ne surcharge ton travail)
		super
 
		#Après affectation (pour test en console)
		s = self.nom || "nil"; 	puts('après [' + s + ']') 
	end
end