bmichel's blog

Radar system calibration
  • http://googlewebmastercentral.blogspot.com/2010/03/googles-seo-report-ca...
    Google a mené en interne une enquête sur le respect des bonnes pratiques SEO dans leurs propres produits. Les résultats ont été rendus publics, même s'ils ne sont pas flatteurs. On peut par exemple se rendre compte que même les éléments de base comme la balise title sont très mal utilisés.

  • http://martinfowler.com/bliki/VcsSurvey.html
    Cette enquête sur les outils de gestion des versions montre que le trio Subversion, Git et Mercurial est très apprécié. Ceci est d'autant plus vrai quand on les compare aux équivalents propriétaires que ce sont ClearCase ou Microsoft VSS. Si l'on rentre plus dans les détails, on se rend compte que Git sort du lot : 65% de ses utilisateurs considèrent que c'est le meilleur outil pour leurs besoins, contre 20% pour svn et 33% pour hg.

  • http://github.com/progrium/DrEval
    DrEval est un serveur web qui exécute du javascript et renvoie le résultat. Sa particularité est d'avoir été conçu spécialement pour faire tourner des scripts utilisateurs dans des environnements sandboxés. Cela en fait donc un serveur applicatif idéal pour utiliser des webhooks créés par des utilisateurs.

  • http://www.regexprn.com/2010/03/nosql-paradox-of-choice.html
    Cet article met un avant le paradoxe du choix pour les bases de données NoSQL : il y a un choix très large de bases de données NoSQL, mais cela n'est pas forcément pour les aider à devenir populaires. En effet, choisir une base de données ne se fait pas à la légère et prends du temps. Le nombre important de bases de données fait qu'il devient difficile de trouver la base de données qui nous convient, et dans le doute, il est parfois plus simple de rester sur une base de données relationnelle. Il serait donc bienvenu qu'une base de données NoSQL (ou un nombre très réduit) sorte du lot.

  • http://dean.edwards.name/weblog/2010/03/ie7js-update/
    IE7.js est une bibliothèque javascript qui vise à combler les déficiences des différentes versions d'Internet Explorer Elle corrige notamment des problèmes HTML et CSS, et permet d'utiliser des PNG transparents sous IE6. En théorie, cela doit permettre de se concentrer sur les standards, tout en faisant un site qui va passer sous IE.

  • http://jashkenas.github.com/coffee-script/
    CoffeeScript est un langage qui se compile vers du javascript. Il apporte une syntaxe qui se veut plus agréable : pas de points-virgules, utilisation simplifiée des objets et tableaux, interpolations pour les chaînes de caractères, etc. De plus, le code javascript généré respecte les règles de JSLint et n'est pas pénalisant pour les performances. Le seul point que je regrette est le choix des espaces significatifs à la Python.

  • http://www.smashingmagazine.com/2010/03/08/entering-the-wonderful-world-...
    Christian Heilmann nous offre ici un tour d'horizon sur les données géospatiales. Il aborde différentes techniques comme la récupération de la localisation d'un utilisateur via les API Geo du W3C, le géocodage (transformer une adresse en latitude/longitude) et son inverse (trouver le nom d'un lieu à partir de ses coordonnées). Cet article est vraiment un bon point de départ pour savoir ce qu'il est possible de faire et trouver les pointeurs pour le faire.

  • http://jashkenas.github.com/docco/
    Docco est un outil de génération de documentation à partir des commentaires d'un code source. On parle de Literate programming, car le code et sa documentation sont mélangés au sein d'un même document et évoluent simultanément. Docco génère un fichier HTML avec deux colonnes : la première contient les commentaires transformés via Markdown, et la seconde reprend le code source avec de la coloration syntaxique grâce à Pygments. À noter : il existe également un portage en Ruby de Docco qui se nomme Rocco.

  • http://ozmm.org/posts/man_what.html
    Chris Wanstrath explique l'intérêt des pages de man, à savoir être une documentation syntaxique permettant de trouver facilement une information précise. Il fait également le tour des outils qui permettent de les créer, les trouver et les lire.

  • http://vagrantup.com/
    Vagrant est un outil en ruby qui permet de construire facilement des machines virtuels pour des projets. Il facilite notamment tout ce qui est la mise en place de l'environnement (via Chef), ainsi que le partage des fichiers entre l'hôte et l'environnement virtuel. Je me verais bien l'utiliser pour partager un environnement complexe sur certains projets avec des personnes qui n'interviennent que ponctuellement.

Book Holder

Les pages de man sont un ensemble de manuels pour les commandes UNIX. Elles sont très utiles pour les personnes qui travaillent régulièrement avec la ligne de commande sous un UNIX, car elles permettent d'accéder facilement aux informations utiles. En effet, celles-ci sont placées dans une dizaine de sections et respectent toujours la même structure.

Par exemple, man 1 ls va afficher la page de man de la commande ls, le 1 servant à indiquer la section, en l'occurence les commandes utilisateur. On y trouve bien entendu des informations générales comme une courte description de la commande et le synopsis (ie comment l'appeler), mais également des informations beaucoup plus détaillées comme la liste des options et ce que fait chaque option.

Dans l'ensemble, les pages de man sont une solide source de documentation qui permet de retrouver très efficacement une information quand on sait se servir de man. Pourtant, les pages de man sont restées très liées aux commandes UNIX et n'ont jamais réussies à s'imposer dans d'autres domaines comme les gems Ruby ou les applications web. Il y a plusieurs raisons à ça :

  • La syntaxe Troff est relativement difficile et obscure, surtout quand on la compare à markdown ou textile.
  • Les développeurs ne connaissent pas forcément très bien la culture UNIX, et n'ont même pas envisagé la possibilité d'utiliser les pages de man pour leur documentation.
  • Les pages de man ne sont pas forcément très jolies et se lisent surtout dans des terminaux. Par exemple, l'absence d'une application graphique pour lire des page de man sous Mac OSX a peut-être repoussé certaines personnes.
  • L'export vers du HTML pour mettre cette documentation en ligne n'est pas toujours très concluant.

Mais il semblerait que les pages de man aient un regain d'activité. On voit ainsi surgir un certain nombre de projets visant à simplifier l'accès aux pages de man et leur écriture. Je voudrais mettre en avant 2 programmes qui me semblent particulièrement pertinents.

Le premier est gem-man : il permet d'accompagner les gem Ruby d'une page de man et fournit un moyen simple de les afficher. Par exemple, gem man 1 mustache affiche la page de man de la commande mustache fournit par le gem du même nom.

Le second, ronn, simplifie l'écriture d'une page de man en fournissant une syntaxe proche de Markdown. Il offre également la possibilité d'exporter la page de man en hTML pour la mettre en ligne. Je vous laisse comparer la version ronn de ronn(1) avec son équivalent troff, et regarder le résultat de l'export HTML.

Ça ne vous donne pas envie d'écrire de jolies pages de man ?

Mise à jour : Chris Wanstrath, aka defunkt, a publié un article sur le même sujet (en anglais) : man what.

  • http://vimcasts.org/ : ce site met diffuse des screencasts sur vim. Chaque semaine, un nouveau screencast de 5 à 10 minutes est publié, mettant en avant une fonctionnalité particulière de Vim.

  • http://www.igvita.com/2010/03/01/schema-free-mysql-vs-nosql/ : cet article d'Ilya Grigorik discute de la pertinence des bases de données NoSQL. En particulier, il souherait voir émerger un moteur Schema-free pour MySQL. Les discussions qui ont suivies cet article sont également intéressantes.

  • http://www.opscode.com/blog/2010/02/28/chef-0-8-2-release/ : Chef est un outil d'automatisation pour son infrastructure. La sortie de la version 0.8.2 est la première de la nouvelle branche, et apporte des nouvelles fonctionnalités majeures comme une API REST complète, un outil en ligne de commande, knife, totalement opérationnel, ou encore un mécanisme d'authentification plus robuste.

  • http://code.google.com/p/html5media/ : cette initiative vise à offrir la balise HTML5 <video> pour tout le monde. Tous les navigateurs web ne supportent pas cette balise, et pour ceux qui la supportent, les codecs ne sont pas toujours les mêmes. Ce projet permet aux développeurs web d'utiliser la balise <video> sans avoir à se soucier de ces problèmes.

  • http://rickosborne.org/blog/index.php/2010/02/09/infographic-migrating-f... : ce document est une représentation graphique d'une transformation d'une requête SQL en requête MongoDB équivalente. Elle illustre une méthode permettant de convertir systématiquement des requêtes SQL relativement complexe en requête de type Map-Reduce pour MongoDB.

  • http://groups.fsf.org/wiki/Group:GNU_Social : des personnes proches du mouvement GNU ont décidé de monter leur propre réseau social décentralisé. Celui-ci vise à offrir un équivalent distribué à facebook dans un premier temps. Il devrait également permettre un meilleur contrôle des données et de sa vie privée par la suite. Tout le code est diffusé sous licence AGPLv3.

  • http://bsonspec.org/ : le BSON, ou Binary JSON, est un protocole de sérialisation dans le style de JSON. Il est notamment utilisé par MongoDB, et présente des avantages intéressants si on le compare à Protocol Buffers : légèreté, traversabilité et efficacité.

  • http://www.cdncatalog.com/ : ce catalogue de CDN pour les bibliothèques javascripts et CSS est une ressource utile. Utiliser pour ces bibliothèques est très pertinent, car il permet aux utilisateurs d'avoir ces versions dans le cache de leurs navigateurs, ce qui accélère le temps de chargement des pages de manière non-négligeable.

 Couverture du livre Web Design For Developers

Je lis régulièrement des livres, et j'ai envie de partager mon avis sur certains d'entre eux. Je vais donc me lancer dans un exercice assez nouveau pour moi : la critique de livres.

Pour commencer, j'ai choisi le livre Web Design For Developers. C'est un livre publié par The Pragmatic Bookshelf qui s'adresse aux développeurs qui souhaitent s'initier au design de sites web. Ça tombe bien, c'est mon cas.

Ce livre explique comment construire le design d'un site web pas-à-pas. On commence par agréger les demandes et faire une esquisse sur papier qui répond à ces demandes. Puis, viennent le choix d'une palette de couleurs et des polices que l'on va utiliser pour le site. On part ensuite dans la partie graphique : création d'un logo et d'une maquette sous photoshop. On attaque alors le coeur du sujet, l'intégration HTML/CSS, avec bien sûr, un chapitre complet dédié au cas particulier d'Internet Explorer 6. Pour finir, on a le droit à des chapitres pour élargir notre horizon : un chapitre sur l'accessibilité (bien que ce sujet soit également abordé tout au long du livre), un autre sur l'optimisation d'un site pour les mobiles, etc.

Globalement, ce livre aborde de nombreux sujets sans demander de connaissance a priori des lecteurs. Il est donc très facile de prendre ce livre et de suivre chaque étape de la construction du site web d'exemple. On y trouve un grand nombre de conseils faciles à appliquer, et généralement très pertinents.

Pourtant, Web Design For Developers me laisse une impression mitigée. J'ai vraiment appréciés certains chapitres, mais d'autres m'ont laissé sur ma faim. Le chapitre sur le SEO m'a même semblé à coté de la plaque (la moitié du chapitre parle de la balise meta keywords, alors que celle-ci est ignorée par de nombreux moteurs de recherche). Je regrette également que le site d'exemple ait au final un design assez décevant.

Au final, je pense que ce livre est une bonne introduction au design web, mais qu'il ne faut pas attendre de miracles. Il vous fera découvrir les problématiques, mais ce sera à vous de creuser chacun de ces sujets si vous voulez vraiment créer un design vraiment réussi.

books

Javascript avancé

Vision Media a publié un ebook sur le javascript avancé. Il ne coûte que 4$ canadien (moins de 3€), mais j'ai appris pas mal de choses avec sur le langage javascript lui-même (pas le DOM). Ses 64 pages sont découpées en 6 chapitres :

  • Closures, Scope & Context
  • Prototypal Inheritance
  • Advanced Meta-programming Techniques
  • Behavior Driven Development with JSpec
  • Creating a jQuery Clone
  • Tools of the Trade

Si vous souhaitez mieux comprendre le javascript, pour l'utiliser avec Node.js par exemple, ça serait vraiment dommage de passer à coté.

http://www.dev-mag.com/2010/02/18/advanced-javascript/

Rails 3 Upgrade Handbook

Jeremy McAnally a écrit un ebook de 120 pages avec tout ce qu'il faut pour passer une application à Rails 3 (actuellement en beta). La plupart des informations sont disponibles ailleurs, sur le site officiel ou des blogs, mais il est très difficile d'avoir une vue synthétique de l'ensemble des modifications. Le prix de cet ebook, 12$, se justifie très simplement par le temps gagné. Vous aurez toutes les informations sous les yeux pour faire votre migration, et la liste des points à ne pas oublier est vraiment très pratique. Pour ma part, je ne regrette absolument pas cet achat.

http://www.railsupgradehandbook.com/

Contribuer en retour à l'Open Source

Ryan Bates a lancé une initiative qui va être, je l'espère, suivie par de nombreux développeurs. L'idée est simple : on utilise régulièrement des Logiciels Libres, notamment des plugins ou gems pour Ruby on Rails, et il est souhaitable de participer à cet effort. Pour cela, Ryan Bates propose une méthode :

  1. Trouver votre projet Rails le plus important
  2. Lister tous les plugins et gems que vous utilisez sur ce projet
  3. Pour chacun, faites une contribution avec, au choix :
    • Donner de l'argent
    • Corriger un bug
    • Ajouter de la documentation
    • Ou, tout simplement, remercier son auteur

Je compte sur vous pour faire la différence en faveur de ses plugins et gems Libres.

http://railscasts.com/give_back

Internet pipes

Le web évolue en permanence. Certaines tendances ne sont que des effets de mode passagers, tandis que d'autres transforment de manière profonde le web. En particulier, ces évolutions peuvent amener de nouvelles façons de concevoir et construire les sites web.

En ce moment, nous entendons de plus en plus parler de « web temps réel ». Cette dénomination est assez floue, mais derrière elle, on peut retrouver le fait que l'information navigue rapidement et relativement facilement entre le sites web : google va récupérer dans google buzz vos images en provenance de flickr et picasa, de nombreux sites intègrent des flux twitter, même ce blog récupère de l'information en provenance de github et de delicious.

Cette approche a des conséquences techniques non-négligeables. Les sites web ne sont plus juste un intermédiaire entre une base de données et des utilisateurs, mais sont de plus en plus obligés de se communiquer entre eux. Or, la communication entre deux sites web est un phénomène assez lent à cause de la latence. Cette lenteur est toute relative : en générale, c'est de l'ordre de quelques centièmes de secondes. Pourtant, cela a un impact énorme sur des applications web qui étaient jusque là capable de générer une page web en moins d'un dixième de seconde.

Les frameworks actuels comme Ruby on Rails ou Django reposent leurs capacité à encaisser un trafic conséquent sur cette rapidité, mais quand ils se retrouvent littéralement à piétiner en attendant que d'autres sites web répondent, cela peut rapidement devenir le drame : le site s'engorge puis finit par ne plus répondre.

La solution existe et est bien connue : il faut changer de paradigme de scalabilité au profit d'architectures asynchrones. L'idée est simple : quand un site web attend la réponse d'un autre site web, il va en profiter pour commencer à répondre à un deuxième client, puis à un troisième, un quatrième, etc. Il va alors se retrouver à gérer un certain nombres de requêtes en parallèle.

Ça ne paraît pas très compliqué, mais pour le développeur, c'est l'enfer : il doit savoir quand il peut traiter une requête, quand il doit passer la main, éviter à tout prix de mélanger les données de l'un avec celle de l'autre, etc. À l'heure actuelle, ce style de programmation est vraiment très exigeant, et une erreur est très vite arrivée.

Heureusement, des personnes ont décidées de s'attaquer à ce problème et de proposer des outils pour simplifier ça. Les frameworks Event-Driven commencent à apparaître, mais cela demande de mettre en place de nouvelles API, d'apprendre de nouveaux réflexes aux développeurs.

Par exemple, là où un simple tweets = Twitter::Base.new(credentials).user_timeline aurait suffit pour récupérer les tweets d'un utilisateur (en Ruby avec le gem twitter), il faut utiliser une approche bien plus compliquée dans un monde asynchrone (exemple libre) :

  1. var tweets = []
  2. new Twitter(credentials).addListener('tweet', function(tweet) {
  3.     tweets.push(tweet);
  4. }).addListener('close', function() {
  5.     // Faire quelque chose d'intéressant avec les tweets ici
  6. });

Comme on peut le voir, le code intéressant doit maintenant se trouver à l'intérieur de la fonction de callback passée à close. On va alors avoir tendance à imbriquer des fonctions dans d'autres fonctions, elles-mêmes imbriquées dans d'autres fonctions, et ainsi de suite. Au final, cela le rend le code difficilement lisible, et assez peu flexible.

Les créateurs de frameworks sont à la recherche de solutions pour proposer des API plus agréables à utiliser. EventMachine, coté Ruby, et Tornado, coté Python, essayent d'encapsuler le tout dans des classes. Cela donne un code relativement lisible, mais très verbeux (trop à mon goût) :

  1. class MainHandler(tornado.web.RequestHandler):
  2.     @tornado.web.asynchronous
  3.     def get(self):
  4.         http = tornado.httpclient.AsyncHTTPClient()
  5.         http.fetch("http://friendfeed-api.com/v2/feed/bret",
  6.                    callback=self.async_callback(self.on_response))
  7.  
  8.     def on_response(self, response):
  9.         if response.error: raise tornado.web.HTTPError(500)
  10.         json = tornado.escape.json_decode(response.body)
  11.         self.write("Fetched " + str(len(json["entries"])) + " entries "
  12.                    "from the FriendFeed API")
  13.         self.finish()

D'autres frameworks comme Node.js tâtonnent encore. Cela se voit par exemple sur ce long de fil de commentaires, qui a amené à la suppression des Promises dans node-v0.1.30. L'article "Do" it fast! est également une réflexion très intéressante sur le sujet.

Une des solutions possibles est de s'inspirer du modèle de passage de messages proposé par Erlang ou des chans et goroutines de Go :

  1. c := make(chan int)  // Allocate a channel.
  2. // Start the sort in a goroutine; when it completes, signal on the channel.
  3. go func() {
  4.     list.Sort()
  5.     c <- 1  // Send a signal; value does not matter. 
  6. }()
  7. doSomethingForAWhile()
  8. <-c   // Wait for sort to finish; discard sent value.

Pour conclure, je dirais que la seule chose qui est sûr aujourd'hui, c'est que les frameworks de demain seront asynchrones et proposeront des API adaptées à ce nouveau fonctionnement, mais pour le moment, nous n'en sommes encore réduit à explorer les différentes possibilités.

Git

Git permet d'ignorer des fichiers par projet en les listant dans un fichier .gitignore. On peut également ignorer des motifs comme log/*.log pour ignorer tous les fichiers du répertoire log avec l'extension .log

Ce mécanisme est souvent utilisé pour ignorer les fichiers temporaires utilisés par les éditeurs de texte. On retrouve alors des motifs comme *~ (emacs) ou *.swp (vim).

Pourtant, ce n'est pas l'idéal. D'une part, ce fichier est partagé par tous les utilisateurs, alors que cet usage voudrait qu'il soit spécifique à chaque utilisateur. D'autre part, il faut recopier à chaque nouveau projet les mêmes motifs, alors qu'il serait tellement plus simple d'avoir à les lister au même endroit.

La solution existe : un fichier .gitconfig par utilisateur. En plus, c'est très simple à mettre en place.

Il faut déclarer à git quel fichier utiliser pour ignorer de manière globale, et mettre les motifs qui nous intéressent dans ce fichier :


git config --global core.excludesfile ~/.gitignore
echo "*~" >> ~/.gitignore
echo "*.swp" >> ~/.gitignore
echo ".DS_Store" >> ~/.gitignore
echo "*.tmproj" >> ~/.gitignore
echo "tmtags" >> ~/.gitignore

Voilà, ce n'était pas compliqué !

Rails 3

Fin 2008, les développeurs de Merb et Rails ont annoncé qu'ils allaient joindre leurs efforts pour sortir un Rails 3 qui combinerait les avantages de Rails et ceux de Merb. Depuis, nous avons porté beaucoup d'espoirs qui s'annonce très prometteuse, mais qui est également une source de frustration que cette version ne soit pas déjà disponible. Enfin, la semaine dernière, Rails 3 est officiellement sorti en beta (avec les release notes détaillées).

Pour le moment, Rails 3 reste encore le domaine des développeurs aventureux, ceux qui n'ont pas peur de rencontrer des bugs. Par exemple, de nombreux plugins ne sont pas encore compatibles avec Rails 3 (railsplugins.org est une bonne source pour connaître la liste de ceux qui le sont).

Si vous faites parti de cette catégorie, alors deux choix s'offrent à vous. Vous pouvez commencer une nouvelle application avec Rails 3. Le 200ème railscast est un très point de départ pour ça. L'autre choix, plus ambitieux, est de porter une application Rails existante vers Rails 3. Je vous conseille alors de vous faire aider par le plugin rails_upgrade en vous laissant guider par les explications du peepcode Rails 3 Upgrade.

Dans tous les cas, il est intéressant de commencer à se plonger dans les nouveautés de Rails 3. Les articles sur le sujet sont dispersés sur de nombreux blogs, mais des listes permettent de s'y retrouver. Celle de Ruby Inside me semble être la plus complète pour le moment.

Je vous encourage également à participer à l'initiative Give Back to Open Source. C'est très simple : prenez votre plus gros projet Rails, regardez les gems et plugins que vous utilisez, et pour chacun d'eux, contribuez en retour : donnez de l'argent, corrigez un bug, écrivez de la documentation, ou simplement, remerciez son auteur. L'important est de donner en retour.

Mise-à-jour : le Rails 3 Upgrade Handbook est un guide PDF qui vous guide dans votre migration vers Rails 3. Il coûte 12$, mais il les vaut. Vous y trouverez toutes les informations utiles, y compris certaines qui sont très difficiles à trouver ailleurs.

Madison Street cable car derailed in snow, 1929

Quand on développe une application web, la sécurité est toujours une problématique à prendre au sérieux. Négligez-la et vous pouvez être sûr qu'un jour ou l'autre, un petit malin se fera le plaisir de vous montrer vos failles. Une attaque simple mais très répandue est l'injection XSS (ou Cross-site scripting). Le principe est d'envoyer du code HTML dans un site web pour qu'il soit interprété par le navigateur d'un autre utilisateur. Par exemple, on peut poster la ligne suivante sur un forum pour essayer d'ennuyer les autres utilisateurs :

  1. <script>alert('All your base are belong to us!');</script>

Cette attaque n'est toutefois pas à prendre à la légère. Elle permet par exemple de voler les cookies d'un utilisateur et donc sa session, ou encore de lui faire des actions indésirables sur le site attaqué.

Il est donc nécessaire de se protéger de cette attaque et, rassurez-vous, Ruby on Rails a tout ce qu'il faut pour faire ça simplement. Jusqu'à maintenant, la méthode pour faire ça consiste à indiquer à Rails les chaînes de caractères qui contiennent du contenu manipulé par l'utilisateur et qui pourraient donc être dangereuses. Dans le cas le plus fréquent, une telle chaîne ne doit pas du tout contenir de balise HTML, et on peut alors utiliser le helper h qui transforme les caractères dangereux en entités HTML. Exemple :

  1. Hello <%=h @name %>

Dans le cas contraire où l'utilisateur a le droit d'entrer du texte HTMl enrichi avec des balises HTML, il convient de limiter les balises et attributs autorisés. Le helper sanitize permet de faire ça :

  1. Biographie : <%=sanitize @bio %>

Cela fonctionne très bien, mais il y a toujours le risque d'oublier un h ou un sanitize, ce qui laisserait une porte pour un attaquant. C'est pourquoi il existe des plugins Rails qui favorisent l'approche inverse, à savoir indiquer quelles sont les chaînes de caractères qui sont sûres et d'échapper tout le reste. C'est également l'approche que Rails 3 offrira lors de sa sortie en février 2010.

Dans Rails 3, les chaînes de caractères auront un attribut html_safe, qui indiquera si la chaîne est sûre. Par défaut, l'attribut vaudra false, et cette chaîne sera échappée lors du rendering.

Bien entendu, votre page HTML contient des balises et il est donc nécessaire de pouvoir construire ces balises sans qu'elles soient échappées. Tout d'abord, cette protection ne vise que des contenus venant de l'utilisateur, il est donc inutile d'échapper le contenu "en dur" des vues : seul ce qui se trouvent entre <%= et %> est concerné. Dans l'exemple suivant, le nom apparaîtra bien en gras :

  1. Hello <strong><%= @name %></strong>

Une autre source de contenus légitimes est la génération de code HTML par les helpers de Rails. Heureusement, ces helpers génèrent des chaînes de caractères marquées comme sûres après avoir échappé leurs entrées. Exemple :

  1. <%= tag(:p, "<script>alert('hello');</script>") %>  # => "<p>&lt;script&gt;alert('hello');&lt;script&gt;</p>"

Enfin, il vous reste la possibilité de marquer vous-mêmes les chaînes comme étant sûres. Pour cela, vous pouvez utilisez raw quand vous êtes dans une vue, ou appeler html_safe sur la chaîne si vous êtes dans un helper. Exemple :

  1. <%= raw @site_title %>
  1. def evil_js
  2.   "<script>alert('This site is evil. Mwahahah!');</script>".html_safe
  3. end

Si vous souhaitez en savoir plus, je vous conseille la lecture de SafeBuffers and Rails 3.0 de Yehuda Katz.

Pour un de nos projets web, nous allons changer la charte graphique. Le projet en question est codé avec le framework Ruby on Rails, ce qui implique de passer sur chacun des fichiers dans app/views pour vérifier le markup, de modifier les feuilles de styles et de s'assurer que le tout est cohérent sur toutes les pages du site. Comme le site est conséquent, cela risque de ne pas être tout simple. Aussi, ai-je écrit deux scripts pour nous aider.

Le premier script sert à extraire toutes les URL appelées depuis les fichiers de logs Rails :

Le second script permet d'ajouter des commentaires HTML au début et à la fin de chaque fichier dans app/views pour l'identifier depuis le code source de la page HTML générée :

Je pense que cela va nous aider dans notre approche, mais je me demande s'il n'existe pas d'autres trucs pour cela. Avez-vous déjà été confronté à cela ? Si oui, comment vous en êtes vous sorti ?