Rien de plus simple que Google Charts on Rails pour créer des graphiques.

Page du projet :
http://code.google.com/p/google-charts-on-rails/

Il faut l'installer :

ruby script/plugin install http://google-charts-on-rails.googlecode.com/svn/google_charts_on_rails/

Sous NetBeans :

Ajouter le dépot :

http://google-charts-on-rails.googlecode.com/svn/

et installer le plugin google_charts_on_rails

En ce qui concerne l'utilisation, rien de plus simple :

Dans une vue :

Installer le plugin :
auto_complete

Générer la doc :
rake doc:plugins:auto_complete

<%= javascript_include_tag :all  %>
<%= text_field_with_auto_complete :appellation, :name, {}, {:method => :get} %>
ou suffisant :
<%= text_field_with_auto_complete :appellation, :name %>

class AppellationController < ApplicationController
  auto_complete_for :appellation, :name
  #protect_from_forgery :only => [:create, :update, :destroy]
  protect_from_forgery :except => :auto_complete_for_appellation_name

  def new
    @appellation = Appellation.new
  end

end




<%= text_field_with_auto_complete :message, :to, {},:url => {:action => :auto_complete_for_message_to, :id => session[:user].id}, :skip_style => true %>

http://www.xtended-blog.com/weblog/cascade_text_field_with_auto_complete/

Après la création d'un crontrolleur, pour éviter d'avoir l'erreur :
No route matches ”/moncontrolleur/monaction” with {:method=>:get}

il faut ajouter la ligne suivante à la fin de routes.rb
map.route '/:controller/:action'

Une autre solution consiste à ajouter pour chaque controlleur la ligne :
map.resources :moncontrolleurs

Installation du plugin :
Sous netbeans : ajouter le repo :
http://actsasnetwork.rubyforge.org/svn/plugins/acts_as_network/

en mode console :
sudo apt-get install git git-core (pour linux)
script/plugin install git://github.com/sjlombardo/acts_as_network.git

générer la doc :
rake doc:plugins

Version simple

Création d'une table des users
script/generate model user


class CreateUsers < ActiveRecord::Migration
  def self.up
    create_table :users do |t|
      t.string   :email
      t.string   :hashed_password
      t.string   :salt
      t.datetime :dateLastLogin
      t.timestamps
    end
  end

  def self.down
    drop_table :users
  end
end


script/generate model friend

class CreateFriends < ActiveRecord::Migration
  def self.up
    create_table :friends, {:id => false} do |t|
      t.column :user_id, :integer, :null => false
      t.column :user_id_target, :integer, :null => false      # target of the relationship
      t.timestamps
    end
  end

  def self.down
    drop_table :friends
  end
end


-> effectuer la migration

Modification des models

class User < ActiveRecord::Base
  acts_as_network :friends, :join_table => :friends
end


Controleur

  def test_acts_as_network
    jane = User.create(:email => 'Jane')
    jack = User.create(:email => 'Jack')

    jane.friends_out << jack                  # Jane adds Jack as a friend
    puts jane.friends.include?(jack)               # true Jack is Janes friend
    puts jack.friends.include?(jane)               # true Jane is also Jack's friend!
  end



Version avec invitations :


Création d'une table des users
script/generate model user


class CreateUsers < ActiveRecord::Migration
  def self.up
    create_table :users do |t|
      t.string   :email
      t.string   :hashed_password
      t.string   :salt
      t.datetime :dateLastLogin
      t.timestamps
    end
  end

  def self.down
    drop_table :users
  end
end


script/generate model invite

class CreateInvites < ActiveRecord::Migration
  def self.up
    create_table :invites do |t|
      t.column :user_id, :integer, :null => false           # source of the relationship
      t.column :user_id_target, :integer, :null => false    # target of the relationship
      t.column :code, :string                                 # random invitation code
      t.column :message, :text                                # invitation message
      t.column :is_accepted, :boolean
      t.column :accepted_at, :timestamp                       # when did they accept?
      t.timestamps
    end
  end

  def self.down
    drop_table :invites
  end
end



Modification des models

class User < ActiveRecord::Base
  acts_as_network :friends, :through => :invites, :conditions => "is_accepted = 1"
end

class Invite < ActiveRecord::Base
  belongs_to :user
  belongs_to :user_target, :class_name => 'User', :foreign_key => 'user_id_target'        # the target of the friend relationship
  validates_presence_of :user, :user_target
end


Controleur :

  def test_acts_as_network
    jane = User.create(:email => 'Jane')
    jack = User.create(:email => 'Jack')

    invite = Invite.create(:user => jane, :user_target => jack, :message => "let's be friends!")

    puts jane.friends.include?(jack)
    puts jack.friends.include?(jane)

    invite.is_accepted = true  # Now Jack accepts the invite
    invite.accepted_at = Time.now
    invite.save and jane.reload and jack.reload

    puts jane.friends.include?(jack)
    puts jack.friends.include?(jane)


  end


Pour créer un champ virtuel dans un controler, on utilise attr_accessor :

class Game < ActiveRecord::Base
 attr_accessor :bloque
end

Ce champ ne sera pas stocké en BDD mais sera accessible par l'instance de l'objet :
@game = Game.find 1
@game.bloque = "X"
puts @game.bloque

On peut aussi définir des méthodes :
class Game < ActiveRecord::Base
 attr_accessor :bloque
 def getInfo
   "#{id} / #{bloque}"
 end
end
 
@game = Game.find 1
@game.bloque = "X"
puts @game.getInfo

...

Comment utiliser le Slider de scriptaculous avec rails.

Il existe un plugin : scriptaculous_slider mais il ne fonctionne plus avec les versions récentes de rails mais on peut quand même s'en inspirer.

On récupère quand même le plugin :
./script/plugin install scriptaculous_slider

Il faut modifier Vendor/plugins/scriptaculous_slider/init.rb :
require 'helpers/slider_helper'
ActionView::Helpers::AssetTagHelper::register_javascript_include_default 'slider'
ActionView::Base.send :include, ActionView::Helpers::SliderHelper





Comment visualiser schema.rb au format UML (StarUML)

En ligne de commande :
./script/plugin install http://cnruby.googlecode.com/svn/trunk/plugins/uml

rake uml:schema

Pour les utilisateurs de Netbeans :
Click droite sur le projet -> Rails plugins
Dans l'onglet Repositories, ajouter l'url :
http://cnruby.googlecode.com/svn/trunk/plugins/
Aller dans l'onglet New Plugins et installer le plugin uml
Pour lancer la génération :
Click droite sur le projet -> Run/Debug Rake Task...
et lancer uml:schema
Et c'est tout, on obtient un fichier schema.xml dans db

Et pour le visualiser, sous StarUML :
File -> Import -> XMI...

Tuto basé sur :
http://blog.zmok.net/articles/2006/11/13/visualize-your-rails-schema

On peut importer facilement des données dans la bdd avec les fichiers yml :
test.yml
champ1:
  id: 1
  nom: durand
  prenom: jean

champ2:
  id: 2
  nom: dupont
  prenom: jacques

Importer les données d'un fichier dans test/fixtures/*.yml
rake db:fixtures:load

--------------------------------------------------------------------------------
/!\ pour certaines données comme les mot de passe, il faut mettre des " :
hashed_password: "c093739843181d80b35a84b1435a3f859d971b83"


Pour préciser les fichiers yml à importer :
rake db:fixtures:load FIXTURES:fichier1.yml,fichier2.yml

Cet article ne traite pas directement de rails mais est très pratique dans un projet de développement.

Si vous développez depuis plusieurs endroits, il est parfois fastidieux de trimbaler une clé usb avec ses sources. L'utilisation d'un serveur de version permet de gérer les modifications et sert aussi de sauvegarde (on a une copie de travail sur chaque poste et une copie sur le serveur).

Le plus utilisé est subversion (cvs est encore beaucoup utilisé mais vieillissant).
On va installer subversion de manière à ce qu'il fonctionne à travers apache. Comme cela on pourra y accéder en utilisant le protocole http.

L'idéal est de posséder un serveur sous linux (on peut utiliser un vieux pc).
Installation sous une distrib Ubuntu :

Installer les paquets nécessaires :
sudo apt-get install apache2 subversion libapache2-svn


sudo vi /etc/apache2/mods-available/dav_svn.conf
<Location /devsvn>
    DAV svn
    SVNPath /var/lib/svn
    AuthType Basic
    AuthName "Depot Subversion"
    AuthUserFile /etc/apache2/dav_svn.passwd
    Require valid-user
</Location>

Redémarrer apache pour prendre en compte le fichier précédent :
sudo /etc/init.d/apache2 restart

Création du repository :
sudo svnadmin create /var/lib/svn
sudo chown -R www-data\: /var/lib/svn

Création d'un accès pour monlogin :
sudo htpasswd -cs /etc/apache2/dav_svn.passwd monlogin
sudo chown www-data:www-data /etc/apache2/dav_svn.passwd

Récupération des sources :
Soit en ligne de commande :
svn checkout http://127.0.0.1/devsvn/monprojet/
ou avec Netbeans et le module Subversion

On peut aussi utiliser tortoisesvn sous windows

Pour pouvoir démarrer votre projet en rails 2.0.2, il faut faire quelques modifications au niveau du source :

- Modifier le fichier config/environment.rb
* Il faut mettre à jour la version de rails :

RAILS_GEM_VERSION = '2.0.2' unless defined? RAILS_GEM_VERSION
(il est aussi possible de mettre la ligne en commentaire)

Installation de mongrel sur un serveur Linux Ubuntu (Hardy)

Pour éviter d'avoir l'erreur :
ERROR:  Error installing mongrel:
        ERROR: Failed to build gem native extension.

/usr/bin/ruby1.8 extconf.rb install mongrel mongrel_rails
extconf.rb:1:in `require': no such file to load -- mkmf (LoadError)
        from extconf.rb:1

sudo apt-get install ruby-dev

Ensuite on installe mongrel :
sudo gem install mongrel mongrel_rails

Pour démarrer le serveur, il faut aller dans le dossier de l'application et taper :
./script/server mongrel

Tous les enregistrements par tri croissant
tab = User.find :all, :order=>"name asc"

On peut utiliser les fonctions find_by_xxxxxx pour un enregistrement et find_all_by où xxxxxx correspond au nom du champ de la table :
u = User.find_by_name("DUPONT")
<=>
u = User.find :first, :conditions=>"name = 'DUPONT'"

tab = User.find_all_by_name("DUPONT")
<=>
tab = User.find :all, :conditions=>"name = 'DUPONT'"

on peut conbiner (and seulement fonctionne pour l'instant -> tester pour or)
tab = User.find_all_by_name_and_prenom("DUPONT", "PIERRE")

les recherches sont très lisibles

Tester le résultat d'une recherche :
tab = User.find_all_by_name("DUPONT")
if !tab.empty?
   # find_all retourne un tableau
end

tab = User.find_by_name("DUPONT")
if !tab.nil?
   # find retourne un enregistrement ou null si rien
end

Compter le nb d'enregistrements dans la table
c = User.count
avec critère
c = User.count "name = 'DUPONT'"

Répondez à ce sondage :

Quel est votre environnement de développement préféré pour Ruby on Rails 
(  polls)

Vous pouvez m'indiquer d'autres choix

Ajouter un champ dans une table via migration
ruby script/generate migration email
rake db/migrate

class Type < ActiveRecord::Migration
  def self.up
    add_column :personnes, :type, :string
  end
end

/!\ ne fonctionnera pas correctement il est préférable d'utiliser :
class Type < ActiveRecord::Migration
  def self.up
    add_column :personnes, :type_personne, :string
  end
end

C'est parti.

Comme je l'ai précisé dans l'article "Comment développer ????" ce tuto est basé sur Netbeans :

1 - Création d'un nouveau projet :
     File -> New Project
     et on choisit Ruby -> Ruby on Rails Application
     Next >

     Ensuite on configure la connexion MySql
     il faut sélectionner Specify Database Information Directly

Notepad et vi c'est bien sympa mais faut pas exagérer quand même, perso je préfère un bon IDE. J'ai essayé au début Eclipse (RadRails) mais franchement , j'ai pas trouvé ça top. Alors j'ai téléchargé Netbeans. Et là, miracle ! Tout il est bo, bien configuré, rien à faire.
En résumé :
- Télécharger Netbeans sur http://www.netbeans.org/ en sélectionnant la version Ruby.
- Installer un serveur MySql (on peut utiliser xampp)

Pas besoin d'installer Ruby car Netbeans intègre par défaut une implémentation java de ruby : jruby.
Pas besoin non plus d'installer un serveur d'appli car il intègre par défaut Webbrick et glassfish.