Dakar Ruby User Group

Active Admin !!!

2011-11-15T23:37:00.005Z

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

2011-11-15T09:46:00.001Z

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

2011-10-03T10:50:00.000Z

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

2011-09-01T09:19:00.000Z

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

2011-07-28T12:08:00.000Z

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

2011-07-19T21:26:00.011Z

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

2011-07-19T09:44:00.001Z

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

Unitialized constant Rake....

2011-07-11T23:02:00.002Z

Salut tout le monde euh c'est moi....

Bon si suis la c'est juste pour donner une astuce relative à cette erreur lorsque vous essayez de faire un rake db:migrate ou un rake db:create, Bah il semblerait que le fait de mettre à jour rake à la version 0.9.2 pose un certain nombre de soucis....

Bon bon voici la solution si vous utilisez rake 0.8.7 faites un bundle rake update et passer à la version 0.9.2, ensuite allez éditer votre rakefile et ajouter ceci :

require 'rake'

require 'rake/dsl_definition'

module ::Nom_de_votre_application

class Application

include Rake::DSL

end

Nom_de _votre_application::Application.load_tasks

et voila le tour est joué

bon ben c'etait moi....:-)

Sinatra au meetup DakarLUG ce samedi 09 juillet

2011-07-05T12:42:00.000Z

Introduction à Sinatra au meetup DakarLUG ce samedi 09 juillet suivie d'un atelier pour écrire une première vraie application web avec Sinatra munie d'une API REST.

Authentication System : part 2

2011-06-27T10:24:00.000Z

Bonjour,

Dans la première partie de cet article, nous avons vu comment chiffrer les informations de connexion d'un utilisateur avant de les stocker dans la base de données; et nous avions une méthode login qui nous permet de comparer des signatures de mots de passe. Donc nous avions un systéme de SignUp/SignIn assez utilisable mais qui reste indépendant de notre application. C'était le but c'est vrai.
Aujourd'hui nous allons utiliser ce système pour sécuriser notre application.

On veut que seules les pages d'accueil et de connexion soient accéssibles aux gens pas encore connectés. Et pour celà nous allons utiliser ce qu'on appelle des filtres.
Les filtres sont des .......... voir wikipedia :)

class AppController < ApplicationController

before_filter :logged_in, :except => [:index, :login]

def index

# ....

end

# ... la suite du contrôleur

end

Une fois que Rails voit le before_filter dans notre contrôleur, il effectue plusieurs choses : passer la main à la méthode appelée ( logged_in dans notre cas ) et attend que cette méthode lui donne une réponse claire : True ou False.

Une fois que la réponse est là, il lit le reste du bloc de code et l'exécute.

Nous remarquerons certainement que la méthode logged_in n'a pas encore été définie. Alors où est ce qu'on doit la définir ? dans un endroit où elle sera accessible par toutes les entités de notre application : contrôleurs et vues. Nous verons pourquoi plus tard inchaallah.

class ApplicationController < ActionController::Base

helper_method :connected?, :logged_in

protected

def connected?
return true if session[:utilisateur]
false
end

def logged_in
if !connected?
redirect_to login_path
flash[:message]= " Désolé ! Accés refusé"
end

end
end

Du nouveau ! En plus de l'utilisation de méthodes privées nous avons utilisé une nouvelle méthode : helper_method !

Alors que fait cette méthode ?

Elle permet de rendre disponible une méthode dans le scope de vues ! C'est tout ce que nous avons besoin de dire et de savoir à ce stade.

Et maintenant dans nos vues on peut s'amuser à faire :

<% if logged_in %>
Bonjour
<% else %>
<%= link_to " connexion ", login_path %>
<% end %>

Merci et bonne semaine.

Le rendez-vous des experts: Ruby On Rails

2011-06-24T12:36:00.000Z

Une introduction à Ruby On Rails !

Le framework qui continue de révolutionner le monde du web présenté par un étudiant de SUPINFO France. Il essaie de couvrir tout ce qu'il faut savoir pour démarrer .

Authentication system for Rails applications

2011-06-24T11:57:00.000Z

Bonjour,

Aujourd'hui on va parler d'un problème que nous rencontrons à chaque fois que nous devons développer une application web avec un accès contrôlé.
Je veux dire par "accès contrôlé" que nous avons besoin d'être authentifié pour pouvoir effectuer certaines opérations.

Nous avons besoin de savoir qui fait quoi ! Ce qui nous pousse à protéger certaines sections de notre application supposées être réservées aux membres.

Pour réaliser une telle tâche on a souvent recours aux "solutions" prêtes. Ces solutions sont souvent des gems/plugins.
L'avantage de ces solutions c'est qu'elles ont été testées et améliorées par des milliers de programmeurs.

Leur plus grande faiblesse est que souvent elles ne sont pas faites pour vous spécialement. Ce qui rend la personnalisation de ces solutions un peu difficile. Car pour modifier le workflow défini par défaut il faut avoir une très bonne connaissance du langage Ruby pour éviter de faire du n'importe quoi et aussi savoir comment les plugins Rails sont conçus.
Nous n'allons pas entrer dans ce sujet car trop vaste et c'est un peu tôt pour nous de l'aborder.

Alors ! Et si on veut développer notre propre solution, comment faire ?

Une solution d'authentification doit être sûre, évolutive et facile à modeler. Et pour ce faire elle doit être totalement indépendante du reste de l'application.

Je vais partager avec vous ma façon de faire. Elle est très simple. Elle consiste en l'enregistrement de la signature du mot de passe et de la clé utilisée pour chiffrer. Donc les mots de passes enregistrés dans la base de données sont indéchiffrables en cas d'attaque sur votre serveur de bases de données.

The Model

Pour utiliser ce modéle dans vos applications, vous aurez juste besoin d'avoir les attributs suivants : login, hashed_password et salt qui représentent l'identifiant de l'utilisateur, le mot de passe crypté et la clé de cryptage.

Et le processus de création d'un nouveau compte reste le même !
Utisateur.create(:attributs)

The controller

Et dans mon contrôleur j'ai mes méthodes de login et de logout.

The view

A ce stade nous avons un systéme de login/logout et création d'un nouveau compte utilisateur avec cryptage de mots de passe. Cette solution est très simple facile à embarquer dans toutes vos applications Rails.

Understanding Rack 2 : les middlewares

2011-06-08T14:26:00.000Z

Bonjour,

Aujourd'hui, à mon réveil, j'ai senti une envie folle de coder. Donc après avoir pris ma douche, prié et pris mon petit déjeuner ( j'aurais pu vous inviter ! je sais ), je suis entré dans mon repertoire "Projets" et je suis tombé sur "Rack applications" et là je me suis rappelé que je vous dois la suite de la série "Understanding Rack" que j'ai commencée il y a quelques semaines déjà.

L'épisode 1 de cette série introduit Rack, son utilité et ses bases. Je vous conseiller de le lire avant de continuer avec cet article.

Dans cet épisode nous allons savoir ce qu'est un middleware Rack, à quoi il sert, comment en créer et surtout comment l'utiliser dans une application en production (ou en dév).

Rack middleware ?

un middleware rack est "juste" une application Rack qui a connaissance de l'existence d'autres applications Rack. J'explique ! Quand un middleware rack est invoqué, il peut passer la main à d'autres middlewares/applications pour des traitements spécifiques.

Exemple par le code :

module Rack
class MonMiddleware
def initialize(app)
@app = app
end
def call(env)
if @app
status, headers, body = @app.call(env)
else
[ status, header, body ]
end
end
end
end

Le code est assez simple et clair. Nous avons une application Rack qui "peut" passer la main à une autre application si cette dernière utilise ce middleware.

Donc, en résumé, un middleware Rack est une application utilisable par les applications Rack. Oui ! c'est tout ! ( pour le moment ).

Et pour donner un peu plus de "valeur" ou d'importance aux middlewares, nous allons parler de Rack::Restrictor.

un peu d'histoire !

Il y a quelques mois, pour le compte du SUP'Management Mauritanie, j'ai dû écrire un petit middleware pour protéger certaines sections de leur SI.
Ils ont en place une application ( Rails ) appelée RubyCampus qui leur permet de gérer leurs étudiants, les enseignants, la paie, la gestion des examens et tout le tralala. Evidement ces modules ne sont pas tous développés par la communauté RubyCampus.

Le problème !

Après quelques mois d'utilisation ils se rendent compte qu'ils doivent restreindre l'accès à certaines parties de l'application à "leur équipe" d'informaticiens. Mais comment le faire ? Avoir deux sous-applications : une pour les étudiants et une pour l'administration ? comment s'assurer que les étudiants ne pourront accéder qu'à "leur" application ?

la solution adoptée !

Pour régler ce problème, on a proposé que le staff devant accéder à la partie Admin soit dans un réseau et que seules les machines dans ce réseau pouvaient avoir accès à la section en question.

Mettre en place un tel réseau est chose aisée certainement ! Now la partie logicielle!
La solution a été un middleware appelé Rack::Restrictor que vous pouvez télécharger ici. Il permet de spécifier la plage d'adresses ip acceptées et il se charge du reste.

Très simple comme solution mais ça marche.

voici le code :

Ok cool ! mais comment utilise-t-on un middleware Rack ?

Simple ! On va utiliser les fonctions du Rack::Builder !
( VOUS( certainement ) :hé ho c'est quoi Rack::Builder ? ...
Moi : on en reparlera plus tard )

Rack::Builder n'a que trois (3) méthodes : map, use et run.

Revenons à notre sujet. Créons une petite applicaton Rack et appelons notre middleware.

class MonApp

def call(env)

status = 200

headers= { "Content-Type" => "text/plain" }

body = "Bonjour tout le monde"

return [ status, headers, body ]

end

Là nous avons une application très simple qui renvoie tout simplement une chaîne de caractéres. Mais notre application a besoin d'être sécurisée et réservée à très peu de personnes :)

pour ce faire nous allons utiliser Rack::Restrictor qui installable par " > gem install rack_restrictor ".

require 'rack_restrictor'

use Rack::Restrictor, "192.168.0.1/24"
run MonApp.new

Ce que ça fait ! On require la gem, on appelle le middleware, on lui passe la plage que nous voulons autoriser et à la fin on lance notre application.

PS : il faut toujours appeler votre application en dernier et prétez attention à l'ordre dans lequel vous appelez vos middlewares.

Lancer votre code et testez !

Je vais parler de Rack::Builder et comment embarquer des middlewares/applications Rack dans des applications web plus sérieuses écrites en utilisant Rails, Sinatra ou autre.

à plus

Rhodes ...

2011-06-06T11:17:00.008Z

Coucou ça faisait un moment pour ne pas dire une éternité...

Entre plein de trucs à faire et pas de journées de 48h comprenez mon absence...

Aujourd'hui je vais vous parler aussi de mobile, pas de Haml, Hassane m'a précédé mais plutôt d'une solution à une problématique majeure.

Vous travaillez dans une entreprise ( ou pas :) ) et on vous demande de développer une application pour smartphone tournant sous IOS, Androïd, et pire on peut même vous obliger à le faire sous Windows Mobile ( sans rancune... ). Que faire ? Développer la même application sur toutes ces plateformes, c'est à dire effectuer le même travail sur autant de plateformes ? se suicider ? ( c'est une option oui ) ou encore faire du web mobile ?

Bah rassurez vous il y a une autre solution et c'est un framework basé sur ruby qui respecte de façon séduisante le principe du DRY ( Don't Repeat Yourself ), ce framework c'est Rhodes, et il permet de developper une fois son application et de Run Everywhere, il suffit juste de specifier la plateforme cible. Si si c'est bien possible!

Rhodes est un framework opensource basé sur le langage ruby qui permet de construire rapidement des applications natives en html et ruby pour la majeure partie des systémes d'exploitation des smartphones.

Rhodes integre par défaut les layout des différentes vues des smartphones et se charge d'adapter le layout au smartphone cible, la logique de rhodes est basée sur une architecture MVC tres proche de rails.

Rhodes intégre un web server, et utilise le browser control des systemes d'exploitation des smartphones afin de permettre au développeur d'ecrire du html et d'editer ses templates, toutefois l'utilisateur final n'a pas connaissance que c'est son browser qui est derriére le rendu de l'application qu'il utilise.

Aussi Rhodes n'est pas venu tout seul, il est accompagné de RhoSync qui est un sync server, un serveur séparé qui se concentre sur les web services, et permet de syncrhoniser les données avec votre application. Si vous êtes dans ce type de problématique RhoSync peut être votre solution.

Toutefois cela ne signifie pas que vous êtes dans l'obligation d'utiliser RhoSync pour synchroniser vos web services avec les données de votre application....vous pouvez en effet développer votre propre serveur et votre propre client pour la synchronisation de vos web services

Et voila comment éviter un suicide collectif .... :)

Pour en savoir plus => http://rhomobile.com

ou encore

http://confreaks.net/videos/68-mwrc2009-rhodes-the-open-source-ruby-framework-for-building-mobile-applications

Introduction à Haml

2011-06-06T10:14:00.001Z

Introduction à Haml

Bonjour Rubyistes,

ça faisait un moment que je vous ai pas écrit et je vous demande pardon. Ce n'est pas évident de travailler toute la semaine, organiser des événements les weekend, préparer des talks et pouvoir se mettre devant mon clavier et partager avec vous :)

Et pour la reprise, nous allons faire de belles choses. Nous allons voir ensemble comment écrire des applications WEB Mobiles en utilisant Haml, jQTouch et Sinatra.

Le but de cette série d'articles est de nous permettre d'écrire des applications WEB Mobiles pour rendre "nos" applications WEB plus à la portée de nos visiteurs, clients et collaborateurs.

L'avantage des applications WEB mobiles par rapport aux applications WEB "simples" est qu'elles ont un look d'applications natives. De ce fait, le visiteur se sent déjà "chez lui".

D'où me vient l'idée de cet article ?

Je travaille pour une entreprise en tant que développeur d'applications WEB (mobile et standard). Et sur la demande de nos collaborateurs, nous devrions avoir une application mobile pour chaque plateforme ( Android, Iphone, BlackBerry, Windows Mobile, Symbian et Palm Os ). Oui c'est beaucoup d'applications qui sont toutes identiques ! La solution que nous avons finalement adoptée c'est avoir une seule et unique application utilisable sur toutes ces plateformes : une application WEB mobile.

Et après une comparaison des différents outils permettant le développement d'applications WEB mobiles, mon choix ( justifié ) s'est porté sur jQTouch (jQuery mobile ). L'application a été développée en Python ( Django ).

Après avoir découvert certaines belles choses, j'ai pensé à vous :)

Now vous savez pourquoi j'ai écrit cet article. Mais vous savez toujours pas pourquoi j'ai choisi HAML ???

HAML est un langage de templating ( pour créer ou générer des pages HTML ) tout comme le ERB, Slim et autres langages de templating. Son avantage par rapport aux autres c'est le DRY ! ( Don't Repeat Yourself ), la structation qu'il vous impose et sa Rubyesque syntaxe.

Installation de HAML

Haml est une GEM qui s'installe comme toutes les autres !

> gem install haml

haml : Basics

Haml vous permet de gérer les contenus statique et dynamique de vos pages HTML en mettant à votre disposition des "méthodes" d'accès aux éléments du document HTML.

Sur cette image on a les différentes "méthodes" d'accès et d'utilisation des tag et blocks du document HTML.

Toutes les balises HTML sont précédées d'un %, les class CSS par un "." et les ID par un "#". C'est toutce qu'il faut savoir sur les parties statiques de votre HTML.

haml : Syntaxe

Exemple : index.haml

!!! Strict

%html

%head

%body

%h1

Bonjour tout le monde

On "compile" tout ça :

> haml index.haml

Et le résultat est :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html>

  <head></head>

  <body>

    <h1>

      Bonjour tout le monde

    </h1>

  </body>

</html>

très simple et super cool ! Pour ceux qui aiment avoir des widgets sur leurs pages web, Haml est vraiment le truc qu'il faut.

Et maintenant ajoutons un peu de contenu dynamique !

- @text = "Ruby is awesome"

!!! Strict

%html

%head

%body

%h1

Bonjour tout le monde !

- if 1 < 2

=@text

Et le résultat est :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html>

  <head></head>

  <body>

    <h1>

      Bonjour tout le monde !

      Ruby is awesome

    </h1>

  </body>

</html>

Un essai avec les div !

- @maclasse = "rouge rounded"

- @text = "c'est super ça "

!!! Strict

%html

%head

%body

%h1

Bonjour tout le monde !

%div{ :class => @maclasse }

=@text

à vous de me dire à quoi ressemblera le résultat HTML.

Haml est très simple, intuitif et amusant. Dans le prochain article, nous allons utiliser Haml dans une application Sinatra. D'ici là amusez vous bien avec Haml et n'hésitez pas à poser vos questions et/ou faire part de vos critiques/suggestions.

PS : Haml vient avec son propre moteur de CSS appelé SASS ! Mais vous pouvez l'utiliser avec le CSS standard. On fera un tour sur le SASS. Promis :)

à Lundi prochain inchaallah.

Présentation du langage Ruby à la FST !

2011-06-03T10:26:00.000Z

View more presentations from hkairi.

Connascence Of X

2011-05-18T12:48:00.000Z

PS : si certains termes (ou expréssions) vous parraient "etranges", wikipedia vous aidera !

Coupling

Coupling or dependency is the degree to which each program module relies on each one of the other modules

Types
No
Modules do not communicate with each other
Message
Modules are not dependent instead they use a public interface to exchange parameter-less messages or events
Data
TODO: simple data/internal
Stamp
a modules share composite data structure but requires only part of it(through say field name structured data/internal
Control
a module controls logic of antother by passing it information on what to do(what-to-do flag)
External
modules share externally imposed data format( ie using mysql api instead wrapping it in db api) simple data/external
Common
modules share common data(ie global variable) structured data/external
Content
module relies/depends on implementation details of another module

Cohesion

Cohesion is a measure of how strongly-related or focused the responsibilities of a single module are

Types

Coincidental cohesion (worst): grouped arbitrarily.. (e.g. a module of frequently used functions).
Logical cohesion: logically categorised to do the same thing, even if they are different by nature (e.g. grouping all I/O handling routines).
Temporal cohesion: during run-time (e.g. a function which is called after catching an exception which closes open files, creates an error log, and notifies the user).
Procedural cohesion: always follow a certain sequence of execution
Communicational cohesion: operate on the same data
Sequential cohesion: output from one part is the input to another part
Functional cohesion (best): contribute to a single well-defined task of the module

Connascence

Two pieces of software share connascence (or relation) when a change in one requires a correspoiding change in the other Like coupling but in operational way instead just levels

Types

Static
- Of Name
- Of Type
- Of Meaning
- Of Algorithm
- Of Position
Dynamic
- Of Execution
- Of Timing
- Of Value
- Of Identity
Contranascence

Rules

Locality: higher connascence for smaller scope
Degree: convert high degrees of connascence into weaker forms of connascence

Corelation To Other Principles

TODO:

Like:

DRY: CoA
Law of demeter: CoT
KISS:
Single responsibility

Modularity Ry Jim Weirich

Quelques pistes pour commencer

2011-05-18T12:07:00.000Z

Hi,

Pendant le meetup que nous avons organisé à l'Ecole Supérieure Polytechnique ce samedi 14 mai 2011,
nous avons promis de partager avec vous certaines ressources :)

Alors voici quelques pistes pour commencer votre belle aventure avec Ruby :

un livre très intéressant pour démarrer : Apprendre à programmer en Ruby
un interpréteur Ruby en ligne http://tryruby.org
*
http://rubyinside.com
http://ruby-toolbox.com
http://rubygems.org

les websockets ? solutions aux limites du protocole HTTP ?

2011-04-07T15:56:00.005Z

Hi mon premier post sur ce blog....

Découvrons le ensemble

Quelques mois auparavant Hassane Moustapha vous a parlé de REST et notamment du protocole HTTP . Je ne reviendrais donc pas dessus, je m'en vais juste soulever une limite majeure du protocole HTTP , limite qui a en partie vu le jour avec l'évolution du Web ( notamment le Web .2.0 ).

Je m'explique, l'utilisation du protocole HTTP implique que le client ( disons notre navigateur web ) doit ouvrir une connexion avec le serveur, effectuer sa requête, attendre la réponse du serveur, avant de la fermer. Aussi à chaque nouvelle connexion c'est ce même processus qui se répéte. Nous notons deux points essentiels

le serveur doit attendre une requête du client pour pouvoir lui envoyer les données qui lui sont destinées
la bande passante en souffre :)
Ce temps de latence implique dans le cas de systèmes à temps réel ( prenons le cas des bourses ) des pertes possibles d'argent

J'espere que vous me suivez toujours car on va bientôt entrer dans le vif du sujet. En effet le souci principal pour nous développeurs avec ce protocole c'est le besoin d'avoir une connexion constamment ouverte entre le client et le serveur permettant un échange de données en full duplex.Certains me diront qu'il existe des alternatives telles que Comet ( Hassane nous fera surement la grâce d'un article dessus).

Nous parlerons donc des Websockets qui via le HTML 5 est supporté par les applications web actuelles.

Le Protocole WebSocket

Ce protocole permet d'ouvrir une connexion permanente directionnelle entre le client et le serveur.

Comment ça se passe ?

Bah tres simplement, considérons que votre application charge un script javascript qui nécessite une connexion permanente avec le serveur. Une requête de type "upgrade" est faite afin de proceder à une mise à jour de la connexion de type TCP/HTTP vers le mode webSocket. Ca ressemble à peu prés à ça :

GET /text HTTP/1.1

Upgrade: WebSocket

Connection: Upgrade

Host: www.example.com

Origin: http://example.com

WebSocket-Protocol: sample

Sec-WebSocket-Version: 6

qui donne

HTTP/1.1 101 Websocket Protocol Handshake

Upgrade: WebSocket

Connection: Upgrade

WebSocket-Origin: http://example.com

WebSocket-Location: ws://example.com/demo

WebSocket-Protocol: sample

Et voila cet échange initial est appelé "handshake" ( poignée de mains pour les francophones :) ) et devinez quoi ? la connexion entre le serveur et le client est établie.

Le client et le serveur peuvent alors échanger librement des informations l'un l'autre via

ce protocole. Le serveur vient push (pousser ) des données vers le client et n'est plus obligé d'attendre qu'il en fasse la demande d'abord.

L'API WEBSOCKET

Elle se veut tres simple. Aussi pour créer une instance de web socket il suffit de fournir l'url du serveur . Elle commence par ws:// ou wss:// ( pour une connexion sécurisée ). Ensuite l'interface fournit un certain nombre d'attributs permettant de gérer les évenements associés :

onopen : ouverture d'un websocket

onmessage : reception d'un message

onerror : en cas d'erreurs

onclose : fermeture de websocket

Les données envoyés par le serveur sont notifiés par l'événement onmessage. Aussi les webSocket fournissent deux méthodes :

send(data_string) pour envoyer un message au serveur
close() pour fermer la webSocket

Hummm je commence à être long la. Aussi je vais terminer par son implementation côté

serveur.

Je ne vais pas finir sans préciser ceci, les websocket representent une évolution importante

dans la communication client-serveur, toutefois d'importantes failles de sécurité ont été notées dont le cache poisonning. Ce qui fait que les websocket restent encore à l'état de brouillon, mais son évolution est ineluctable so

Wait and see...

quelques liens

http://www.blog-nouvelles-technologies.fr/archives/3237/html5-websockets-le-successeur-du-protocole-http/

Ruby : quelques ressources !

2011-04-04T13:58:00.000Z

Bonjour,

Pendant ma présentation du langage Ruby (lien) au CodeCamp le samedi 02 Avril 2011, j'avais promis de partager avec vous mes sources! Voici quelques liens qui vous seront très utiles :

- http://www.ruby-lang.org/fr
- http://rubyflow.com
- http://rubyinside.com
- http://tryruby.org
- http://screencasts.org/
- http://rubyusergroup.blogspot.com
- http://railscasts.com
- http://confreaks.net/events
- http://teachmetocode.com/
- http://rubycorner.com/blogs/lang/fr (liste des blogs francophones )

Blogs personnels

Aaron Quint – QuirkeyBlog
Adam Keys – The Real Adam
Adam Wiggins – A Tornado of RazorBlades
Amanda & Michael Morin – Amanda and Michael’s Ruby Blog
Amy Hoy – Slash7
Antonio Cangiano – Zen and the Art of Programming
Brian Dainto – The Budding Rubyist
Brian Eng & Jeff Cohen – Softies on Rails
Brian Marick – Exploration Through Example
Bruce Williams – Codefluency
Chad Fowler – Chad Fowler
Charles Nutter – Headius
Chris O’Sullivan – The Chris O Show
Dave Thomas – PragDave
David Heinemeier Hansson – Loud Thinking
Derek Neighbors – Derek Neighbors
Dr Nic Williams – Dr Nic
Eric Hodel – Segment7
Evan Phoenix – evan.musing
Ezra Zygmuntowicz – Brainspl.at
Eldon Alameda – Simplifies
Eric Falcao – austin entrepreneur
Fabio Akita – AkitaOnRails.com (Portuguese)
Geoffrey Grosenbach – Nuby on Rails
Giles Bowkett – Giles Bowkett
Graeme Mathieson – Rubaidh
Gregg Pollack & Jason Seifer – Rails Envy
Ilya Grigorik – igvita.com
Jade Meskill – iamruinous
James Golick – James on Software
Jamie van Dyke – FearOfFish
Jamis Buck – the { buckblogs :here }
Jay Fields – Jay Fields’ Thoughts
Jay Phillips – Adhearsion Blog
Jesse Newland – SoylentFoo
Jim Weirich – { |one, step, back| }
Joe O’Brien –
my not-so-barbaric yawlp
John Lam – John Lam on Software
John Nunemaker – RailsTips
Josh Susser – has_many :through
Lindsay Holmwood – auxesis’ musings
Lyle Johnson – Lovable Lyle
Manik Juneja – { :from => Delhi, :about => everything }
Marc-Andre Cournoyer – macournoyer’s blog
Matt Aimonetti – The Merbist
Matt Todd – Paragon Adrift
Michael Bleigh – Mister Bleigh
Michael Ivey – Michael Ivey
Michael Koziarski – The Rails Way
Mike Gunderloy – A Fresh Cup
Mike Perham – Mike Perham
Mislav Marohnic – No strings attached
Nick Plante – zerosum dirt(nap)
Nick Quaranto – Litany Against Fear
Obie Fernandez – Obie Fernandez
Pat Eyler – On Ruby
Peat Bakke – Peat Dot Org
Peter Cooper – Peter Cooper’s Blog
Peter Szinek – Ruby, Rails, Web2.0
Pratik Naik –
has_many :bugs, :through => :rails
PJ Hyett & Chris Wanstrath – Err The Blog
Rick Olson – techno weenie
Richard Roberts – RichText
Ryan Bates – RailsCasts
Ryan Daigle – Ryan’s Scraps
Ryan Tomayko – Ryan Tomayko
Sau Sheong Chang – saush.com
Steve Sanderson – Steve Sanderson
Sur – Expressica::Blog
Tim Kadom – Skiptree
Tom Preston-Werner – Tom Preston-Werner
Tobias Lutke – Too-biased
Yehuda Katz – Katz Got Your Tongue?
Yukihiro Matsumoto (Matz) – Matz’s Blog (Japanese)
Zed Shaw – Zed’s Technical Blog

Blogs gérés par des entreprises

Altoros – Blog on the Business of Software Product Development
Dynamic50 – The Blog of the Fifty Group
ELC Technologies – ELC Technologies
Engine Yard – Union Station
FiveRuns – FiveRuns Blog
Heroku – Heroku| Blog
Highgroove Studios – The Napkin
MorphLabs – Morph Labs Staff Blog
New Bamboo – Bamboo Blog
Relevance Inc. – Relevance Blog
RubyLearning – RubyLearning Blog
Taazza – Taazza newsroom
TheWebFellas – TheWebFellas
Thoughtbot – Giant Robots
Unspace – Rethink

Autres

DB2 on Rails – DB2 on Rails
Odd Thesis – Odd Thesis
Rails on the Run – Rails on the Run
RailsOnWave.com – RailsOnWave.com
Ruby Best Practices – Ruby Best Practices
RubyInside – RubyInside

Understanding Rack

2011-02-15T19:15:00.006Z

" Rails 3 est compatible Rack "
" Sinatra est un framework web basé sur Rack "
" Padrino est un citoyen Rack "

Ces expressions, nous les rencontrons très souvent sur le net et surtout sur les blogs qui parlent de Ruby et du web. Qu'est ce qu'elles peuvent bien vouloir dire ?

Pour ceux qui savent pas ce que c'est Rack, ces expressions n'ont aucun sens. Malheureusement.

Expliquer Rack, dire à quoi ça peut servir et comment l'utiliser ou en faire n'ont pas été les motivations pour me placer devant "Blogger" ( parce que je suis tout le temps , ou presque, devant mon ordi ) et écrire cet article.

La vraie raison est une question que j'ai "croisée" sur Twitter. Et cette question c'était : " why rack should matter to .net developers ?". Tout le "monde" commence à faire du 'Rack'. Google a un framework basé sur Django et sur WSGI (la version Rack pour python). La communauté Microsoft en a quelques uns (frameworks je veux dire) que sont Nancy et Nina.

Ces frameworks sont basés sur une approche plus intelligente et plus simple que d'autres mais restent quand même moins classes que Sinatra ou Padrino.

Ok ! Cool ! Mais c'est quoi Rack ? On aimerait bien savoir.

So What is Rack ?

"Rack est une couche d'abstraction qui se trouve entre les serveurs et les frameworks. Cela apporte une plus grande interopérabilité entre les implémentations de serveurs HTTP et frameworks web."

Euuhhh ! C'est pas encore très clair. Revenons un peu dans le temps et revoyons comment communiquent un client HTTP et un serveur HTTP.

schéma 1 : communication HTTP entre un client et un serveur

Sur ce schéma, nous avons un scénario classique de communication entre un client et un serveur.
Le client envoie une requête HTTP. Elle arrive sur le serveur et passe souvent par toutes les couches de l'application. Après traitement de la requête, l'application répond et le serveur renvoie la réponse au client et tout le monde est content. Sûr ? non. Puisque le serveur a des limites logicielles et matérielles.

Pour ce qui est des limites logicielles, on fera comme si on n'était pas au courant et on se concentre (dans cet article) sur les limites matérielles.

PS : les 'limites' techniques ou logicielles sont surtout la nécessité d'avoir un adaptateur pour chaque serveur web et pour un chaque framework. Ce qui explique que souvent vous soyez obligés de chercher des hébergeurs pour une certaine technologie.Revenons à notre sujet.

La montée en charge ! vous en avez certainement entendue parler ? Comment éviter ce problème ? Est ce que c'est possible si vous n'avez aucun contrôle sur le serveur ? Ben oui. Par le biais des bonnes pratiques et de la bonne modélisation. Passons.

On arrive très facilement à ses limites quand on fait des efforts inutiles. Mais comment savoir qu'un effort peut être inutile ? Comment décider des actions à effectuer avant même de passer la main à l'application concernée (ça peut être un contrôleur aussi quand on fait du MVC) par la requête ?

Simple il faudra rajouter une couche supplémentaire dans "l'architecture" du serveur applicatif. Cette couche devra décider des opérations à effectuer et aussi à les traiter s'il le faut. Et dans ce cas notre application aura moins de boulot à faire et se "fatiguera" alors beaucoup moins vite.

schéma 2 : middleware installé sur le serveur

Expliquons le schéma 2. Nous avons installé sur notre serveur un middleware qui nous aidera à filtrer les requêtes et n'exécuter que celles que nous jugeons importantes ou nécessaires.

Le fait de monter plusieurs middlewares (au besoin) nous donne l'impression que notre serveur est en quelque sorte un tiroir. D'où l'appellation RACK qui veut, littéralement, dire tiroir.

Pour ce qui est des problèmes matériels et logiciels, nous savons à peu prés comment Rack peut aider.

Passons à la partie code!

Dans le monde Rack, nous avons deux types d'applications. Certaines sont appelées rack applications et d'autres rack middlewares.

La seule différence entre une application et un middleware rack réside dans le fait que le middleware est une application qui a connaissance des autres applications qui sont autour de lui. Il peut communiquer avec elles.

Tout objet ruby peut être transformé en une application rack valide. Il suffira que ce dernier puisse répondre à la méthode each. Un middleware rack doit avoir au moins deux méthodes initialize et call.

Installation de Rack :

   gem install rack

Première application Rack =>

Exemple : app.rb

class MonApplication

   def call(env)
   [ 200, {"Content-Type" => "text/html"}, "Hi from Rack"]
   end

end

Pour faire tourner cette application rack on utilisera la commande : rackup mise à notre disposition par la gem rack.

La commande rackup exige un fichier nommé config.ru (ru pour dire Rack Up).

Créons notre config.ru :

require 'app'
run MonApplication

et puis :

rackup config.ru -p 3000 # => http://localhost:3000

Dans le prochain article, on va écrire un middleware l'utiliser dans notre application. Et dans un troisième article sur Rack, nous allons écrire notre propre version de Sinatra :).

BlogCast : Première plateforme de Blogging en Ruby

2011-01-29T09:29:00.001Z

Bonjour,

Ceci est juste une annonce de la mise à votre disposition d'une plateforme de Blogging écrite entièrement en Ruby. Cette plateforme se nomme "BlogCast". Elle est gratuite, open source et encore en évolution.

BlogCast : 'Blogger autrement'.

Pour le moment, les principales fonctionnalités sont :

-> Gestion des membres ou rédacteurs
-> Gestion des articles et des commentaires
-> Gestion des SPAMS ( grâce à Rakismet )
-> Aperçu Temps réel (pendant que vous rédigez votre article vous savez déjà à quoi il ressemblera.)
-> Adopté au programmeurs et permet d'introduire du code dans le corps de votre article et tient compte de la coloration syntaxique.

What next ?

Tian (un pote et propriétaire de l'idée) et moi sommes en train de travailler sur certaines idées. Parmi lesquelles on a :

-> la création de Gem BlogCast pour faciliter son utilisation dans d'autres frameworks web Ruby.
-> la création d'un Rails 3 engine pour utiliser BlogCast comme un plugin Rails 3.
-> la création d'un middleware Rack pour faciliter l'intégration de BlogCast aux applications AppEngine.
-> Une documentation complète en français et en anglais.

Vous voulez contribuer ?

Très facile! Forkez le repo sur github rajoutez vos features, listez les dans un fichier "new_feature.txt" et faites une pull request.

How to get a copy of BlogCast ?

Vous aurez besoin de :

Git, Rails 3, Bundler et sqlite3

1-) git clone git://github.com/hkairi/BlogCast.git
2-) cd BlogCast
3-) bundle install
4-) rails server

BlogCast sera disponible sur http://localhost:3000/ . La partie administration est accessible depuis http://localhost:3000/admin .

username : admin
password : admin

Have fun.

Discovering Sinatra : Episode 2 => Skeleton generator

2011-01-04T18:04:00.001Z

Application skeleton for Sinatra

Dans cet article on va pas aborder des techniques ou fonctionnalités propres à Sinatra mais plutôt de la création d'applications Sinatra.

Sinatra nous permet de créer des applications WEB de façon très simple, rapide et claire mais ne nous donne pas des outils pour nous faciliter la création de certains composants souvent statiques tels que le Gemfile, config.ru et les répertoires tels que views, public, lib etc que nous utilisons souvent dans nos applications comme le font Rails et Merb. Les créer manuellement pour chaque nouvelle application n'est pas très intelligent c'est pour ça que j'ai écrit ce petit script SHELL qui permet de générer le squelette d'une application Sinatra.

# Le contenu du script /usr/bin/sinatra-app-gen.sh

if [ "$1" == "" ]; then

echo " Utilisation: "

echo "'sinatra-gen nom_application' pour créer l'architecture d'une nouvelle application Sinatra";

else

if [ ! -d $1 ]; then

mkdir $1;

mkdir $1/views;

mkdir $1/lib;

mkdir $1/public;

mkdir $1/public/css;

mkdir $1/public/images;

mkdir $1/public/js;

echo "require 'sinatra' " > $1/app.rb

echo "source 'http://rubygems.org' gem 'sinatra' " > $1/Gemfile

echo "require 'app.rb'" > $1/config.ru

echo "<!DOCTYPE html>\n<html>\n<head>\n<title>$1</title></head><body><%= yield %></body></html>" > $1/views/layout.erb

echo "Application Sinatra [ $1 ]créée avec succès.";

cd $1; ls ;

else

echo "Erreur lors de la création de l'application : $1 existe déjà.";

fi;

Après avoir lu le code source vous imaginez déjà ce qu'il fait : que des choses simples :). Now apprenons à l'utiliser.

Installation du script :

créer un fichier, le nommer comme suit : sinatra-app-gen, y mettre le code SHELL précédent et le mettre dans le /usr/bin et le render exécutable (chmod +x).

Utilisation :

$ sinatra-app-gen mon_application_sinatra

It's all.