Active Admin !!!

Hello c'est moi...

Aujourd'hui j'aimerais vous parler d'un souci majeur dans un processus de développement : la mise en place d'un module d'administration souple efficace, et intuitif. Sur les différents projets dans lesquels j'ai eu a travailler, c'était souvent la partie la plus laborieuse et bien souvent bâclée. On se comprend....

Mais comme le monde n'est pas toujours si cruel, on a notre petite communauté qui nous a mijoté un petit bijou, une gem, pour la mise en place d'un module d'administration. Hé oui oui...si si je blague pas...en 10 min et encore c'est déjà beaucoup vous aurez une interface d'administration clean et flexible.

Comment fonctionne cette gem ?

Bah très simplement une fois l'installation effectuée, il suffit de spécifier les ressources qui font l'objet de cette administration, par ressource j'entends les modèles. 


En effet Active admin se base sur les modèles pour récupérer les différents champs et construire les différents formulaires, champs de recherche, filtres et autres outils. 
La commande a taper est tres simple :

> rails g active_admin:resource nom_du_model

Prenez le temps de googler tout ça, vous ne le regretterez sûrement pas.

Quelques liens utiles :

http://activeadmin.info/

http://railscasts.com/episodes/284-active-admin

C'était moi...

Dakar Ruby Brigade : Meetup

Reprise des activités ce Samedi 19 novembre 2011 

a l'Ecole Supérieure Polytechnique de Dakar

a partir de 15 h

 Présentation sur REST suvie d'un atelier 

Sinatra 1.3.0 is out ! and it streams

Bonjour tout le monde,

Pour ce mois d'Octobre la communauté Ruby nous fera beaucoup de beaux cadeaux ! Et ça a déjà commencé avec l'équipe Sinatra qui fait une "double" release : en sortant deux versions de sinatra : 1.2.7 et la 1.3.0.

Les nouveautés !

I - Sinatra-contrib

Sinatra a un très grand nombre d'extensions ( plugins ) et certaines ( tels que sinatra-content-for et sinatra-reloader) sont très utilisées. Ce qui a poussé l'équipe Sinatra à décider de les incorporer dans le "core" de sinatra et en faire un "third party component". Et de ce fait nous avons une grande partie des helpers de Rails disponibles et qui fonctionnent de la même maniére. YOUPI !!!

II - "Sinatra recipes"

Zachary Scott a (enfin) lancé son projet "Recipes". C'est en effet un ensemble de techniques, d'astuces et d'applications réalisées par les amoureux de Sinatra.

III - Streaming 

La version "vanilla" ressemble à ça : 

get '/' do
  stream do |out|
    out << "Ce sera vraiment ... -\n"
    sleep 0.5
    out << " (vous attendez toujours ? :)) \n"
    sleep 1
    out << "- SUPER !\n"
  end
end

La chose la plus cool dans cette abstraction est que cette fonctionnalité (streaming) n'est pas spécifique à un serveur Rack particulier ! Et oui ça marche partout ! Que votre serveur soit du type "evented" ( Ebb, Rainbows, thin) ou "sequential" (Unicorn, Mogrel ou passenger).
Pour le moment le seul serveur à ne pas utiliser est WEBrick! Et ne me demandez pas pourquoi :)


Un truc super intéressant : si vous utilisez un serveur "evented" ( thin par exemple ) vous pourrez garder la connexion active et avoir facilement un "messaging service" et de facto votre applicatoin devient plus rapide.

set :server, :thin
connections = []

get '/' do
  # garder la connexion active
  stream(:keep_open) { |out| connections << out }
end

post '/' do
  # Envoyer un message à tous les canaux (connexions) ouverts 
  connections.each { |out| out << params[:message] << "\n" }
  "message envoyé "
end

NB : Tout cela est fait sans l'utilisation des "Fibers". Ce qui permet d'éviter de saturer la stack.


Il est à noter aussi que l'ajout du PATCH HTTP permettra d'accéler certains requêtes ( mise à jour surtout). Merci à l'équipe GitHub.

patch '/' do
  # ... modifier une ressource devient facile, rapide et toujours secure
end

Les tests sont toujours les mêmes :)


Bonne semaine !

Sortie de Rails 3.1

Ruby on Rails 3.1 : Les nouveautés

• Streaming
• Reversible Migrations
• Assets Pipeline
• jQuery as the default JavaScript library

Introduction à Rails 3 :

http://rubyonrails.org/screencasts/rails3

Quelques applications Rails 3.1 : 

    https://github.com/RailsApps

Quelques screencasts pour démarrer comprendre comment ça marche :

   

    http://railscasts.com/?tag_id=31

Tester son code Ruby : Minitest

la programmation est une activité super intéressante. Chacun a sa métaphore préférée qui explique ce que signifie pour lui la programmation. Eh bien, pour moi "la programmation est tout au  sujet d'automatisation". 

Vous êtes devant votre ordinateur pour lui apprendre à faire automatiquement un travail que vous savez faire, mais que vous ne voulez pas faire encore et encore.

Quand on s'en rend compte, on cherche tout de suite des choses qui  peuvent être automatisées. Je n'aime pas me répéter encore et encore et encore. C'est ennuyeux et parfois énervant!

 Eh bien, il y a une tâche particulière qui est liée à la programmation et qui se répète tout le temps : "vérifier que votre logiciel fonctionne!" Donc une tâche à automatiser.

 > MINITEST 

Heureusement pour nous, Ruby a des outils fantastiques qui vous permettent de mettre en place des tests pour votre code que vous pouvez exécuter automatiquement. Vous pouvez vous éviter de perdre du temps et de l'effort en laissant l'ordinateur exécuter des milliers de tests à chaque fois que vous modifiez votre code. Je ne vais pas disserter sur les vertus du«Test Driven Development" dans cet article, mais écrire les premiers tests. Pour commener, nous allons prendre un petit peu de code pour travailler, et je vais vous montrer comment le tester en utilisant minitest.

Pour cet exercice, nous allons faire quelque chose de simple et nous concentrer sur les tests. Nous allons écrire une classe Ruby appelée Membre. Il va falloir un tas de fonctionnalités, mais voici les deux premières méthodes, nous aurons besoin:
-> un membre peut ajouter d'autres membres en tant qu'amis-> un membre peut savoir combien d'amis il a-> quand il est nouveau, le nombre de ses amis est 0-> quand il supprimer sa liste d'amis, il revient à 0 ami.
Très simple non ? Pour écrire ces tests nous allons utiliser une librairie Ruby appelée minitest. Elle est native dans Ruby1.9 mais si vous utiliser 1.8 installez la en faisant :
> gem install minitest
Ecrivons notre premier test !

require 'minitest/autorun'

class TestMembre < MiniTest::Unit::TestCase
  def setup
    @membre = Membre.new
  end
  def test_pas_d_amis
    assert_equal 0, @membre.nombre_amis
  end
end

Ok! Il ya beaucoup de choses ici. Prenons ligne par ligne. Sur la première ligne, nous avons un «require». La partie 'minitest/autorun' comprend tout ce dont vous avez besoin pour exécuter vos tests, automatiquement. 

Tout ce dont nous avons besoin pour faire tourner nos tests est de taper "ruby membre.rb". Mais regardons le reste du fichier avant de faire cela. La prochaine chose que nous faisons est écrire une classe qui hérite de l'une des classes de base de minitest. Voilà comment fonctionne minitest, en exécutant une série de TestCases. Minitest permet également les tests de groupe et en plusieurs fichiers.
Dans notre TestCase nous avons 2 méthodes : setup et test_pas_d_amis. La méthode setup est exécutée automatiquement et avant chaque test. Elle permet de préparer le terrain pour réaliser les tests. La deuxiéme méthode permet de vérifier qu'un nouveau membre n'a pas encore d'amis.
Lançons notre test et voyons ce que ça donne :
> ruby membre.rb

Loaded suite membre
Started
E
Finished in 0.000853 seconds.

1) Error:
test_pas_d_amis(TestMembre):
NameError: uninitialized constant TestMembre::CashRegister
membre.rb:5:in `setup'

1 tests, 0 assertions, 0 failures, 1 errors, 0 skips

Test run options: --seed 36463

Waaaaw cool ! Comme vous pouvez le voir nous avons un test et un échec. Nous savons que les classes Ruby sont des constantes et il en manque une ici. Ecrivons cette classe alors.

class Membre
end

Relançons le test :

1) Error:
test_pas_d_amis(TestMembre):
NoMethodError: undefined method `nombre_amis' for #<Membre:0x00000101032a80>
membre.rb:9:in `test_pas_d_amis'

ça avance ! et cette fois ça nous dit qu'il manque une méthode.

class Membre
  def nombre_amis
  end
end

Relançons le test encore une fois.

1) Failure:
test_pas_d_amis(TestMembre) [membre.rb:9]:
Expected 0, not nil.

Erreur claire : On s'attend à 0 pas à nil

def nombre_amis
  0
end

Ok cool. Le test passe mais notre total est toujours fixe (0). Vérifions que quand on ajoute des amis, le nombre d'amis change.

def test_calculer_nombre_amis
  @membre.ajouter 1
  @membre.ajouter 2
  assert_equal 3, @register.nombre_amis
end

A ce stade, la visoin doit être un peu plus claire pour vous. Lançons nos tests encore une fois

Loaded suite membre
Started
.E
Finished in 0.000921 seconds.

1) Error:
test_calculer_nombre_amis(TestMembre):
NoMethodError: undefined method `ajouter' for #<Membre:0x00000101031838>
membre.rb:13:in `test_calculer_nombre_amis'

2 tests, 1 assertions, 0 failures, 1 errors, 0 skips

Test run options: --seed 54501

Ok! vous voyez le ".E" sur la 3iéme ligne du résultat ? Ben ça veut dire qu'on a eu 2 tests, un réussi '.' et un échoué "E".
Ajouter la méthode qui manque et continuons .

def ajouter(ami)
  @amis << ami
end

Oups ! le @amis n'a pas encore été défini :) Lancez le test et il vous le dira.

def initialize
  @amis = []
end

Avec ce constructeur, nous n'aurons plus ce genre de problèmes.

Relancez le test et vous aurez une erreur : le nombre d'amis est toujours 0 alors qu'il devait passer à 3 .
Corrigeons ce petit souci:

def nombre_amis
  @amis.inject(0, &:+)
end

C'est fait. Alors pour vérifier que vous avez bien compris le truc, écrivez le dernier test : supprimer_liste_amis.


.....


Alors c'est quoi l'intérêt d'écrire les tests en premier ? Ben ça vous permet d'écrire le code qu'il faut pour répondre aux spécifications que contient votre cahier de charges d'une part et de vous assurer que votre logiciel fait exactement ce pour quoi il a été écrit. 


Les mises à jour du code deviennent chose simple. Et quand il a un problème on sait que c'est le nouveau code qui a cassé quelque chose surtout que le "code base" était digne de confiance.


Dans la suite de cette série d'articles sur les tests, nous allons intégrer les tests à des applications Rails et Sinatra.

Rails Admin

Salut !!!!

Pas la peine de chauffer vos méninges en cherchant des tutos pour installer Rails Admin dans vos applications Rails.

je l'ai fait pour vous.

Créons une petite application Rails ,et ajoutons a cette merveille une autre merveille: l'interface d'administration.

Pour ce faire nous utilisons:

• rails 3.0.9
• rails_admin 0.0.1 (version actuellement présente sur github)
• ruby 1.9.2

commençons par créer notre projet

$rails new railsAdminProject
$cd railsAdminProject

éditons le fichier Gemfile de notre application

$vim Gemfile

et ajoutons les gems nécessaires

gem 'devise'
gem 'rails_admin', :git => 'git://github.com/sferik/rails_admin.git'

installons les dépendances / gems de notre application :

$bundle install

Pour avoir le mode d'utilisation du générateur de rails_admin, faire un listing de tous les générateurs intégrés à notre application.

$rails generate

à la fin du listing des générateurs nous retrouvons ceux de rails admin.

RailsAdmin:
rails_admin
rails_admin:install_migrations
rails_admin:uninstall_migrations

exécutons le générateur de rails admin:

$rails generate rails_admin

une suite d'instruction apparaît, spécifiant comment installer rails_admin:

$rake rails_admin:install

créons les tables en base de données, nécessaire a l'application rails_admin.

$rake db:migrate

démarrons le serveur

$rails server

Sur la barre d'adresses sasire l'URL: http://localhost:3000/admin. Vous êtes redirigé vers la page de login.

Jusqu'ici aucun utilisateur n'est enregistré pour l'administration, donc faut s'enregistrer (sign up) en renseignant les informations demandées (email,password, confirmation de password).

BINGOOOO !!!!!. vous y êtes, dans l'interface d'administration Rails_admin de votre application.

Tests du fonctionnement de l'interface d'administration.

En utilisant le générateur scaffold, ajoutons la gestion des produits à notre application rails

$rails generate scaffold Produit nom:string details:string

générons les migrations nécessaires au modèle Produit

$rake db:migrate

Allons sur l'interface d'admninistration(http://localhost:3000/admin) rails_admin, nous avons une onglet pour la gestion des Produits.

BANG !!!! vous pouvez administrer vos produits, et tous les modèles que vous ajoutez a votre application RoR.

Bon heiiinnn !!!!. je vous laisse découvrir les fonctionnalités de Rails_admin. C'est trop cool !!!.

A une prochaine fois. Si je découvre d'autres choses sur Rails Admin je vous ferai signe.

A plus !!!!!.

Ecrire un DSL en Ruby

Bonjour,


Je m'excuse de pas avoir publié cet article hier ( le lundi ) comme le veut la coutume :) J'étais dans l'embarras du choix du sujet à aborder cette semaine. Et vu que je suis en train de développer une API pour un domaine assez "spécifique" qui a son propre jargon j'ai (enfin) eu une idée : comment écrire un jargon en Ruby.
Dans le monde de l'informatique un jargon est dit DSL.
Les DSL et Ruby
Ruby fournit quelques fantastiques fonctionnalités natives pour la création Domain Specific Languages ​​(DSL). Un Domain Specific Language est comme un langage de programmation écrit pour un domaine déterminé. C'est une façon d'exposer les fonctionnalités dans unformat simple et lisible pour les autres programmeurs (ou vous-même). Un des DSL les plus couramment utilisés dans le monde Ruby est Sinatra.

require 'rubygems'
require 'sinatra'

get '/hello' do
  "Hello world."
end

Sinatra est un DSL pour créer des applications web. Sa syntaxe est construite sur la base des verbes HTTP tels que GET, POST, et PUT. En exposant les fonctionnalités de cette manière, le code est beaucoup plus lisible et beaucoup plus parlant surtout quand on sait comment fonctionne le web en général.

un peu de Yield 

yield est un concept très important à comprendre pour réussir à créer un DSL Ruby. La fonctionnalité fournie par yield permet à un développeur de faire passer le contrôle temporairement pour permettre l'éxécution d'un autre bout de code. Si vous avez déjà utilisé le Array#map (ou Array#collect) qui est un exemple intéressant de l'utilisation de yield. 

[1, 2, 3].map{|i| i + 1} # => [2, 3, 4]

Alors comment pourrions-nous ré-implémenter la fonctionnalité carte si ce n'était pas fait pour nous? C'est en fait assez simple en utilisant yield :

class Array
  def my_map
    resultat = []
    self.each do |truc|
      resultat << yield(truc)
    end
    resultat
  end
end

[1, 2, 3].my_map{|i| i + 1} # => [2, 3, 4]

yield arrête essentiellement l'évaluation(éxécution) de la méthode et évalue le bloc passé, l'appelant avec les arguments fournis dans la déclaration de yield lui-même. Donc, si j'avais une méthode qui simplement retournait  ce qu'on lui passe en arguments, ça ressemblerait à ça :

def confesser( argument )
  yield argument
end

confesser(" Ruby c'est magnifique !") do |arg|
  puts arg
end

# Sortie : "Ruby c'es magnifique !"

Yield et les DSLs


Maintenant, en utilisant yield, nous avons les bases pour créer un DSL simple. Je sais pas pour vous mais moi j'ai faim ! Donc nous allons créer un DSL pour décrire les recettes de cuisine. Nous voulons être en mesure de créer des recettes, d'ajouter des ingrédients ainsi que les étapes, et avoir un joli affichage de tout ça.  Au boulot now :

class Recette
  attr_accessor :nom, :ingredients, :instructions

  def initialize(nom)
    self.nom = nom
    self.ingredients = []
    self.instructions = []
  end

  def to_s
    affichage = nom
    affichage << "\n#{'=' * nom.size}\n\n"
    affichage << "Ingredients: #{ingredients.join(', ')}\n\n"

    instructions.each_with_index do |instruction, index|
      affichage << "#{index + 1}) #{instruction}\n"
    end

    affichage
  end
end

Now ajoutons une recette :

plat = Recette.new("Omelette")

plat.ingredients << "Oeufs"
plat.ingredients << "beurre"
plat.ingredients << "fromage"
plat.ingredients << "autres trucs "

plat.instructions << "Beurre dans poêle"
plat.instructions << "ouefs ..."
plat.instructions << "fromage ..."
plat.instructions << "la suite certainement ..."

Now faisons un "puts plat"! ça doit donner :

Plat
====

Ingredients: Oeufs, beurre, fromage, autres trucs

1) Beurre dans poêle
2) ouefs ...
3) fromage ...
4) la suite certainement ...

Bien que cela fonctionne, le code ne semble pas être élégant! Nous avons besoin d'un moyen de faire ressembler à ce qu'on peut voir sur une carte de recette. Rendons le code un peu plus beau. Pour commencer, nous allons réécrire le constructeur et yield :

def initialize(nom)
  self.nom = nom
  self.ingredients = []
  self.instructions = []

  yield self
end

Next, nous devons ajouter quelques méthodes pour ajouter des ingrédients et des instructions à la recette :

def ingredient(nom, options = {})
  ingredient = nom
  ingredient << " (#{options[:quantite]})" if options[:quantite]

  ingredients << ingredient
end

def instruction(texte, options = {})
  etape = texte
  etape << " (#{options[:pendant]})" if options[:pendant]

  instructions << etape
end

Cela nous permet de créer une recette d'une manière beaucoup plus naturelle :

nouilles_au_fromage = Recette.new("Nouilles au fromage") do |r|
  r.ingredient "Eau",      :quantite => "2 verres"
  r.ingredient "Nouilles", :quantite => "1 verre"
  r.ingredient "Fromage",  :quantite => "3 cuillères"

  r.step "L'eau sur le feu",      :pendant => "5 minutes"
  r.step "Ajouter les nouilles.", :pendant => "6 minutes"
  r.step "Enlever l'eau."
  r.step "Mélanger le fromage aux nouilles."
end

"puts nouilles_au_fromage" donnera :

Nouilles au fromage
===================

Ingredients: au (2 verres), Nouilles (1 verre), Fromage (3 cuillères)

1) L'eau sur le feu. (5 minutes)
2) Ajouter les nouilles. (6 minutes)
3) Enlever l'eau.
4) Mélanger le fromage aux nouilles.

Et voilà ! le petit déjeuner est servi. 
Nous verrons dans la suite comment rendre ce DSL plus joli et plus proche du langages des chefs cuisiniers.


Conclusion :
Nous avons appris à écrire un DSL en Ruby et nous n'avons utilisé qu'une seule méthode ( Yield ). Dans la suite de cet article nous utiliserons d'autres merveilles de Ruby.


Bonne journée