Bienvenue sur mon blog.

J'ai découvert Rails il y a maintenant un an. J'ai trouvé que ce framework était absolument fantastique.

Il a fallut que je trouve une idée pour le tester. J'ai décidé de créer un annuaire de jeux en ligne (un de plus mais bon ...).

J'ai déjà fait les maquettes http://jeux.domozone.net . Et maintenant y'a plus ka !

Ce blog sera en fait un gros mémo de mes découvertes

Flux RSS :

1. 
   
2. 
   
3. Each avec index :
   
4. @something.each_with_index do |thing,index|
5.    puts index
6. end
7. 
   

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 :

Il semblerait que le repo :
http://dev.rubyonrails.com/svn/rails/plugins/
ne fonctionne plus.

En le remplaçant par :
http://dev.rubyonrails.org/svn/rails/plugins/

Ça fonctionne !!! :-)

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


Convertir un caractère en code ascii :
puts ?a
puts ?H

Convertir un code ascii en caractère :
puts 65.chr

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

Sur ubuntu, pour installer rails :

sudo apt-get install rails


Par défaut, le navigateur demande au serveur un flux html. On peut être amené à utiliser un flux xml (ou autre).

Rails sait gérer sa réponse en fonction du type demandé. Dans le controleur, on va indiquer comment répondre aux différents formats :

def list
  respond_to do |format|
    format.html # liste.html.erb
    format.xml  # liste.xml.erb
    format.js   # liste.js.erb
  end
end

l'exemple ci-dessus montre que l'on peut demander du html et du xml.

Pour répondre, format.html utilisera la vue list.html.erb et format.xml, utilisera la vue list.xml.erb.

On est pas obligé d'utiliser une vue pour le xml, on peut simplement sérialiser un objet :
def list
  @games = Game.find(:all)
  respond_to do |format|
    format.xml { render :xml => @games }
  end
end

le controleur enverra directement le flux xml correspondant à l'objet @games.

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

Si vous utilisez rails en entreprise, il y a de grandes chances que vous soyez derrière un proxy.

Pour pouvoir accéder à internet et donc aux maj, il faut positionner les variable suivantes :
HTTP_PROXY
HTTPS_PROXY

Sous windows :
set HTTP_PROXY=http://url_de_ton_proxy:ton_port_HTTP
set HTTPS_PROXY=http://url_de_ton_proxy:ton_port_HTTPS

Sous Linux :
export HTTP_PROXY=http://url_de_ton_proxy:ton_port_HTTP
export HTTPS_PROXY=http://url_de_ton_proxy:ton_port_HTTPS

On peut maintenant faire les maj :
gem update --system

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

Après avoir cherché longtemps le moyen de le faire proprement à la sauce ruby, j'ai trouvé ca :

@game = Game.find :first, :offset => ( Game.count * rand ).to_i

Ce qui revient au même que (en sql) :
select * games order by rand() limit 1;

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

Je suis à la recherche d'un hébergeur Rails gratuit

En cherchant sur les forum je n'ai rien trouvé de récent et d'intéressant sur des hébergeur gratuit.

Le seul que j'ai trouvé est : alwaysdata mais il est limité à 10Mo sinon l'interface et les possibilité ont l'air très bien.

Si quelqu'un a trouvé mieux ??? je suis preneur !

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

Pour ceux qui développent sur Linux, la connexion avec MySql ne fonctionne pas toujours correctement.

Par défaut la configuration suivant peut poser des problèmes :
development:
 adapter: mysql
 database: depot_development
 username: root
 password:
 host: localhost

Il faut la modifier par (testé sous ubuntu) :
development:
  adapter: mysql
  encoding: utf8
  database: depot_development
  username: root
  password:
  host: 127.0.0.1
  socket: /var/run/mysqld/mysqld.sock

-> remplacer localhost par 127.0.0.1

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.