Réaliser un blog avec Ruby On Rails 3 et MongoDB

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.

mercredi 15 décembre 2010