Développeur Web RoR

Aller au contenu | Aller au menu | Aller à la recherche

Tag - tutorial

Fil des billets

mardi 10 mai 2011

Un bon grand tutorial pour Gimp

Par rivsc le mardi 10 mai 2011, 16:23

Bon voilà je fais la promo du site du zero pour la bonne cause : l'adoption de Gimp par le grand public et les professionnels !

La version cible de ce grand tutorial de Gimp est la 2.6 donc la dernière stable, et puis comme la 2.8 tarde à sortir et que l'interface (enfin le menu) ne changera pas des masses, ça vaut le coup de le bouquiner.

Voici l'adresse du tuto gimp : http://www.siteduzero.com/tutoriel-3-462917-debuter-dans-l-infographie-avec-gimp.html

samedi 26 mars 2011

Boutons partage sur les réseaux sociaux pour les gandi blog

Par rivsc le samedi 26 mars 2011, 18:01

J'ai vu que pas mal de personne cherchent comment ajouter des boutons de partage sur les gandi blog. Donc j'ai fait un petit script qui vous fait ça. 

1) Vous devez mettre un titre et sauvegarder votre billet (même si le contenu est vide)

2) Vous devez récupérer le lien de l'article (zone "URL spécifique" à droite) CLIC dans le champ, puis CTRL + A, puis CTRL + C.


3) Vous collez l'url dans le champ prévu à cet effet, ici : boutons réseaux sociaux , vous finissez de remplir le formulaire et puis cliquez sur "Générer le code".

4) Vous récupérez le code généré et vous le collez en bas dans l'onglet source (ou au début si vous voulez que les boutons apparaissent en haut de l'article) 

5) Vous enregistrez de nouveau votre billet et hop c'est dans la boite !

un commentaire

mardi 14 décembre 2010

Tutorial Rubyonrails 3 - Partie 4 - ActiveRelation et scopes - Arel

Par rivsc le mardi 14 décembre 2010, 12:53

Partie 4 – Rails3 -  ActiveRelation et scopes

N’hésitez à mettre des commentaires / à corriger mes fautes / à rajouter des choses !

Vous avez vu dans la partie 2 :

post = Post.where(:title => ’Mon titre’).first

Il existe de nombreux scopes ActiveRelation :

joins
limit
order
includes
where
offset

Vous aurez remarqué que ces termes ressemblent à SQL....

Donc si vous souhaitez trouver les 10 derniers commentaires visibles du post d’id 3, trié par ordre de création décroissant et qui contiennent la lettre ‘a’ dans leur contenu (l’exemple est volontairement compliqué pour que vous puissiez voir un aperçu assez complet):

comments = Comment.where(:post_id =>  3, :visible => true).where("content LIKE ?", "%a%").order(‘created_at DESC’).limit(10).all

Vous avez remarqué ce champ que j’utilise et qui apparait comme ça : created_at . Il s’agit de la date/heure de la création de l’objet. Rails l’ajoute par défaut dans la migration (ainsi que updated_at : date/heure de la dernière modification), ces champs m’ont toujours servi d’une manière ou d’une autre.
Vous noterez aussi que l'on peut chainer les scopes where.

Vous pouvez créer vos propres scopes et ils se définissent dans les models.
Par exemple si vous souhaitez filtrer les commentaires par visible :
Dans le model Comment :

class Comment < ActiveRecord::Base
 #Remarquez le singulier
 belongs_to :post
 belongs_to :reader

 scope :visible, where(:visible => true)
end

La syntaxe est :

scope :nom_du_scope, where(...).order....

Vous pouvez maintenant utiliser votre scope :

comments = Comment.where(:post_id =>  3).visible.order(‘created_at DESC’).limit(10).all

Quand vous voulez recupérer des enregistrements vous devez faire .all à la fin de l’ActiveRelation ou .first si vous ne souhaitez qu’un élément.

C’est un avantage (qui n’existait pas dans rails 2), du coup vous pouvez garder des ActiveRelations et continuer de chainer les conditions (d’un point de vue technique la requête SQL n’est executé que lorsque l’on appelle .all, .each, .length ou .first sur l’ActiveRelation):

Vous pouvez tester le chainage des scopes en console (rails c) :

ar = Comment.where(:post_id =>  3)
ar.length
ar = ar.visible
ar.length
ar = ar.order(‘created_at DESC’)
ar.length
ar = ar.limit(10)

Un peu de lecture:http://guides.rubyonrails.org/active_record_querying.html

Prochainement Partie 5 – Controller, actions

lundi 1 novembre 2010

Tutorial Rubyonrails 3 - Partie 3 - Création des relations entre les models (détail relation et migration)

Par rivsc le lundi 1 novembre 2010, 20:02

Partie 3 – Rails3 -  Création des relations entre les models (détail relation et migration)

N’hésitez à mettre des commentaires / à corriger mes fautes / à rajouter des choses !

Rails intègre un système de migration. Chaque migration et un fichier ruby qui modife la structure de la base de données.

Donc si vous avez besoin de renommer un champ, de rajouter une table, de rajouter un champ, de supprimer un champ vous devez créer une migration.

Les migrations se trouvent dans monblog/db/migrate . Vous devez en avoir 3, car rails generate model crée une migration pour rajouter une table dans la base de données.

Pourquoi parler des migrations ?

Eh bien, nous avons les models, nous savons les manipuler. Mais ActiveRecord est encore un peu plus puissant, il gère les relations entre les models pourvu que nous suivions les conventions !

Souvenez-vous dans la partie 2 :

reader : celui qui laissera un ou plusieurs comments sur un post.
post : un article du blog, il possède plusieurs comments.
comment : les commentaires des readers sur un post.

Nous allons donc créer une migration pour ajouter les clés étrangères oubliées  (volontairement) lors du rails generate model.

Donc créons une migration pour ajouter les clés étrangères:
rails generate migration add_foreign_keys

Ouvrons le fichier (monblog/db/migrate/XXXXXXXXXXXXX_add_foreign_keys.rb):

class AddForeignKeys < ActiveRecord::Migration
 def self.up
   #On met ici le code pour passer à un nouveau schéma de la base de données
 end

 def self.down
   #On met ici le code pour passer à la version précédente du schéma de la base de données
 end
end

Exemple :
On peut ajouter une colonne / supprimer une colonne / renommer une colonne
Attention les tables sont toujours au pluriel !
- Les noms de table correspondent aux noms des models au pluriel
- Les noms des tables de jointure (has_and_belongs_to_many) se nomment suivant cette convention : nom des models au pluriel par ordre alphabétique séparés par un underscore _ .

add_column ‘ma_table_au_pluriel’, ‘mon_champ’, :type
remove_column ‘ma_table_au_pluriel’, ‘mon_champ’
rename_column ‘ma_table_au_pluriel’, ‘ancien_nom’, ‘nouveau_nom’

Les types disponibles sont les mêmes que dans la partie précédente du tutorial.

Un peu de lecture
http://guides.rubyonrails.org/migrations.html

Par convention les clés étrangères se notent : model au singulier + “_id”, donc pour notre blog:

class AddForeignKeys < ActiveRecord::Migration
 def self.up
   #On met ici le code pour passer à un nouveau schéma de la base de données
   add_column ‘comments’, ‘post_id’, :integer
   add_column ‘comments’, ‘reader_id’, :integer
 end

 def self.down
   #On met ici le code pour passer à la version précédente du schéma de la base de données, donc l’inverse de ce qu’il y a dans up
   remove_column ‘comments’, ‘post_id’
   remove_column ‘comments’, ‘reader_id’
 end
end

Puis on applique les changements au schéma de base de données

rake db:migrate

Pour revenir en arrière d’une migration : rake db:rollback, mais ne le faites pas.

Maintenant il faut dire à rails qu’il existe des relations entre nos models. Il existe plusieurs types de relation gérés dans les models :

  • belongs_to
  • has_one
  • has_many
  • has_many :through
  • has_one :through
  • has_and_belongs_to_many (suivez les conventions pour créer la table de jointure : noms des tables au pluriel par ordre alphabétique séparés par _ )


Je vous (oblige / conseille fortement) de lire en anglais (mais c’est facile à comprendre) :
http://guides.rubyonrails.org/association_basics.html#the-types-of-associations

Pour nous :

Model Post :
Un article  à plusieurs commentaires

class Post < ActiveRecord::Base
 #Remarquez le pluriel (avec le "s" à comments)
 has_many :comments

 # Méthode d’instance qui renvoie le nombre de commentaires
 def nb_comment
   return self.comments.length
 end

 # Méthode de classe (précédé de self. ) qui affiche “Méthode de classe”
 def self.nb_post
   return Post.all.length
 end
end

Model Comment :
Un commentaire appartient à un article et est écrit par une personne

class Comment < ActiveRecord::Base
 #Remarquez le singulier
 belongs_to :post
 belongs_to :reader
end

Model Reader :
Un lecteur du blog peut écrire plusieurs commentaires

class Reader < ActiveRecord::Base
 #Remarquez le pluriel (avec le "s" à comments)
 has_many :comments
end

Maintenant, rails connait les relations, nous pouvons donc manipuler les objets comme ceci :
Vous pouvez tester en console (rails console ou rails c) !

post = Post.new(:title => ‘titre 1’)
post.save

reader = Reader.new(:pseudo => ‘rivsc’)
reader.save

comment = Comment.new(:content => ‘Mon commentaire 1’)
#Grace aux relations
comment.reader = reader
comment.post     = post
comment.save

#Renvoie le pseudo de la personne qui a mis le “Mon commentaire 1”
comment.reader.pseudo

comment = Comment.new(:content => ‘Mon commentaire 2’)
#Grace aux relations
comment.reader = reader
comment.post     = post
comment.save

#remarquez le pluriel, car le post peut avoir plusieurs commentaires (has_many :comments)
#Ceci renvoie un tabeau avec les commentaires associés au post
#nous voilà presque débarrassés de sql :-p
post.comments

Un peu de lecture : http://guides.rubyonrails.org/migrations.html

Prochainement Partie 4 – ActiveRelation et scopes

lundi 18 octobre 2010

Tutorial Rubyonrails 3 - Partie 2 - Création des models (rails generate model)

Par rivsc le lundi 18 octobre 2010, 20:45

Partie 2 – Rails3 -  Création des models (rails generate model)

N’hésitez à mettre des commentaires / à corriger mes fautes / à rajouter des choses !

Allons-y notre blog a besoin de quelques models :

reader : celui qui laissera un comments sur un post.
post : un article du blog, il possède plusieurs comments.
comment : les commentaires des readers sur un post.

J 'ai volontairement mis en gras des termes pour qu'apparaissent les relations entre les models (ce que nous verrons la prochaine fois).

Comme nous l’avons vu plus haut nous allons utiliser : Rails generate model

La syntaxe est :

Rails generate model monmodel champ:type champ:type...

Voici les types disponibles:
  • string      (chaine 255 caractères)
  • text      (texte sans limite de caractère)
  • datetime    (champs date heure)
  • date      (champs date)
  • integer      (entier)
  • numeric     (champs pour des nombres avec précision)
  • float      (nombre décimal, à virgule...)
  • boolean     (booléen : true / false)

Pour notre blog:

rails generate model reader pseudo:string www:string
rails generate model post title:string content:text visible:boolean
rails generate model comment content:text visible:boolean

Nous avons nos models, mais que faire avec des models ?
Ils servent à faire le lien avec la base de données, à gérer les relations entre les models. On ne manipule quasiment plus de sql.

Executez les migrations, nous verrons plus tard de quoi il s’agit mais faites-le !
rake db:migrate

Vous pouvez tester les lignes de code qui suivent en lancant la console (pour quitter la console rails : tapez exit) :

rails console ou rails c

Pour créer un article :

post = Post.new(:title => “Mon titre”, :content => “contenu de mon article”, :visible => false)
post.save

Pour chercher un article par son ID :

post = Post.find(1)
ou
post = Post.where(:id => 1).first

Pour chercher un article par son title :

post = Post.where(:title => “Mon titre”).first

Pour le supprimer :

post.destroy

Rails (ActiveRecord pour être précis) se charge de construire les requêtes sql pour nous.
Attention si vous voyez find_all_by... ou find(:all) c’est vieux c’est rails 2 :-p

Maintenant que vous avez créé vos models vous pouvez aller les voir dans monblog/app/models .

Vous pouvez ajouter des méthodes d’instances (qui s’applique sur l’objet instancié) et des méthodes de classes dans vos models.

Exemple pour notre blog :

class Post < ActiveRecord::Base
 # Méthode d’instance qui renvoie le nombre de commentaire
 def nb_comment
   return self.comments.length
 end

 # Méthode de classe (précédé de self. ) qui affiche “Méthode de classe”
 def self.nb_post
   return Post.all.length
 end
end

Vous pouvez appeler votre méthode d’instance de cette manière (sur un objet instancié)

post = Post.find(1)
post.nb_comment

Et votre méthode de classe comme ceci (directement sur la classe) :

Post.nb_post

Attention ces 2 méthodes devraient être des scopes, c’est plus adapté mais c’était pour l’exemple.

Prochainement Partie 3 – Création des relations entre les models (détail relation et migration)

mercredi 13 octobre 2010

Tutorial Rubyonrails 3 - Partie 1 - MVC, model, view, controller (rails command)

Par rivsc le mercredi 13 octobre 2010, 12:22

Partie 1 – Rails3 - MVC, model, view, controller (rails command)

N’hésitez à mettre des commentaires / à corriger mes fautes / à rajouter des choses !

Maintenant que vous avez créé votre projet vous allez avoir besoin de créer des models, vues et controlleurs.
Rapide rappel pour ceux qui n'ont jamais entendu ces termes :

Pattern MVC : modèle, vues, controleur (model, view, controller)

Model : class du monde réel (voiture, chien, article, commentaire)
View : les fichiers qui présentent les donnés (pour nous des fichiers html, pdf, …)
Controller : permet de faire des traitements sur les modèles, charger un objet, le modifier...

Voir aussi :
http://fr.wikipedia.org/wiki/Mod%C3%A8le-Vue-Contr%C3%B4leur

La commande « rails generate » permet de vous macher le travail.
Rails generate scaffold : permet de créer un model, avec son controller et ses views
Rails generate model : permet de créer un model
Rails generate controller : permet de créer un controller
Rails generate -h vous donnera plus de détail !

Il existe d'autres commandes

Rails server (ou rails s): démarre le server
Rails console (ou rails c) : démarre la console, cette console charge tout le code de l'application et vous permet de taper du code en live.

Et d'autre commande rails dont je ne m'occupe pas pour le moment !

Par contre il est intéressant de voir les tâches rake  (rake est censé être un « make » pour ruby):
En console faite :

rake -T

Voici différentes tâches (tasks) bien pratique :

rake db:migrate    #permet de mettre à jour le schéma de base de données grâce aux migrations (nous verrons plus tard les migrations : partie 3)
rake routes #permet de voir les routes de l’application. (nous verrons plus tard les routes)

Vous pouvez tester votre serveur ! Executez ces commandes dans l’ordre :

#Installe les gems manquant
bundle install
#execute les migrations
rake db:migrate
#démarre le serveur
rails server

Lancez votre navigateur à l'adresse

http://localhost:3000/

Vous allez voir une page qui décrit votre environnement rails.

Prochainement Partie 2 – Création des models (rails generate model)

mardi 12 octobre 2010

Tutorial Rubyonrails 3 - Partie 0 - Arborescence d'un projet rails3 et environnement

Par rivsc le mardi 12 octobre 2010, 22:53

Tutorial Rubyonrails 3 - Partie 0 - Arborescence d'un projet rails3 et environnement

Il s’agit de la première partie d’une série de tutorials rubyonrails 3 pour les novices qui ne connaissent pas rails 2.
N’hésitez à mettre des commentaires / à corriger mes fautes / à rajouter des choses !
Bon créons une application rails (le classique blog) :

rails new monblog

Voici l'arborescence générée :

app : il contient le code source de votre application
app/controllers : il contient les controllers
app/helpers : il contient les helpers
app/mailers : il contient les mailers
app/models : il contient les models
app/views : il contient les vues
config : les fichiers de configuration de votre application (base de données, routes, et autres configurations)
db : contient les migrations
doc : vous mettez ici la doc de votre application
lib : pour des nouvelles bibliothèques
log : contient les logs de l'application
public : contient les fichiers clients (image, js, css)
public/images : contient les images de votre application
public/javascripts : contient les fichiers javascripts de votre application
public/stylecheets : contient les fichiers css de votre application
script : contient le script rails
test : contient les fichiers de test (unitaires / fonctionnels / intégrations)
tmp : contient les sessions, et les fichiers temporaires
vendor : contient les plugins rails
vendor/plugins : quand on installe un plugin il se trouve ici
Gemfile : contient la liste des gems dont l'application a besoin pour fonctionner
Rakefile
README


Rails possède 3 environnement :
Production : quand le site est déployé.
Development : quand on développe, plus lent qu'en production mais supporte la modification de code sans redemarrage du serveur.
Test : environnement destiné à être utiliser pour faire les tests.

En console vous pouvez précisé l'environnement de cette manière :
RAILS_ENV=env

Exemple :
RAILS_ENV=production rails console

Env = production ou development ou test

Par défaut l'environnement development est pris en compte.
Des éléments de configuration peuvent changer suivant l'environnement (la base de données à utiliser, la mise en cache des fichiers...)
Vous pouvez tout de suite ouvrir le fichier config/database.yml qui vous permet de définir les bases de données pour chaque environnement, mais ne modifier rien pour le moment !
Garder sqlite3 pour le développement !

Prochainement Partie 1 – MVC, model, view, controller (rails command)