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.
samedi 29 janvier 2011
mardi 4 janvier 2011
Discovering Sinatra : Episode 2 => Skeleton generator
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;
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.
lundi 3 janvier 2011
Rails 3: Episode 2 => ActiveRelation
L'épisode de cette semaine portera sur ActiveRelation qui est la nouvelle gamme de "Finder" et aussi une implémentation (ruby) de l'algèbre relationnelle.
Le modèle relationnel
Commençons par une introduction en douceur. C'est quoi le modèle relationnel ? Eh bien, vous avez probablement plus une idée générale de ce que c'est. SQL est une implémentation du modèle relationnel. Je vais pas entrer dans le détails dans cet article.
Le modèle relationnel se compose de deux grands concepts: les relations et les opérateurs. Pour faire court et simple disons que les relations sont similaires aux tables SQL, des vues et des résultats de requête. Les opérateurs sont les différents éléments du langage SQL, tels que SELECT, WHERE et JOIN.
Une des propriétés les plus importantes du modèle relationnel est la propriété de "fermeture". Cela signifie que vous pouvez prendre n'importe quel rapport, effectuer toute opération, et vous en obtiendrez une autre relation. Cela signifie que toute requête peut être utilisée comme une entrée d'une autre requête (qui est juste la notion de sous-requêtes dans SQL).
ActiveRecord 3.0
Alors que ActiveRecord était un outil pour exécuter des requêtes SQL, il est devenu un outil pour construire des relations. La différence est peut être subtile, mais reste importante. L'utilisation du modèle relationnel est l'abstraction correcte, comme nous le verrons tout au long du reste de cet article. Tout d'abord, permettez-moi de souligner quelques changements importants.
Dans l'exemple précédent, @articles est une instance de la classe Relation.Cela diffère des versions précédentes de ActiveRecord où @articles aurait été un tableau d'instances de la classe Article.
@articles = Article.order("created_at DESC")
En outre, il est important de noter que les relations doivent être considérées comme immuables. Une relation est à l'algèbre relationnelle comme un certain nombre(comme 2) est à l'algèbre élémentaire. Il serait un monde fou si 2 pourrait être mutéà représenter un nombre différent.
Le Chaînage
L'apport le plus évident de la nouvelle API est que les opérations peuvent être enchaînées. Cela est dû à la propriété de' fermeture' que j'ai mentionnée plus haut. Par exemple, les deux extraits de code suivants sont équivalents.
Article.where(:author => "moi", :category => "inutile")
Ce n'est pas seulement l'opérateur WHERE qui peut être enchaîné mais tous les autres opérateurs.
Article.where(:author => "moi").where(:category => "inutile")
L'objet Relation pourrait même être enregistré dans une variable et utilisé plusieurs fois pour définir des sous-requêtes. Quelque chose comme:
Article.where(:author => "moi").order("created_at desc")
mes_articles = Article.where(:author => "moi")
articles_inutiles = mes_articles.where(:category => "inutile") # vide :)articles_utiles = mes_articles.where(:category => "utile")
Laziness
Les relations sont matérialisées paresseusement. Cela signifie que la requête n'est pas déclenchée avant que les résultats sont réellement utilisés. Cela rend la création de relations quasi-gratuite. Le cas d'utilisation le plus évident est la mise en cache de fragment. Les relations pourrait être construites que la mise en cache soit complète ou partielle.
# controllerdef index
@articles = Article.where(:author => "hkairi")
end
# la vue
<% cache do %> <% @articles.each do |a| %>
<h2><%= a.titre %></h2>
<%= a.autre_methode %> <% end %> <% end %>
Si le fragment est mis en cache, alors @articles.each ne sera jamais appelé, sauf au moment où la requête devient effectivement utile.Auparavant, le contrôleur aurait enveloppé le bloc (@articles.each) dans une condition pour vérifier si oui ou non le fragment a été déjà mis en cache.
Available finder method
Les relations ont les méthodes de recherche suivantes à leur disposition:
where
order
limit
offset
includes
joins
select
having
group
lock
readonly
from
Sous le capot
Arel est composé de deux parties principales. La première est le côté formel des choses qui gère les relations et les opérateurs. C'est ce que ActiveRecord utilise dans son API de requêtes. La deuxième composante est l'ensemble des moteurs, qui matérialisent une relation. Cette matérialisation se passe quand une relation est "énuméré" (généralement via un appel à chacun).
Un moteur est une classe qui répond au CRUD. En d'autres termes, il doit mettre en œuvre les méthodes: créer, lire, mise à jour, et supprimer, où chaque méthode accepte un seul argument: une instance de relation. Il ya actuellement deux moteurs qui sont construits pour Arel: un moteur SQL et un moteur en mémoire. Le moteur SQL est ce que ActiveRecord utilise.
Conclusion
Cela n'a été qu'une brève introduction à la nouvelle API de requête de ActiveRecord. Les caractéristiques actuelles ne sont qu'un début. Le travail se poursuit et Arel sera développé et son intégration deviendra plus forte.
Inscription à :
Articles (Atom)