Objectifs
Le but de cet article est assez simple : réaliser un
moteur de blog (minimaliste) en utilisant
Ruby on Rails 3 et
MongoDB.
Installation
Parce qu'il faut bien commencer quelque part, on va installer notre environnement. L'installation détaillée ici est pour ubuntu 10.10.
On va utiliser rvm (Ruby Version Manager), qui permet de gérer facilement plusieurs version de Ruby simultanément.
On commence par installer git, qui nous sera utile tout au long du projet, notamment pour l'installation de certaines gems, ou encore pour le déploiement.
sudo apt-get install git-core
Puis les dépendance nécessaires pour compiler ruby.
sudo apt-get install build-essential bison openssl libreadline5 libreadline5-dev curl git-core zlib1g zlib1g-dev libssl-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libmysqlclient-dev libreadline-dev
Ensuite on installe la dernière version de rvm en suivant la doc officielle :
# RVM install
bash < <( curl http://rvm.beginrescueend.com/releases/rvm-install-head )
# Load RVM into shell
echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"' >> ~/.bashrc
# RVM bash completion complete
echo '[[ -r $rvm_path/scripts/completion ]] && . $rvm_path/scripts/completion' >> ~/.bashrc
# One-time source of RVM
source ~/.rvm/scripts/rvm
rvm est installé, on peut maintenant compiler et installer ruby :
rvm install 1.9.2
rvm use 1.9.2 --default
On a maintenant un environnement ruby à jour est prêt à être utilisé.
Initialisation du projet
On va tout d'abord créer le squelette de l'application grace à rails (avec les flags qui vont bien -O pour desactver ActiveRecord, -J pour utilier jquery, -T pour ne pas générer les Tests/
rails new MongoOnRailsBlog -O -J -T
Notre application rails est en place, on peut déjà voir le résultat en lancant
rails server
Et en visitant l'adresse http://localhost:3000.
Par défaut, rails va utiliser sqlite comme backend, et nous voulons utiliser mongodb. Pour cela, on va utiliser
MongoID, un ORM pour MongoDB.
On va l'installer via bundle, en modifiant le fichier GemFile
source 'http://rubygems.org'
gem 'rails', '3.0.3'
gem "mongoid", ">= 2.0.0.beta.20"
gem "bson_ext"
gem "will_paginate"
gem "devise"
gem "haml", ">= 3.0.0"
gem "haml-rails", :group => :development
gem "ruby_parser", :group => :development
gem "hpricot", :group => :development
gem "formtastic"
gem "jquery-rails"
gem "heroku"
Et en lancant un
bundle install
On commence par un peu de configuration, pour que les générateurs nous machent le travail pour MongoId et pour haml.
application.rb
# Configure generators
config.generators do |g|
g.orm :mongoid
g.template_engine :haml
end
rails generate mongoid:config
rails devise:install
rails generate jquery:install
rails generate formtastic:install
Code
Les articles
Les articles sont bien entendu au centre de notre moteur de blog, ils correspondront à une collection MongoDB à part entière.
Un article possède donc :
- Un slug (l'url SEO Friendly), qui nous servira d'identifiant
- Un titre
- Un contenu
- Une date de publication et d'édition
- Un auteur (facultatif)
- Des tags
- Des commentaires
Pour les champs "complexes" (auteur, tags, commentaires), plusieurs solutions s'offrent à nous.
- Pour les tags, la solution la plus simple est un tableau, largement suffisant dans la mesure où le tag est une simple chaîne de caractères
- Les commentaires sont fortement liés à un document, et n'ont aucun sens sans eux, la meilleure solution est donc de les embarquer dans l'article : voir la doc de MongoId sur les associations.
- Pour les auteurs, le choix est plus compliqué. On peut aussi embarquer l'auteur dans l'article, ce qui sera plus performant, mais nécessitera de mettre à jour tous les articles d'une personne si par exemple elle change son nom. On va ici ne stocker qu'une référence à l'auteur dans l'article, ce qui est moins performant, mais sera plus rapide à implémenter : voir la doc de MongoId sur les associations.
On va commence par générer le squelette pour la gestion des articles grace au scaffold, ce qui à le grand avantage de faire gagner du temps sur l'écriture des controlleurs, vues, ... :
rails g scaffold article slug:string title:string body:text published_date:date
On complète bien sur notre modèle :
class Article
include Mongoid::Document
include Mongoid::Timestamps
field :slug, :type => String
field :title, :type => String
field :body, :type => String
field :published_at, :type => DateTime
field :edited_at, :type => DateTime
field :tags, :type => Array
referenced_in :user, :stored_as => :array, :inverse_of => :articles
embeds_many :comments
key :slug
before_save :set_edited_date
before_create :set_slug,:set_published_date
def set_published_date
self.published_at = DateTime.now
end
def set_edited_date
self.edited_at = DateTime.now
end
def set_slug
self.slug = "#{title.parameterize}"
end
validates_presence_of :title, :body
validates_uniqueness_of :slug
index [[:published_date, Mongo::DESCENDING]]
index :tags
index :user
end
Comme on peut le voir, on complexifie un peu notre modèle pour mettre automatiquement les dates de publication et d'édition (notez que ces dates font doublons avec les Mongoid::Timestamps), et générer automatiquement le slug.
On peut donc déjà s'amuser à créer un article via la console rails :
ruby-1.9.2-p0 > Article.create(:title => "My First Post", :body => "blablabla", :tags => ["misc"])
=> #
Les commentaires étant imbriqués dans les articles, le formulaire de saisie de commentaire sera affiché sur la page de vue d'un article :
resources :articles do
resources :comments
end
class ArticlesController < ApplicationController
def show
@article = Article.find(params[:id])
respond_to do |format|
format.html
format.xml { render :xml => @article }
end
end
end
class CommentsController < ApplicationController
def create
@article = Article.find(params[:article_id])
@comment = @article.comments.create!(params[:comment])
redirect_to @article, :notice => "Commented!"
end
end
%h1 New Comment
= semantic_form_for [@article, Comment.new] do |f|
= f.inputs do
= f.input :title
= f.input :body, :as => :text
= f.buttons do
= f.commit_button
On va maintenant ajouter à notre blog un nuage de tag, et on va pour cela utiliser le
map-reduce intégrer à MongoDB :
class Article
def self.tag_cloud
map = <<EOF
function() {
for (index in this.tags) {
emit(this.tags[index],1);
}
}
EOF
reduce = <<EOF
function(previous, current) {
var count = 0;
for (index in current) {
count += current[index]
}
return count;
}
EOF
if Mongoid.master.collection(collection.name).count != 0
collection.map_reduce(map,reduce).find()
else
[]
end
end
end
Et pour l'afficher :
%ul.tagcloud
- Article.tag_cloud.each do |tag|
%li{:style => "font-size: #{tag['value']}em"}
%a{:href => "#"}
= link_to tag["_id"], articles_by_tag_path(tag["_id"])
On a donc déjç, en seulement 1h de développement, un blog où l'on peut poster, mettre des commentaires, et naviguer par tag.
On va maintenant ajouter la notion d'auteur sur les articles et les commentaires, et on va pour cela utiliser
Devise
rails generate devise User
rails generate devise:views users
Devise a le grand avantage de s'occuper de tout le côté inscription, authentification récupération de mot de passe, ... pour nous.
Il suffit pour cela d'ajouter dans le routes.rb :
devise_for :users
Et les URLs /users/sign_up, /users/sign_in, /users/sign_out sont disponibles.
On peut donc mantenant lié un article et un commentaire à un utilisateur, en modifiant le controller de création.
class ArticlesController < ApplicationController
def create
params[:article][:tags] = params[:article][:tags].split(',')
@article = Article.new(params[:article])
if user_signed_in?
@article.user = current_user
end
respond_to do |format|
if @article.save
format.html { redirect_to(@article, :notice => 'Article was successfully created.') }
format.xml { render :xml => @article, :status => :created, :location => @article }
else
format.html { render :action => "new" }
format.xml { render :xml => @article.errors, :status => :unprocessable_entity }
end
end
end
end
class CommentsController < ApplicationController
def create
@article = Article.find(params[:article_id])
if user_signed_in?
params[:comment][:user] = current_user
end
@comment = @article.comments.create!(params[:comment])
redirect_to @article, :notice => "Commented!"
end
end
Grace à un simple plugin, et à la puissance de rails, il nous a fallu moins d'une heure pour mettre en place un système d'authentification complet sur notre application. On peut même ajouter les fonctionnalité d'affichage de l'auteur d'un article, ou la liste des articles d'un auteur :
class ArticlesController < ApplicationController
def author
@author = User.find(params[:author])
@articles = @author.articles.desc(:published_at)
respond_to do |format|
format.html
format.xml { render :xml => @articles }
end
end
end
Mise en ligne
Pour déployer notre blog, nous allons utiliser la plateforme d'hébergement cloud pour Ruby on Rails
Heroku, qui permet de déployer très facilement et gratuitement une application rails, avec à disposition un grand nombre d'addon, dont MongoDB.
Il suffit de s'inscrire sur le site, et ensuite d'installer la gem heroku via bundler.
Je vous invite à lire la
documentation d'heroku.
Une fois le déploiement fait via git, l'application est tout de suite visible en ligne via
http://mongoonrailsblog.heroku.com/.
Le code source est disponible sur
github.
Voila, c'est la fin de mon premier essai en
Ruby on Rails, qui m'a permis de construire un moteur de blog très minimaliste en quelques heures seulement, et de le mettre en ligne.