Le Blog du Geek Joyeux

Définir une ressource Active Admin dans une gem

2012-02-03T18:03:09Z

Si vous utilisez Active Admin pour générer vos interfaces d’administration sous Rails, voici une technique pour définir des ressources depuis un engine.

Définir la ressource

Pour une question de simplicité, je place mes ressources dans un dossier admin situé dans le dossier lib/my_engine de mon engine.

# lib/my_engine/admin/articles.rb
if defined?(ActiveAdmin)
  ActiveAdmin.register Article do
    # personnalisez ici votre ressource
  end
end

Charger la ressource

Le problème auquel j’ai été confronté au début était celui du chargement de cette ressource.

Naïvement, je l’avais placée dans app/admin/articles.rb dans mon engine mais elle n’était pas chargée par l’application. Je l’ai ensuite placée dans lib/my_engine/admin et ai appelé require dessus. Le problème est que le modèle Article n’était pas encore défini au moment de l’appel à register.

J’ai donc fait appel à after_initialize dans la définition de l’engine:

# lib/my_engine/engine.rb
module MyEngine
  class Engine < Rails::Engine
    config.after_initialize do
      require 'my_engine/admin/articles'
    end
  end
end

Ce n’est peut être pas la solution la plus optimale ou la plus propre. Je serais d’ailleurs ravi d’avoir une solution alternative plus efficace. Celle-là a le mérite de fonctionner : ).

size doesn't COUNT

2012-01-17T10:16:15Z

Requêtes N+1

Lorsque vous développez avec Rails, vous devez bien sûr faire attention aux requêtes qui sont effectuées et surtout éviter les requêtes N+1.

Les requêtes N+1 sont celles qui sont lancées pour chaque élément d’une liste.

Prenons l’exemple suivant :

# Dans le contrôleur

@articles = Article.all
# SELECT articles.* FROM articles

# Dans la vue

<% @articles.each do |article| %>
  ...
  Nombre de commentaires: <%= articles.comments.count %>
  # SELECT COUNT(*) FROM comments WHERE comments.article_id = XY
  ...
<% end %>

Pour chaque article listé, une requête va être lancée pour compter ses commentaires.

Heureusement pour nous, Rails fournit, dans l’API d’ActiveRecord un moyen d’éviter ces requêtes N+1. Il s’agit de la méthode includes qui s’utilise comme ceci :

@articles = Article.includes(:comments).all
# SELECT articles.* FROM articles
# SELECT comments.* FROM comments WHERE comments.article_id IN (1, 2, ..., 42)

On peut donc voir ici que l’ensemble des commentaires est récupéré d’un seul coup. Cela nous permet d’accéder aux informations des commentaires d’un article sans requête supplémentaire.

Size vs. Count

Le souci c’est que ça ne règle pas notre problème de count. En effet, si nous faisons de nouveau appel à count, les requêtes seront tout de même effectuées !

L’astuce est donc d’utiliser size plutôt que count sur l’attribut comments de nos articles, ce qui va simplement retourner la taille du tableau contenant les commentaires associés. Ces derniers étant déjà chargés, le compte est bon !

# Dans le contrôleur

@articles = Article.includes(:comments).all
# SELECT articles.* FROM articles
# SELECT comments.* FROM comments WHERE comments.article_id IN (1, 2, ..., 42)

# Dans la vue

<% @articles.each do |article| %>
  ...
  Nombre de commentaires: <%= articles.comments.size %>
  ...
<% end %>

Versionner ses scripts de seeding avec versioned_seeds

2011-12-07T21:30:47Z

Si vous vous retrouvez dans le besoin de faire des imports de données ou des insertions scriptées dans une application Rails, de nos jours vous n’avez pas vraiment d’autre choix que de créer des tâches rake (ou consorts) pour le faire.

Dans cette idée, j’ai écrit la gem versioned_seeds qui permet de stocker ces scripts dans un dossier spécifique et de les utiliser à la manière des migrations.

Son installation se fait grâce à l’ajout de la ligne suivante dans votre Gemfile :

gem 'versioned_seeds', require: false

Le principe est simple, vous appelez un générateur qui va créer au besoin le dossier et un script dans celui ci. Le nom du script commence par un timestamp, comme les migrations, ce qui va permettre à versioned_seeds de l’enregistrer et de ne pas l’exécuter plusieurs fois.

rails g versioned_seeds:seed_file nom_du_script
        create db/seeds
        create db/seeds/20111207201942_nom_du_script.rb

Vous n’avez plus qu’à écrire votre script puis, une fois terminé, à appeler une tâche rake qui va l’exécuter:

rake vs:next

Cette tâche va trouvé le prochain script non chargé jusqu’à présent et le lancer. Si vous avez généré plusieurs scripts, vous pouvez faire appel à

rake vs:all

Qui va les lancer un-à-un.

Pour savoir où vous en êtes de vos scripts, vous pouvez faire appel à

rake vs:status

Pour connaitre la version du dernier script chargé.

Pensez simplement à ignorer le fichier .versioned_seeds dans Git, il sert à stocker la liste des scripts déjà lancés et il ne doit pas être versionné puisqu’il est spécifique à chaque machine.

Le code est disponible sur Github et la gem sur rubygems.org.

Utiliser rvm avec cron

2011-09-24T05:40:12Z

Il y a quelques temps, j’avais besoin de lancer un script ruby avec cron. Le souci, c’est que sur mon serveur, tout est à base de rvm. De fait, cron ne sait pas trouver ruby puisque rvm est chargé par mon fichier .bashrc.

La petite astuce pour que ça marche, c’est de dire à cron de charger mon environnement pour ce script spécifiquement :

0 * * * * /bin/bash -l -c 'ruby mon_script.rb'

En clair, l’option -l permet de charger l’environnement bash et l’option -c indique la commande à exécuter.

Rendre git-diff plus précis

2011-09-19T23:46:35Z

Git permet d’afficher différentes informations en couleur. Cela se fait dans le fichier de configuration, ~/.gitconfig.

[color]
  ui = true

Une des commandes concernées est git-diff. Cette coloration est bien pratique mais peut avoir ses limites. En effet, lorsque la différence sur une ligne se joue à quelques caractères seulement, il peut être difficile de détecter les modifications.

  Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
  tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
- quis nostrud exercitation ullamco labaris nisi ut aliquip ex ea commodo
+ quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
  consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
  cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
  non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Une petite astuce pour les voir plus précisément est l’utilisation de l’option –word-diff

git diff --word-diff=color

Voici le résultat obtenu :

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboaris nisi ut aliquip ex ea commodo
consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat
non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

L’option prend différentes valeurs qui peuvent être utiles selon les circonstances.

Gestion du PATH sous OS X

2011-09-19T23:44:06Z

Une fonctionnalité bien pratique de OSX_ est la gestion du PATH. En effet un mécanisme permet de ne pas surcharger son .bashrc chaque fois que l’on doit rajouter une entrée dans le PATH.

La magie s’opère dans le fichier /etc/paths et dans le dossier /etc/paths.d.

Le premier est un listing des chemin généraux :

/usr/bin
/bin
/usr/sbin
/sbin

Le deuxième est un dossier permettant d’ajouter des fichiers contenant des listings en plus. Ces fichiers seront chargés à la suite de /etc/paths.

Exemple

Si vous avez installé MySQL avec le DMG fourni sur le site officiel, vous pouvez ajouter le chemin des exécutables mysql en créant un fichier /etc/paths.d/mysql et y écrire la ligne suivante :

/usr/local/mysql/bin

Collision

Si vous vous trouvez dans la situation où vous avez un exécutable dans un dossier non système et que vous souhaitez que ce dossier ait la priorité, mettez le en tête du fichier /etc/paths, les chemins sont chargés dans l’ordre.

Créer ses propres sélecteurs avec jQuery

2011-08-25T15:03:01Z

Ce que nous cherchons à obtenir, c’est quelque chose dans ce goût là :

$('li:classMatch(^menu_item_)')

Il faut en fait créer un sélecteur personnalisé. Cela se fait en définissant une fonction afin d’étendre les sélecteurs standards de jQuery :

$.expr[':'].nomDuFiltre = function(obj, index, meta, stack) {
  // ...
};

Si votre fonction retourne vrai l’élément est sélectionné, sinon il est rejeté. La fonction reçoit quatre arguments :

obj: l’élément DOM à tester
index: le numéro d’itération dans la boucle
meta: les meta-données de votre sélecteur (dont les arguments)
stack: la pile de tous les éléments à tester

Les deux arguments qui vont nous intéresser sont obj et meta. Si on regarde le contenu de l’argument meta, on trouve ceci :

[ ":classMatch(^menu_item_)", // 0
  ":",                        // 1
  "classMatch",               // 2
  "^menu_item_",              // 3
  undefined ]                 // 4

L’entrée qui nous intéresse est donc stockée dans meta3. Il ne nous reste donc plus qu’à tester si une des classes de notre élément correspond à la valeur passée et à retourner vrai si tel est le cas :

$.expr[':'].classMatch = function(obj, index, meta, stack) {
  var pattern = new RegExp(meta[3]);
  var classes = obj.className.split(/\s+/);
  var found   = false;

  $.each(classes, function() {
    found = this.match(pattern);
    return !found;
  });

  return found;
};

Nous pouvons maintenant utiliser notre nouveau sélecteur pour trouver les éléments qui nous intéressent.

Installation de markItUp avec preview dans une application Rails3

2011-08-25T15:03:01Z

Pour ce tutoriel, je choisirai la syntaxe markdown et mon moteur de transformation de markdown vers HTML sera RDiscount.

Prérequis

markItUp se base sur jQuery, vous aurez donc besoin d’une application Rails utilisant jquery-rails. Je ne détaillerai pas ici la procédure d’installation qui est relativement simple et très bien expliquée sur la page github de jquery-rails.

Installation de markItUp

Commencez par télécharger la dernière version de markItUp depuis le site officiel. Sauvez l’archive dans RAILSROOT/public/javascripts/_. Décompressez la et déplacez le dossier RAILSROOT/public/javascripts/latest/markitup_ dans RAILSROOT/public/javascripts/markitup_. Vous pouvez ensuite supprimer latest.

Pour récupérer les CSS et images contenues dans markitup, le plus simple est de créer un lien symbolique vers markitup dans public/images et public/stylesheets.

cd RAILS_ROOT/public/images
ln -s ../javascripts/markitup ./

cd RAILS_ROOT/public/stylesheets
ln -s ../javascripts/markitup ./

Vous aurez ensuite besoin d’un set pour gérer Markdown. Il en existe plusieurs. Mon choix se portera ici sur Markmin.

Téléchargez son archive et décompressez la dans markitup/sets/.

Une fois cela fait, il faut ajouter les balises qui vont bien dans le layout de l’application.

<head>
  <title>Ma super appli Rails 3</title>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <%= stylesheet_link_tag :all %>

  <%= stylesheet_link_tag 'markitup/skins/simple/style.css' %>
  <%= stylesheet_link_tag 'markitup/sets/markmin/style.css' %>

  <%= javascript_include_tag :defaults %>
  <%= javascript_include_tag 'markitup/jquery.markitup.js' %>
  <%= javascript_include_tag 'markitup/sets/markmin/set.js' %>

  <%= csrf_meta_tag %>
</head>

On récupère donc la CSS du style Simple de markItUp ainsi que celle spécifique à Markmin. De la même manière, on récupère le script de markItUp et le set spécifique à Markdown.

Mise en place de markItUp sur une textarea

Pour activer markItUp sur une textarea, cela se fait de manière très simple. Le set activé fournit de base une variable mySettings que vous pouvez utiliser telle quelle ou modifier à votre convenance.

Dans public/javascripts/application.js, ajoutez le code suivant :

$('textarea.markItUp').markItUp(mySettings);

Lorsque vous voulez activer markItUp, ajoutez la classe markItUp sur la textarea de votre choix :

<%= f.text_area :content, :class => 'markItUp' %>

Mise en place du système de preview avec Sinatra

Pour commencer, nous allons ajouter Sinatra et RDiscount dans notre Gemfile :

gem 'sinatra'
gem 'rdiscount'

Installons nos nouvelles gems grâce à l’ami Bundler :

bundle

Écrivons ensuite notre application Sinatra qui va nous demander un long travail. Vous êtes prêt ? C’est parti !

# RAILS_ROOT/lib/markitup_preview.rb
class MarkitupPreview < Sinatra::Base
  post '/markitup-preview' do
    RDiscount.new(params[:code]).to_html
  end
end

Hop, terminé ! C’est tout… Bon maintenant, il faut faire en sorte que notre application soit atteignable au travers de Rails. Commençons par inclure le fichier markituppreview.rb_ dans config/application.rb :

Bundler.require(:default, Rails.env) if defined?(Bundler)

require 'lib/markitup_preview'

module MyRailsApp
  class Application < Rails::Application

Il nous faut également ajouter la route Rails menant à notre application :

# RAILS_ROOT/config/routes.rb
post 'markitup-preview' => MarkitupPreview, :format => false

Contacter le système de preview depuis le JavaScript

Il nous faut retourner dans application.js et personnaliser notre mySettings.

mySettings['previewParserPath'] = '/markitup-preview';
mySettings['previewParserVar']  = 'code';

mySettings['markupSet'].push({
  name:       'Preview',
  className:  'preview',
  call:       'preview'
)};

$('textarea.markItUp').markItUp(mySettings);

Conclusion

On a un système fonctionnel de preview. Par dessus tout, on a évité de créer un contrôleur qui aurait eu pour seule utilité de faire cette preview. Cool !

La méthode inject en Ruby

2011-08-25T15:03:00Z

En Ruby, il existe une méthode bien pratique nommée inject. Elle s’utilise de la manière suivante :

puts (0..10).inject(0) do |somme, x|
  somme += x
end
# => 55

Dans l’exemple précédent, on part d’une valeur de 0 que l’on modifie à chaque tour. Le code suivant est équivalent :

somme = 0
(0..10).each do |x|
  somme += x
end
puts somme
# => 55

De manière classique, on peut s’en servire pour générer un tableau ou une table de hash de la manière suivante :

@articles.inject({}) do |hash, article|
  hash[article.title] = article.body
end

Une autre utilisation interessante, est avec les booléens :

@plugins.inject(true) do |keep_going, plugin|
  keep_going &= plugin.some_method
end

On obtient donc en fin de parcours, true si tous les appels ont retourné true ou false si au moins un appel a retourné false.

Dans le cas où on veut stoper l’appel à inject dés qu’un appel retourne false, on peut utiliser l’instruction break :

@plugins.inject(true) do |keep_going, plugin|
  keep_going &= plugin.some_method or break(keep_going)
end

Cela permet de ne pas faire les appels suivants dés le premier retour négatif.

Éviter la création des fichiers ._ (point underscore) sous Mac OS X

2011-08-25T15:03:00Z

Un comportement plutôt gênant sous OS X est la création des fichiers ._ (point underscore). C’est souvent un problème quand on veut créer une archive .tar.gz ou avec certains SCM.

Voici une solution pour empêcher leur création.

Dans votre .bashrc et votre .profile, ajoutez la ligne suivante :

export COPYFILE_DISABLE=true

Utiliser un shell non standard sous mac

2011-08-25T15:03:00Z

Chaque fois que j’installe un shell sous Mac OS X et que je le règle par défaut gràce à chsh, l’application Terminal refuse de se lancer et me dit :

Vous n’êtes pas autorisé à lancer cette application.
L’administrateur a donné à votre shell une valeur illégale.

Pour régler ce petit souci, il suffit d’ajouter le chemin vers votre shell dans le fichier /etc/shells :

cat /etc/shells
# List of acceptable shells for chpass(1).
# Ftpd will not allow users to connect who are not using
# one of these shells.

/usr/local/bin/bash # bash installé avec homebrew
/bin/bash
/bin/csh
/bin/ksh
/bin/sh
/bin/tcsh
/bin/zsh

C’est une erreur que l’on ne rencontre pas lorsque l’on utilise un terminal comme iTerm 2…

Utiliser la sortie d'une commande comme un fichier en shell

2011-08-25T15:03:00Z

Il arrive qu’on ait besoin d’utiliser la sortie d’une commande comme si c’était un fichier. Voici une petite astuce pour ne pas passer par un fichier temporaire.

diff <(ls /un/dossier/au/pif) <(ls /un/autre/dossier/au/pif)

Et voilà avec cette syntaxe on a la différence entre deux dossiers sans utiliser de fichiers temporaires.

Installer la gem mysql sous Snow Leopard

2011-08-25T15:03:00Z

Sous Snow Leopard, l’installation de la gem mysql n’est pas toujours simple. Voici ce que j’utilise, sachant que mon MySQL est installé via le DMG fourni sur le site officiel.

export ARCHFLAGS="-arch i386 -arch x86_64";
sudo gem install mysql -v2.7 --no-rdoc --no-ri --         \
   --with-mysql-dir=/usr/local/mysql                      \
   --with-mysql-config=/usr/local/mysql/bin/mysql_config

Problème de police trop fine sous Snow Leopard

2011-08-25T15:02:59Z

Il y a quelques jours j’ai réinstallé un Snow Leopard sur un Mac Mini.

Lorsque j’ai lancé iTerm et TextMate, la police Monaco que j’utilise dans les deux n’était pas tout à fait comme d’habitude, plus fine et moins agréable.

Cela vient d’un bug Snow Leopard qui ne reconnait pas toujours les LCD : il les voit comme des écrans CRT et désactive l’anti-aliasing sur les polices !

Pour régler ce souci, tapez simplement ceci dans une console :

defaults -currentHost write -globalDomain AppleFontSmoothing -int 2

La prochaine fois que vous lancerez iTerm ou TextMate, ça devrait être bon.

Présentation de TotalFinder

2011-08-25T15:02:59Z

Réglages

Le paramétrage de TotalFinder se fait grâce à une entrée spécifique dans les préférences de Finder.

Le panneau de configuration se divise en plusieurs sections regroupant les différentes fonctionnalités que je vais décrire.

Les onglets

Un des principaux apports de TotalFinder est la présence d’onglets dans les fenêtres Finder. Ils ressemblent comme deux gouttes d’eau à ceux du navigateur Chrome de Google.

Il est également possible de grouper deux onglets pour obtenir une fenêtre scindée en deux.

Visor

Visor est une fenêtre Finder qui a pour particularité d’être toujours accessible grâce à un simple raccourci clavier.

Le raccourci est, par défaut, option-`. Pour ceux qui, comme moi, utilisent un clavier QWERTY mais écrivent tout de même avec les accents, ce raccourci n’est pas des plus pratiques. Heureusement, cela se change facilement.

On peut voir que quelques options sont également paramétrables.

Asepsis

Le but d’_Asepsis_ est d’éviter la création des .DS_Store dans les dossiers locaux.

Ces fichiers servent à stocker les options d’affichage des dossiers mais peuvent devenir encombrants lorsque l’on copie ces derniers sur un serveur ou une clé USB.

Plutôt que de prendre le parti d’empêcher leur création, TotalFinder les centralise simplement dans un autre dossier (/usr/local/.dscache).

De plus, une option permet d’éviter la création de ces fichiers sur les machines distantes que l’on visite.

Tweaks

L’onglet Tweaks contient bon nombre d’options bien utiles. Ces options sont d’ailleurs ce qui m’a amené à utiliser TotalFinder.

Quand on vient de Linux ou même, soyons fous, de Windows, on est habitué à quelques petites choses qui peuvent cruellement manquer lorsque l’on passe sous OS X.

Il faut être honnête, Finder n’est pas le logiciel magique qui sauve des vies tous les jours… Parmi les options qui manquent on trouvera :

la possibilité d’afficher les fichiers système ;
le tri des dossiers au dessus des fichiers ;
la maximisation de la fenêtre.

TotalFinder est là pour nous offrir ce qui aurait dû être présent depuis toujours.

Téléchargement

Une version d’essai de 30 jours est disponible.

Tout se passe sur http://totalfinder.binaryage.com/.

Le prix

On l’oublie parfois mais tous les logiciels ne sont pas gratuits. TotalFinder est effectivement payant mais le prix est tout à fait raisonnable. 15$ soit environ 10€ ce qui est assez peu par rapport à ce que l’on peut dépenser pour tant de choses bien moins utiles.

Il existe toutefois des moyens d’obtenir une licence gratuite. En participant au projet, en aidant à dénicher des bugs ou en faisant la promotion de ce produit.

Travailler en case-sensitive sous Mac

2011-08-25T15:02:59Z

Exemple simple, travailler avec un SCM comme Git ou Subversion. Un utilisateur utilisant un système case-sensitive ajoutera sans problème deux fichiers nommés Hello.txt et hello.txt.

Si on met à jour notre copie de travail, on se retrouve avec un seul fichier mais l’outil de versionning qui en suit deux en vois toujours un modifié.

svn st
M hello.txt

svn revert hello.txt
svn st
M Hello.txt

Solutions

À ce stade, peu de solutions s’offrent à nous, la première étant de réinstaller OS X et de choisir d’utiliser HFS+ en case-sensitive.

Étant donné que ce n’est pas la plus pratique des options, une alternative serait la bienvenue.

En voici une.

Créer un volume DMG

Cela revient à créer un volume amovible qui peut être utilisé comme une clé USB ou un disque dur externe. Un DMG peut donc être partitionné. Il est alors possible de formater une partition en HFS+ case-sensitive à l’intérieur de ce dernier.

L’outil Disk Utility (présent de base sur OS X) permet de créer des DMG. Il suffit de le lancer, de cliquer sur Nouvelle Image.

Réglons ensuite les paramètres en fonction de nos besoins :

Une fois le DMG créé, il ne reste plus qu’à le monter comme n’importe quel DMG et de copier le contenu de la copie de travail dedans.

ATTENTION ! N’oubliez pas les .git ou .svn sinon ça ne fonctionnera pas !

Désactiver la résolution interactive des conflits dans Subversion

2011-08-25T15:02:59Z

Depuis la version 1.5 de Subversion, la résolution des conflits se fait de façon interactive lorsque l’on utilise svn update.

svn update
Conflict discovered in 'some/file/located/somewhere.rb'.
Select: (p) postpone, (df) diff-full, (e) edit,
        (h) help for more options:

Personnellement, je ne supporte pas ce nouveau mode. Je préfère de loin faire un update complet et corriger les conflits à posteriori.

Pour le faire de manière ponctuelle l’option –non-interactive permet d’obtenir ce comportement.

svn update --non-interactive

Pour le faire de manière permanente, éditez votre ~/.subversion/config et ajoutez la ligne suivante dans la section miscellany :

[miscellany]
...
interactive-conflicts = no

Surcharge de méthode élégante en Javascript

2011-08-25T15:02:52Z

Aujourd’hui, j’ai eu besoin de surcharger une méthode Javascript. Premier réflexe, réécrire la fonction en y ajoutant le code voulu.

Soit le code qui suit :

mon_objet.fait_le_café = function() {
  var tasse = prendre_une_tasse();
  tasse.verser_café();
  tasse.faire_chauffer();

  return tasse;
}

Afin d’ajouter du sucre, on pourrait surcharger de la façon suivante :

mon_objet.fait_le_café = function() {
  var tasse = prendre_une_tasse();
  tasse.verser_café();
  tasse.faire_chauffer();

  tasse.ajouter_sucre();

  return tasse;
}

Jusque là, rien d’inhabituel. Mais quid du code propre, simple et surtout DRY ?

Voici donc une façon plus élégante d’obtenir le même résultat en écrivant juste le code nécessaire :

mon_objet.fait_le_café_sans_sucre = mon_objet.fait_le_café;

mon_objet.fait_le_café = function() {
  var tasse = mon_objet.fait_le_café_sans_sucre();

  tasse.ajouter_sucre();

  return tasse;
}

C’est tout simple, ça fonctionne et c’est DRY…

Pour information, l’idée m’est venue du framework Ruby On Rails (en) et de sa méthode

alias_method_chain (en)

Rails - Utiliser SASS avec theme_support

2011-08-25T15:02:58Z

J’ai eu l’occasion de me prendre un petit moment la tête aujourd’hui sur comment utiliser des feuilles de styles SASS au sein de thèmes dans une application Rails.

Pour la gestion des thèmes, j’ai utilisé theme_support qui permet de créer, pour chaque thème, un dossier ayant l’arborescence suivante :

un_theme
├── images
|   └── preview.png
├── javascripts
├── stylesheets
├── views
└── about.markdown

Ce que je cherchais à faire était de pouvoir mettre des fichiers SASS dans le dossier stylesheets, mais que les CSS compilées soient placées dans <app_root>/public/stylesheets.

Le plus simple moyen que j’ai trouvé pour faire ça, est d’ajouter le script suivant dans >app_root>/config/initializers/theme_sass.rb :

# :template_location est normalement une String, on la convertie donc en Array
Sass::Plugin.options[:template_location] = [[Sass::Plugin.options[:template_location], Sass::Plugin.options[:css_location]]]

# Pour chaque thème, on ajoute son dossier stylesheets à la liste des sources SASS
Theme.find_all.map(&:name).each do |theme|
  Sass::Plugin.options[:template_location] << ["#{RAILS_ROOT}/themes/#{theme}/stylesheets", Sass::Plugin.options[:css_location]]
end

Continuer d'ouvrir ses onglets en fin de liste sous Firefox 3.6

2011-08-25T15:02:56Z

Depuis quelques jours maintenant, Firefox 3.6 est sorti. Cette nouvelle version apporte un certain nombre de nouveautés, dont certaines qui peuvent être déroutantes (<troll>le nouveau système de skins uselessfull par exemple ?</troll>).

Bref ! Une nouveauté est l’ouverture des onglets relatifs (ouverture d’un lien de la page courante dans un onglet) à côté de l’onglet courant et non plus à la fin de la liste. Tout cela n’aurait rien de bien gênant si cette fonctionnalité pouvait être désactivée grâce à une simple case à cocher…

Voici un moyen simple de revenir à l’ancien fonctionnement.

Ouvrez l’URL about:config.

Dans la zone de filtre saisissez insertRelated cela devrait laisser seulement une entrée :

Double-cliquez dessus pour passer sa valeur à false.

C’est tout. Les nouveaux onglets devraient s’ouvrir maintenant en fin de liste.

EDIT: Je viens de trouver un lien avec quelques astuces supplémentaires

Utiliser GetText côté Javascript avec Rails

2011-08-25T15:02:56Z

Installation

gettext_json s’installe comme n’importe quel plugin Rails. Donc, au choix :

La méthode par gem :

gem install gettext_json

Dans config/environment.rb :

config.gem "gettext_json", :version => ">= 0.0.2"

Puis, à la racine de votre application :

rake gems:install

Le méthode vendor/plugins :

./script/plugin install git://github.com/simonc/gettext_json.git

Utilisation

Initialisation

La première étape est de faire appel au générateur gettext_json :

./script/generate gettext_json

Ceci va créer trois fichiers :

gettext_json.js: La micro librairie Javascript.
lib/js_parser.rb: Le parser de fichiers javascript pour GetText.
lib/tasks/gettext_json.rake: Contient la tâche rake makemo:json

Génération des traductions

Lorsque l’on utilise GetText avec Rails, on se sert en général de deux tâches rake : updatepo et makemo. Pour plus d’informations : Ruby-gettext-howto-rails.

Pour que les chaines à traduire dans les fichiers Javascript soient prises en compte, votre tâche updatepo doit ressembler à ceci :

desc "Update pot/po files."
task :updatepo do
  require "gettext_rails/tools"
  require "js_parser"
  GetText.update_pofiles(
    "your_app",
    Dir.glob("{app,lib,bin,public}/**/*.{rb,erb,rjs,js}"),
    "your_app 1.0.0"
  )
end

Il ne reste plus qu’à faire appel à la tâche rake pour obtenir les nouvelles chaines :

rake updatepo

Génération du fichier JSON

Pour générer le fichier de traductions utilisables par Javascript, utilisez la tâche rake suivante :

rake makemo:json

Un fichier public/javascripts/gettext_json_translations.js va être créé.

Traduction des chaines

Pour utiliser GetText côté Javascript, il faut inclure deux fichiers dans le layout de l’application :

<%= javascript_include_tag 'gettext_json.js' %>
<%= javascript_include_tag 'gettext_json_translations.js' %>

Il vous suffit ensuite dans vos scripts d’utiliser la micro librairie :

// Définir la locale courante (la valeur par défaut est 'en')
GetText.locale = "fr";
var str = GetText.t("Hello World");
//=> "Bonjour le Monde"

En savoir plus

gettext_json sur Github

Mettre en place un groupe de sites de démonstration

2011-08-25T15:02:55Z

Quand on développe de nombreux sites, on n’a pas forcement envie de toucher à ses VirtualHosts pour chaque nouveau site.

Voici ce que j’ai mis en place sur mon serveur pour l’espace de démo de ce genre de sites.

Le but était d’avoir un dossier contenant un nombre non limité de dossiers nommés demo1, demo2, demo3, etc…

Pour cela, j’ai créé un dossier demos à la racine de mon serveur Apache. C’est ce dossier qui va contenir tous les dossiers demoXYZ.

J’ai ensuite ajouté un VirtualHost comme ceci :

<VirtualHost *:80>
  ServerName demos.exemple.com
  ServerAlias demo*.exemple.com
  DocumentRoot /var/www/demos

  <Directory />
    AllowOverride all
  </Directory>
</VirtualHost>

Le travail de dispatch entre les différents dossiers de démo est fait par un fichier .htaccess dans le dossier demos :

RewriteEngine On
RewriteCond %{HTTP_HOST} ^demo(\d+).exemple.com
RewriteCond %{REQUEST_URI} !^/demo
RewriteRule (.\*) demo%1/$1 [L]

Et voilà ! Après redémarrage du serveur, tout devrait fonctionner.

Deverouiller un groupe de fichiers sous Mac

2011-08-25T15:02:58Z

Dernièrement, lors de la copie de fichiers depuis le disque dur d’une amie, je me suis retrouvé avec de nombreux fichiers verrouillés. Verrouillés au sens OS X du terme.

Il est possible pour chaque fichier d’afficher ses infos et de décocher la case de verrouillage.

Mais lorsque cela concerne une centaine, ou un millier de fichiers, d’un coup, cocher une simple case peut devenir quelque peu fastidieux.

Pour effectuer cette action en ligne de commande, il suffit d’utiliser la ligne suivante :

chflags nouchg <fichiers>

Utiliser Paperclip avec Rails sous Mac

2011-08-25T15:02:58Z

Pour gérer l’upload de fichiers dans les applications Rails, un plugin fréquemment utilisé est Paperclip. Récemment, lors du développement d’un projet, je me suis retrouvé confronté à un problème lors de l’envoie des fichiers. En effet, ça ne fonctionnait pas et je recevais un message d’erreur à chaque fois.

Après quelques recherches, j’ai fini par trouver que cette erreur venait du fait que mon application ne trouvait pas son chemin vers les outils d’ImageMagick dont Paperclip dépend au travers de Rmagick.

Pour résoudre ce problème, il suffit d’ajouter un initialiseur à l’application.

J’ai donc ajouté le fichier RAILS_ROOT/config/initializers/paperclip.rb contenant ceci :

Paperclip.options[:command_path] = '/opt/local/bin'

J’ai utilisé ce chemin car j’ai installé ImageMagick en utilisant MacPorts.

SSH automatique sur une machine au travers d'une autre

2011-08-25T15:02:54Z

Pour une connexion ponctuelle, l’utilisation de l’option -t permet de gagner du temps :

$ ssh user1@machine1 -t user2@machine2
Welcome to machine1
Welcome to machine2
machine>

Quand il s’agit d’utiliser ce genre de connexion de façon plus fréquente, déclarer ce mécanisme en configuration est beaucoup plus simple. Pour ce faire, il suffit d’éditer le fichier ~/.ssh/config et d’y insérer les lignes suivantes :

Host machine1
  User user1

Host machine2
  User user2
  ProxyCommand ssh machine1 nc %h %p 2> /dev/null

Cela permet de définir la manière dont on se connecte à machine2 :

$ ssh machine2
machine2>

Ignorer les changements d'espaces dans un diff SVN

2011-08-25T15:02:54Z

Lorsque l’on édite un fichier, il peut arriver qu’en plus de simples modifications, certaines portions, voire le fichier entier, soient re-indentées. Malheureusement, Subversion étant bête et discipliné, un svn diff montrera les lignes modifiées mais également les lignes simplement indentées.

Cela peut devenir gênant lorsque, par exemple, tout le fichier s’en retrouve changé.

Pour ignorer ces différences d’espaces lors d’un diff, la commande à utiliser est la suivante :

svn diff --extensions -bu

Problème des noms de fichiers avec accents dans Subversion sous OS X

2011-08-25T15:02:54Z

Si vous utilisez des fichiers dont le nom contient des accents sur un dépôt SVN, vous avez de grandes chances de rencontrer quelques soucis sous Mac, si vous avez installé Subversion avec MacPorts. Le problème vient de la différence de stockage des caractères unicode entre les plateformes Unix et OS X.

Voici comment résoudre ce problème. C’est très simple, il suffit d’installer une variante du port subversion.

port install subversion +unicode_path

Si tout s’est bien passé, vous ne devriez plus avoir de problèmes.

NOTE: j’ai ajouté cette option dans la Formula subversion de Homebrew mais c’est toujours en attente de merge de leur part…

Utiliser TextMate pour les messages de commit SVN ou Git

2011-08-25T15:02:58Z

Lorsque l’on utilise un éditeur de texte particulier, on apprécie de pouvoir l’utiliser comme éditeur par défaut pour peu tout. Cela comprend également les messages de commit des outils tels que SVN ou Git.

Malheureusement, utiliser un éditeur graphique pour cela n’est pas toujours trivial.

La commande mate propose l’option -w qui permet de signifier que l’on veut attendre que TextMate en ait fini avec le fichier pour reprendre la main.

Il est vrai que TextMate intègre les fonctionnalités SVN et Git. Personnellement j'ai toujours préféré m'occuper de ces choses là en ligne de commande... chacun son truc...

Pour SVN

Il y a plusieurs façons de dire à subversion d’utiliser tel ou tel éditeur, le plus simple est de donner une valeur à la variable SVN_EDITOR :

export SVN_EDITOR="mate -w"

Pour Git

Pour rester dans l’utilisation habituelle de Git, on utilisera la commande suivante :

git config --global core.editor "mate -w"

Relever automatiquement les mails des sous dossiers dans Thunderbird

2011-08-25T15:02:59Z

Depuis plusieurs années maintenant, j’utilise pour lire mes mails le logiciel Thunderbird. Pratique et efficace, il n’en est pas moins doté de certains défauts plus que gênants…

L’un d’eux est que Thunderbird ne relève pas automatiquement les mails dans les sous dossiers. Cela devient très gênant lorsque l’on utilise un filtrage des messages à la source, autrement dit, côté serveur.

Il existe toutefois une solution. Il est possible de préciser, pour chaque dossier, que l’on souhaite que Thunderbird vérifie les nouveaux messages.

Pour ce faire, il suffit de faire un clic droit sur un dossier puis sur Propriétés….

Dans la fenêtre qui s’ouvre, cochez la case Surveillez les nouveaux messages dans ce dossier :

Voilà, à ce jour, le mieux que l’on puisse faire, mais c’est mieux que rien.

Comment se passer de <div class="clear"></div> ?

2011-08-25T15:02:53Z

Pour corriger ce comportement il existe plusieurs solutions. La seule que je connaissais jusqu’à maintenant était la technique de la div clear.

Technique de la div clear

Cette technique consiste à ajouter une div ayant pour particularité d’avoir la propriété CSS clear: both;

Code xHTML :

<div id="container">
  <div class="content"></div>
  <div class="content"></div>
  <div class="clear"></div>
</div>

Code CSS :

#container {
  border:       1px solid #000000;
  padding:      10px;
}
      
.content {
  background:   #999;
  float:        left;
  height:       100px;
  width:        100px;
  margin-right: 10px;
}

.clear {
  clear: both;
}

Voici le résultat :

Cette solution permet d’obtenir le résultat voulu mais un souci subsiste, l’utilisation d’une balise présente uniquement pour le style.<br> C’est mal !

Voici donc une solution purement CSS se basant sur l’utilisation de la propriété overflow.

La technique Overflow

Pour cette technique il suffit simplement d’ajouter la propriété overflow: hidden sur le conteneur.

Edit: Attention ! Pensez à préciser une width, sinon la technique risque de ne pas marcher sous certains navigateurs !

Code xHTML :

<div id="container">
  <div class="content"></div>
  <div class="content"></div>
</div>

Code CSS :

#container {
  border:       1px solid #000000;
  padding:      10px;
  overflow:     hidden;
  width:        100%;
}
      
.content {
  background:   #999;
  float:        left;
  height:       100px;
  width:        100px;
  margin-right: 10px;
}

Le résultat est le même mais le code HTML reste cantoné au strict minimum ;).

Enjoy !

ssh: complétion et alias

2011-08-25T15:02:57Z

Voici deux petites astuces pour améliorer l’utilisation de ssh.

Complétion des noms d’hôtes

Pour obtenir la complétion des noms d’hôtes pour ssh et scp, il vous suffit d’installer le paquet bash-completion.

# Sous Debian et consorts
aptitude install bash-completion

# Sous Mac, avec macport
port install bash-completion

# Sous Mac, avec homebrew
brew install bash-completion

Alias

Il est possible de créer des alias pour les hôtes sur lesquels on se ssh. Cela se fait en éditant le fichier ~/.ssh/config :

Host somehost
  HostName     some.host.with.long.name
  User         someuser
  IdentityFile ~/.ssh/other_id_rsa

Ceci permet de se connecter à l’hôte some.host.with.long.name avec l’utilisateur someuser en utilisant la clé ~/.ssh/other_id_rsa :

ssh somehost

Changer facilement la configuration proxy de SVN

2011-08-25T15:02:58Z

Comme de nombreux développeurs, je suis très souvent amené à utiliser SVN (Subversion). Comme de nombreux développeurs toujours, je suis amené à partir en mission chez différents clients qui ont chacun leur proxy. Pour peu qu’on en ait déjà un au boulot ou chez soi, ça devient vite fatiguant de jongler entre ces différentes configurations.

Voici donc une petite astuce toute bête pour se rendre la vie facile.

Configurer un proxy dans subversion

Première étape, savoir où se configure les proxies dans subversion. Tout cela se passe dans le fichier ~/.subversion/servers où l’on peut trouver les lignes suivantes :

# http-proxy-host = 
# http-proxy-port = 3128
# http-proxy-username = 
# http-proxy-password =

Comme on peut le voir, il est facile de configurer un proxy selon le serveur svn que l’on veut atteindre. C’est très bien, seulement ça ne nous aide pas. Nous ce n’est pas le serveur qui change mais l’environnement de travail !

Comment se sauver la vie

Tout d’abord il faut créer un fichier servers par environnement. Idéalement on les place dans le dossier ~/.subversion avec un nom comme env1_servers, env2_servers (en ce qui me concerne je prends 3 lettres représentatives de l’environnement).

Pensez à renommer le fichier servers existant, en def_servers par exemple car servers va devenir un lien symbolique vers le fichier qui nous intéresse.

On pourrait se contenter ce ça et s’amuser à appeler ln -s à tout bout de champ, voir même créer un alias comme “ln -s ~/.subversion/env1_servers ~/.subversion/servers” mais honnêtement, une solution pérenne (quel horrible mot) serait bien plus agréable.

Voici donc une petite fonction shell qui va nous faciliter grandement la vie !

# switch de profile svn
svnpro() {
  if [ -f ~/.subversion/$1_servers ]; then
    ln -nfs $1_servers ~/.subversion/servers
  else
    echo "$1\_servers n'existe pas."
  fi
}

Et voila, il nous suffit maintenant de l’appeler de la manière suivante et notre configuration de proxy changera.

svnpro env1
svnpro env2

Un peu de couleur dans les diffs SVN

2011-08-25T15:02:54Z

Les diffs SVN peuvent parfois être longs et souvent pénibles à lire. Oui il y a des + et des - mais ça ne fait pas tout. Un bon moyen de simplifier cette lecture est l’utilisation de couleurs.

Un utilitaire bien sympathique, colordiff, permet justement de coloriser l’affichage des diffs. Packagé sous Debian ou disponible via MacPort.

Voici comment l’utiliser pour les diffs SVN.

Pour une utilisation occasionnelle :

svn diff --diff-cmd colordiff

svn diff | colordiff

Pour l’établir de manière globale, il suffit d’éditer le fichier ~/.subversion/config et d’ajouter dans la section helpers :

diff-cmd = colordiff

EDIT: Pour afficher la sortie de colordiff dans less, il faut utiliser l’option -R de ce dernier :

svn diff | less -R

Pour aller plus loin, un autre utilitaire permet de coloriser bien plus de choses, il s’agit de colorsvn.

Ignorer les fichiers de votre IDE dans Subversion

2011-08-25T15:02:53Z

Il peut arriver que, sur un projet, chacun utilise son propre IDE. Le petit problème c’est que chaque IDE crée des fichiers qui lui sont spécifiques. Lorsque l’on utilise Subversion, gérer les svn:ignore devient vite lourd. Mais une solution existe ! Ignorer localement certains fichiers.

Je prendrai NetBeans comme exemple pour cet article.

Voici ce que l’on peut voir lors d’un svn status après la création d’un projet sous NetBeans depuis des sources existantes:

svn status
?      nbproject
M      some\_file

Dans le dossier ~/.subversion, il existe un fichier config. Dans ce fichier, sous le groupe miscellany, vous trouverez les lignes suivantes :

## Debian
# global-ignores = \*.o \*.lo \*.la \*.al .libs \*.so
#   \*.so.[0-9]\* \*.a \*.pyc \*.pyo \*.rej \*~ #\*# .#\* .\*.swp .DS\_Store

## Mac
# global-ignores = \*.o \*.lo \*.la #\*# .\*.rej \*.rej
#  .\*~ \*~ .#\* .DS\_Store

Il vous suffit de décommenter ces lignes et de rajouter les fichiers que vous souhaitez ignorer :

global-ignores = *.o *.lo *.la #*# .*.rej *.rej .*~ *~ .#* .DS\_Store nbproject

Voilà le résultat :

svn status
M      some\_file

Remettre GRUB apres une reinstallation de Windows

2011-08-25T15:02:54Z

En général, quand on me parle de remettre GRUB après une installation de Windows, la première chose à laquelle je pense est “bah tu mets un live-cd, tu montes ta partition /, tu te chroot et grub-install”.

En somme, ça se résume effectivement à ça. Mais, parfois, tout ne se passe pas comme prévu. En effet, lors de ma dernière expérience, lorsque je montais la partition / de ma Debian, aucune trace de hda ou sda. Rien du tout ! La raison, je ne la connais pas et, pour être honnête, je n’ai pas cherché (création dynamique, quelque chose comme ça ?).

Bref, rien à faire, ils sont introuvables. Voici donc la solution dans ce cas :

Lancer le CD d’installation de Debian (marche probablement avec d’autre mais c’est ce que j’ai fait donc…). Après le lancement, continuer jusqu’au moment de la sélection du réseau, passer cette étape puis, un petit ALT+F2 (ou CTRL+ALT+F2), pour passer dans une console. Ensuite, voici la marche à suivre (mon / se trouve dans /dev/sda6) :

$ mount /dev/sda6 /mnt
$ mount -o bind /dev /mnt/dev
$ mount -o bind /proc /mnt/proc
$ chroot /mnt
$ grub
Probing devices to guess BIOS drives. This may take a long time.
grub> root (hd0,5) # trouvé dans /boot/grub/menu.lst
grub> setup (hd0)
sortie de grub qui dit que tout s'est bien passé
grub> # CTRL+C pour sortir
$ update-grub
$ reboot

En ce qui me concerne, ça a fonctionné. Seul un dernier souci que j’ai eu, mes partitions /home et de swap ont été échangées. Donc, au redémarrage, si un problème se pose, pensez avant de tout envoyer valser à passer en console de maintenance, à tester le montage de vos partitions pour voir ce qu’il y a dedans et modifier votre /etc/fstab en conséquence…

Contrôler Amarok en ligne de commande grace a DCOP

2011-08-25T15:02:53Z

DCOP

DCOP ( Desktop COmmunication Protocol), est un système de communication léger entre les processus et les composants logiciels d'un système. Sa principale utilisation est de permettre aux différentes applications d'interagir et de partager des tâches complexes. DCOP est essentiellement un système de « contrôle à distance », qui peut faire profiter une application ou un script de l'aide des autres applications. Il est construit au dessus du protocole d'échanges interclients de X.

Wikipedia

Utilisation d’Amarok via DCOP

Comme la plupart (voir toutes) des applications KDE, Amarok fournit une interface DCOP. Celle-ci est très complète, soit dit en passant.

Lorsque l’on est en ssh, il faut tout d’abord récupérer le DISPLAY. Ceci se fait en général de cette manière :

export DISPLAY=:0.0

Contrôle du son

La première raison de mon investigation était le contrôle du son, il est donc normal que je commence par là…

dcop amarok player setVolume X

Cette commande permet de régler le son a X, X étant compris entre 0 et 100

Récupération d’informations

Toujours grâce à DCOP, il est possible de récupérer des informations sur la playlist ou la piste actuellement en lecture. Voici un petit exemple :

dcop amarok player title
The Bonny Swans

dcop amarok player artist
Loreena McKennitt

dcop amarok player album
The Mask And The Mirror

Conclusion

Vous connaissez maintenant le principe de la manipulation d’Amarok via DCOP. Je vous invite donc à fouiller un peu plus pour découvrir toutes les possibilités offertes par l’interface DCOP d’Amarok mais également celles d’autres applications comme Kmix. Le moyen le plus simple est d’utiliser la complétion de Bash…

Références

Automatiser les tags ID3 de vos mp3

2011-08-25T15:02:56Z

Prerequis

Ces scripts se servent des programmes suivants :

eyeD3 : permet l’édition des tags ID3
jpegoptim : optimisation des images
(suppression des infos inutiles, pratique aussi pour les images web)

Sous Debian, il existe un package pour eyeD3 ainsi que pour jpegoptim.

Conventions de nommage des fichiers

Ces scripts se basent sur des conventions de nommage que j’ai établi pour mes mp3.
Mais elles peuvent ne pas être du gout de tout le monde.

Il suffit donc d’adapter les expressions régulières a vos conventions de nommage. Si vous n’en avez pas, ces scripts n’auront aucune utilité pour vous ;)

~/Music
└── Nom_Artist
    ├── Titre_Album
    │   └── 01___Titre_Du_Morceau
    └── Autre_Album
        ├── CD_1
        │   └── 01___Titre_Du_Morceau
        └── CD_2
            └── 01___Titre_Du_Morceau

Le script tag_tracks

Ce script se charge d’appliquer les tags ID3 sur chaque mp3 du dossier.

#!/usr/bin/env bash

#
# expressions regulieres utilisees pour obtenir les informations
#
reg_name="s/^\([0-9]\{2\}\)\_\_\_\(.\*\)\.\(mp3\|ogg\)//"
reg_artist="([^/]+)/[^/]+(/CD\_[0-9]+)?$"
reg_album="[^/]+(/CD\_[0-9]+)?$"

#
# Si on est en dans un album compose d'un seul CD,
# on recupere l'image Folder.jpg du dossier courant.
# Dans le cas contraire, c'est celle du dossier parent.
#
if [ -f ./Folder.jpg ]; then
  img='./Folder.jpg'
else
  if [ -f ../Folder.jpg ]; then
    img='../Folder.jpg'
  fi
fi

#
# Optimisation de l'image pour qu'elle prenne moins de place
#
jpegoptim --strip-all $img

#
# On effectue le traitement pour chaque fichier mp3 du dossier
#
for fic in *.mp3
do
  if [ -f $fic ]; then
    #
    # Recuperation des informations du fichier
    #
    num=`echo $fic | sed "s/\([0-9]\{1,3\}\).\*//"`
    name=`echo $fic | sed $reg\_name | tr -s "\_"""`
    artist=`pwd | grep -o $reg\_artist | cut -d'/' -f1 | tr -s '\_'`
    album=`pwd | grep -o $reg\_album | cut -d'/' -f1 | tr -s '\_'`
    album_num=`pwd | grep -o "CD\_[0-9]+$" | cut -d'\_' -f2`

    #
    # Si l'album ne contient qu'un seul CD
    #
    if [ -z $album\_num ]; then
      album_num='1'
    fi

    #
    # Application du tag ID3.
    # Si un tag existait avant, il est supprime.
    # Cela permet d'eviter l'accumulation de la meme image
    # dans le tag.
    #
    eyeD3 --remove-all --to-v2.4 \
          -t"$name" \
          -a"$artist" \
          -A"$album" \
          -n$num \
          --add-image=$img:FRONT_COVER \
          --set-text-frame=TPOS:$album\_num \
          $fic 1> /dev/null
  fi
done

Le script tag_album

Ce script se charge te d’appeler le script tag_tracks sur chaque album d’un artiste.

#!/usr/bin/env bash

#
# Pour chaque album
#
for d in `ls -x`
do
  if [ -d $d ]; then
    cd $d
    line="$d"

    #
    # Si c'est un album compose de plusieurs CDs,
    # pour chaque CD on appel le script tag\_tracks
    #
    if [ -d ./CD_* ]; then
      for cd in ./CD_*
      do
        cd $cd && /chemin/vers/tag_tracks 2>&1 && line="$line [OK]"
        cd ..
      done
      cd ..

    #
    # Si l'album ne contient qu'un seul CD,
    # on appele directement le script tag\_tracks
    #
    else
      /chemin/vers/tag_tracks 2>&1 && line="$line [OK]"
      cd ..
    fi
    echo $line
  fi
done

Le script tag_artists

Ce dernier script appel tag_albums pour chaque artiste de votre dossier de musique.

#!/usr/bin/env bash

#
# Pour chaque artiste (1 artiste = 1 dossier)
#
for d in `ls -x`
do
  #
  # On entre dans le dossier
  # et on fait appel au script tag\_albums
  #
  if [ -d $d ]; then
    cd $d
    line="------------------- $d"
    /chemin/vers/tag_albums && line="$line [OK]"
    echo $line
    cd ..
  fi
done

En résumé

Vous avez donc maintenant trois scripts qui vous permettent d’intervenir à différents niveaux de votre arborescence ;)

Connaitre les classes heritant d'une autre classe en Ruby

2011-08-25T15:02:57Z

Petit rappel

Pour connaître la classe parente d’une classe en Ruby il suffit de faire :

class MaClasse
end

MaClasse.superclass
# => Object

Pour connaître les ancêtres d’une classe il suffit de faire :

MaClasse.ancestors
# => [MaClasse, Object, Kernel]

Définition d’une méthode de classe

Ce que nous cherchons à obtenir est une méthode de classe, le but étant de faire ceci :

class ClasseA
end

ClasseA.children
# => []

class ClasseB < ClasseA
end

ClasseA.children
# => [ClasseB]

Pour définir une méthode de classe il y à deux façons (équivalentes) :

class MaClasse
  def self.meth1
  end

  class << self
    def meth2
    end
  end
end

La deuxième façon peut sembler un peu obscure même pour quelqu’un ayant de bonnes bases de Ruby… Je vais donc l’expliquer en détail.

En Ruby, TOUT est objet. Cela implique qu’une classe elle-même est un objet et donc… une instance de classe : la classe Class (oui c’est recherché… mais ça a le mérite d’être explicite).

Cette “instance” n’aurait aucun sens en plusieurs exemplaires, c’est pourquoi c’est un singletonur Wikipedia”).

De par l’architecture même de Ruby, il est possible d’éditer la définition de ce singleton. C’est ce que l’on fait lorsque l’on rajoute une méthode de classe.

Écrire class « self revient donc à entrer en mode d’édition de ce singleton.

La méthode inherited(by)

Comme dit précédemment, une classe est une instance singleton de la classe Class. Lorsque l’on regarde la documentation de la classe Class, on constate l’existence d’une méthode “inherited”. La lecture de sa documentation nous informe que c’est une méthode de Callback appelée à chaque fois qu’une classe enfant de la classe courante est créée.

Voila qui est intéressant !!

Écriture de notre méthode de classe

Grâce à la méthode inherited, nous allons pouvoir écrire notre méthode de classe ; de la manière la plus simple qui soit puisque nous allons redéfinir cette méthode.

class MaClasse
  class << self
    def inherited(by)
      puts "La classe #{by} hérite de #{self.name}"
    end
  end
end


class Enfant < MaClasse
end
# => La classe Enfant hérite de MaClasse

Effet de bord sympathique, la méthode inherited… est héritée par la classe Enfant :

class PetitEnfant < Enfant
end
# => La classe PetitEnfant hérite de Enfant

Bon c’est bien beau tout ça… mais en attendant, on n’a toujours pas la liste des enfants de notre classe ! J’y viens…

Maintenant que l’on sait utiliser inherited, le reste du travail est assez trivial. En voici le code :

class MaClasse
  @children = []

  class << self
    attr_reader :children

    def inherited(by)
      @children << by
      by.instance_variable_set(:@children, [])
    end
  end
end

Bon, ça, ça marche. Mais pourquoi ça marche ?
Explication :

@children = []

Ici, on crée une variable d’instance, un tableau vide qui contiendra par la suite les classes enfants. Cette variable d’instance appartient à la classe elle-même (l’instance de Class).
Placer cette variable dans class « self n’aurait aucun sens…

attr_reader :children

De la même manière que pour une classe normale, on donne accès en lecture à la variable d’instance @children.

@children << by

La classe passée en paramètre à inherited, la classe héritant de notre classe donc, est insérée dans le tableau @children.

by.instance_variable_set(:@children, [])

Cette ligne fait en sorte que la classe enfant contienne une variable @children déjà initialisée à . Ceci évite de devoir réécrire la ligne @children = à chaque fois.

Aller plus loin…

Généraliser ce fonctionnement

Étant donné qu’il est possible d’éditer n’importe quelle classe en Ruby, pourquoi ne pas généraliser notre fonctionnement à toutes les classes ?

Ceci se fait très simplement en éditant la classe la plus haut placée, j’ai nommé Object :

class Object
  @children = []

  class << self
    attr_reader :children

    def inherited(by)
      @children << by
      by.instance_variable_set(:@children, [])
    end
  end
end

class MaClasse
end

Object.children
# => [MaClasse]

class Enfant < MaClasse
end

MaClasse.children
# => [Enfant]

Découvrir toute la hiérarchie

Pourquoi ne pas pousser le bouchon encore plus loin Maurice ? Et si on faisait en sorte de récupérer toute la descendance d’une classe ?
C’est parti !

class MaClasse
    @children = []

    class << self
        attr_reader :children

        def inherited(by)
            @children << by
            by.instance_variable_set(:@children, [])
        end

        def all_children
            result = {}
            @children.each do |child|
                result[child] = child.all_children
            end
            result.empty? ? nil : result
        end
    end
end

class Enfant < MaClasse
end

class PetitEnfant < Enfant
end

class AutreClasse < MaClasse
end

MaClasse.all_children
# => {Enfant=>{PetitEnfant=>nil}, AutreClasse=>nil}

Déjà !? Et oui… c’est aussi simple que ça… :)

VirtualBox - BSoD au demarrage de Windows

2011-08-25T15:02:56Z

Si, comme moi, vous êtes passe à la nouvelle version de VirtualBox, celle de Sun, vous avez peut-être de petits problèmes avec vos anciennes VM Windows.
Voici comment résoudre le problème du BSoD juste après l’affichage du logo Windows.

La manipulation est relativement simple. Il vous suffit d’aller des les réglages de votre VM. Puis dans la partie General » Advanced » IDE Controller Type de choisir PIIX3 a la place de PIIX4.

Et voilà le tour est joué !

Mettre en place un serveur SVN disponible via HTTP

2011-08-25T15:02:52Z

Installation de Subversion (SVN)

L’installation de Subversion est assez simple :

sudo aptitude install subversion

Création d’un dépot SVN

Pour initialiser un dépôt SVN, il faut utiliser la commande suivante :

svnadmin create mon_depot

Suite à cette commande, un dossier mon_depot est créé et contient l’arborescence nécessaire au fonctionnement du dépôt.

Mise a disposition via HTTP

Cette étape nécessite qu’un serveur Apache soit installé et configuré sur le serveur SVN. Afin de permettre une authentification des utilisateurs un module apache est nécessaire. Il s’agit de libapache2-svn.

sudo aptitude install libapache2-svn

Configurons maintenant Apache pour lui indiquer le comportement à suivre concernant notre dépôt. Dans la configuration des VirtualHosts d’Apache (/etc/apache2/sites-available), imaginons que vous avez un hôte dédié aux dépôts svn.

<VirtualHost *>
  ServerName svn.mon_serveur.com
  <Location /mon_depot>
      DAV svn
      SVNPath /chemin/vers/mon_depot
      AuthType Basic
      AuthName "Mon Super Depot SVN"
      AuthUserFile /chemin/vers/mon_depot.htpasswd
      Require valid-user
      AuthzSVNAccessFile /chemin/vers/mon_depot.perm
  </Location>
</VirtualHost>

Voyons une à une les lignes précédentes :

<Location /mon_depot>

Nous déclarons l’accès au dépôt par l’url http://svn.mon_serveur.com/mon_depot

DAV svn

On signal l’utilisation du module Dav pour l’accès aux fichiers via Apache

SVNPath /chemin/vers/mon_depot

Donne le chemin vers le dépôt

AuthType Basic

On demande une authentification basique

AuthName"Mon Super Depot SVN"

Permet de donner un nom au serveur SVN.

AuthUserFile /chemin/vers/mon_depot.htpasswd

Si vous souhaitez utiliser un système de login/password pour l’accès au sources, vous pouvez utiliser un fichier de type htpasswd.

Pour le créer, il suffit de taper ceci

htpasswd -mc mon_depot.htpasswd mon_user
New password:
Re-type new password:
Adding password for user mon_user

L’option -m permet de forcer l’encryptage md5 des mots de passes. Pour d’autres options, un petit man htpasswd ne fait jamais de mal…

Require valid-user

Force les utilisateurs à être authentifiés pour effectuer des actions sur le dépôt

AuthzSVNAccessFile /chemin/vers/mon_depot.perm

Permet de spécifier un fichier chargé d’attribuer des permissions aux utilisateurs. Son contenu est du type :

[groups]
dev = mon_user, autre_user # crée le groupe dev

[/]                        # permissions pour de dossier racine du dépôt
@dev = rw                  # lecture/écriture pour le groupe dev
une_personne = rw          # lecture pour une_personne
anonymous =                # aucun droits pour les personnes anonymes
[/sous_dossier]            # permissions pour le dossier /sous_dossier
@dev = r                   # droit de lecture pour le groupe dev</pre>

Dernières notes

Pensez à donner les droits d’accès à l’utilisateur d’Apache sur votre dépôt

sudo chown -R www-data:www-data /chemin/vers/mon_depot

Pensez à bien mettre un liens vers votre VirtualHost dans /etc/apache2/sites-enabled

ln -s /etc/apache2/sites-available/mon_vhost.conf \
  /etc/apache2/sites-enabled/

Ou plus simplement

a2ensite mon_vhost.conf

Pensez à redémarrer le serveur Apache pour que les modifications soient prises en compte.

Importer les fichiers sur le serveur

Prenons un exemple simple, on dispose d’un dossier de travail

mon_dossier/
   -- main.c
   -- fichier.h

Pour importer les fichiers sur le serveur :

cd ~/mon_dossier
svn import . http://svn.mon_serveur.com/mon_depot

On trouve maintenant nos deux fichiers à la racine du dépôt.

Pour créer une copie de travail versionnée (mon_dossier n’est pas versionné) :

svn checkout http://svn.mon_serveur.com/mon_depot

Ceci a pour effet de créer un dossier mon_depot dans le dossier courant. Ce dossier est une copie de travail qui pourra être synchronisée avec le serveur lors des commits.

Et voilà, c’est terminé

Ouvrir les liens de Thunderbird dans Firefox

2011-08-25T15:02:57Z

La méthode brutale

La méthode brutale consiste à aller dans la configuration de Thunderbird et modifier la valeur d’un paramètre en dur.<br> Pour ce faire, allez dans édition > préférences > Avancé et cliquez sur le bouton ‘Config Editor…’

Une nouvelle fenêtre s’ouvre avec pour titre about:config. Dans celle-ci cherchez la clé ‘network.protocol-handler.app.http’<br> Si tout se passe bien, vous devriez avoir deux réponses :

network.protocol-handler.app.http
network.protocol-handler.app.https

Il suffit de changer les valeurs de ces deux clés avec le chemin vers firefox, /usr/bin/firefox (ou /usr/bin/iceweasel pour Debian).

La bonne méthode

Ouvrez une console et tapez ceci :

sudo update-alternatives --config x-www-browser
Il y a 3 alternatives fournissant « x-www-browser ».
Sélection    Alternative
-----------------------------------------------
*+        1    /usr/bin/konqueror
          2    /usr/bin/iceweasel (ou /usr/bin/firefox...)
          3    /usr/bin/opera
Appuyez sur Entrée pour conserver la valeur par défaut[*]
ou choisissez le numéro sélectionné : 2

Et voilà, le tour est joué…

Utiliser plusieurs fois le meme VDI sous VirtualBox

2011-08-25T15:02:53Z

Pendant un instant, j’ai crus qu’il n’était pas possible d’utiliser plusieurs fois un même fichier VDI avec VirtualBox.

En effet lorsque je copiais simplement une machine virtuelle, VirtualBox me disait que cette machine était déjà enregistrée.

Cette idée allant à l’encontre du principe même de la virtualisation, je me suis penché sur le problème.

Il se trouve que VirtualBox est livré avec un utilitaire : VBoxManage

VBoxManage permet différentes actions sur les fichiers VDI dont le ‘clonevdi’ qui justement répond au besoin de copie des machines virtuelles.

La commande suivante permet de créer un clone de MachineEnEntree :

VBoxManage clonevdi MachineEnEntree.vdi MachineEnSortie.vdi

La Text User Interface de GDB

2011-08-25T15:02:54Z

Pour la lancer en même temps que gdb

gdb -tui mon_programme

Pour l’activer alors que gdb est lancé le raccourcis clavier est Ctrl-x Ctrl-a.

Pour tirer pleinement partie de cette fonctionnalité, ajoutez les flags de debug à la compilation (-g suffit).

GDB en mode TUI (cliquez pour agrandir)

Un man kikoolol

2011-08-25T15:02:58Z

Si vous êtes intéressé par un man en couleurs, voici un moyen de l’obtenir.

Commencez par installer most. Most est un pager assez sympa dans le style de more et less.

sudo aptitude install most

Pour faire un simple test.

man -P most commande

Si ça vous plaît et que vous comptez le garder voici la marche à suivre.

sudo update-alternatives --config pager

Choisissez most

Si most vous plaît mais que les couleurs vous insupportent vous pouvez les désactiver en réglant la variable d’environnement MOST_SWITCHES<br> (dans votre .shrc par exemple)

export MOST_SWITCHES="-C"

Une signature dans le style de Tron

2011-08-25T15:02:55Z

Pour ceux qui ne connaissent pas, un petit tour sur http://www.internationalhero.co.uk/t/tron.jpg

Et oui… le mec est ridicule, le film n’en reste pas moins culte pour tout geek qui se respecte :)

Voici donc la marche à suivre :

Avant de commencer, je vous conseille de récupérer la police Tron sur dafont.com. http://www.dafont.com/fr/tron.font

Pour le tuto j’ai pris une image transparente de 280x70

Créer le fond

Renommez le premier calque en bleu clair. Pour ce faire, allez sur la liste des calques et double cliquez sur son nom.

On commence par une sélection de tout, Sélection > Tout (ou ctrl-A).

Ensuite on réduit la sélection de 5px, Sélection > Réduire.

Puis on arrondi les bords, Sélection > Rectangle arrondi.

Sélectionnez un rayon entre 20% et 50%.

Remplissez ensuite la sélection d’un bleu clair (#CDFBFF), Édition > Remplir avec la couleur de PP (ctrl-,).

Faites Calque > Transparence > Alpha vers sélection.

Créez un nouveau calque transparent et nommez le bleu foncé.

Remplissez ensuite la sélection d’un bleu très fonce (#2F3839).

Créez un nouveau calque transparent, au dessus des deux autres et nommez le dégradé.

Reprenez le noir comme couleur de Premier Plan.

Une nouvelle fois Alpha vers sélection sur un des deux autres calques, peu importe lequel.

Revenez sur le calque dégradé et appliquez un dégradé PP vers AP comme ceci (de bas en haut) :

Passez le calque en mode Superposer.

Puis fusionnez dégradé avec bleu foncé. Cela se fait en faisant un clic droit sur le calque dégradé et en choisissant fusionnez vers le bas.

Vous devriez obtenir ceci :

Créer la forme

Créez maintenant le texte. Sélectionnez la nouvelle police Tron.

Ajoutez votre texte et donnez lui la taille désirée.

Afin de recentrer le texte un fois créé,

Calque > Aligner les calques visibles :

Sur le calque de texte, Alpha vers sélection

Sélectionnez le calque bleu foncé puis,

Édition > Effacer (ctrl-K).

Masquez le calque de texte (ou supprimez le…).

Créez un nouveau calque transparent et nommez le formes.

Sur ce calque créez différentes formes que vous souhaitez ajouter à l’image.

Un fois terminé, Alpha vers sélection sur le calque formes.

Sur le calque dégradé, Édition > Effacer.

Vous pouvez effacer le calque formes.

Et la lumière fut

Créez maintenant un calque juste en dessous du calque de dégradé et nommez le lumière.

Alpha vers sélection sur le calque de bleu foncé.

Sur le calque lumière, Agrandir la sélection de 1px, Sélection > Agrandir.

Remplissez ensuite la sélection de blanc, Édition > Remplir avec la couleur d’AP (ctrl-.).

Desélectionnez tout, Sélection > Aucune (ctrl-maj-A).

Appliquez ensuite un flou Gaussien de 5px, Filtres > Flou > Flou Gaussien.

Créez un nouveau calque transparent au dessus de tous les autres calques.

Alpha vers sélection sur le calque bleu foncé.

Remplissez ensuite la sélection de blanc sur le nouveau calque.

Inversez la sélection, Sélection > Inverser (ctrl-I).

Ajoutez un masque de calque, Calque > Masque > Ajouter masque de calque.

Choisissez l’option Sélection (le blanc devrait disparaitre).

Desélectionnez tout.

Appliquez ensuite au masque de calque un flou Gaussien de 5px.

Voila c’est terminé.

Installer et configurer Apache2 sous Debian

2011-08-25T15:02:57Z

Première chose à faire : installer apache2

Pour ceux qui n’aiment pas la console :

lancez votre gestionnaire de packages (Adept/Synaptic/etc…)
cherchez le package apache2 et demandez son installation

Pour les autres :

sudo aptitude install apache2

Par défaut, sous Debian, la racine du serveur se trouve dans /var/www, les fichiers de configuration dans /etc/apache2.

En ouvrant votre navigateur préféré vous devriez atteindre votre serveur en tapant l’adresse http://localhost ou http://127.0.0.1.

Configuration basique du serveur

Après avoir effectué un changement, il faut redémarrer le serveur pour que celui-ci soit pris en compte.

sudo /etc/init.d/apache2 force-reload

Changer le répertoire racine:

éditer le fichier /etc/apache2/sites-enabled/000-default
sans se soucier du reste remplacer
1. DocumentRoot /var/www par DocumentRoot /un/autre/chemin
2. <Directory /var/www> par <Directory /un/autre/chemin>

Gestion des VirtualHosts

Il peut arriver que sur votre serveur vous hébergiez plusieurs sites en même temps. Mais comment faire la différence entre les requêtes ? C’est justement la que les VirutalHosts interviennent.

Prenons un cas pratique. Je souhaite héberger deux sites, http://www.mon_site1.com et http://www.mon_site2.com sur le même serveur. La racine de mon_site1 se trouve dans /var/www/site1 et celle de mon_sit e2 dans /home/moi/www.

Le fichier /etc/apache2/sites-enabled/000-default devrait ressembler a ceci (j’ai retiré le surplus d’infos) :

# signale que cette configuration est valable
# pour toutes les connections sur le port 80 (http)
# il est possible de specifier une adresse IP a la place de *
NameVirtualHost *:80

<Virtualhost *:80>
    ServerName www.mon_site1.com       # nom du serveur
    DocumentRoot /var/www/site1        # la racine du site
    # regles du repertoire /var/www/site1
    <Directory /var/www/site1>
        Options Indexes
        AllowOverride FileInfo         # active les .htaccess
        Order allow,deny
        Allow from all
    </Directory>

    # dans le cas ou le serveur liste un repertoire,
    # la description du serveur n'est pas affichee
    ServerSignature Off
</Virtualhost>

<Virtualhost *:80>
    ServerName www.mon_site2.com
    DocumentRoot /home/moi/www
    <Directory /home/moi/www>
        Options Indexes
        AllowOverride FileInfo
        Order allow,deny
        allow from all
    </Directory>
    ServerSignature Off
</Virtualhost>