<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sylvain Gautier on Medium]]></title>
        <description><![CDATA[Stories by Sylvain Gautier on Medium]]></description>
        <link>https://medium.com/@sylvain_?source=rss-cd5ca983ec26------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*4KJltmyU7Y8o8YPf.png</url>
            <title>Stories by Sylvain Gautier on Medium</title>
            <link>https://medium.com/@sylvain_?source=rss-cd5ca983ec26------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 19:34:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sylvain_/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[My refactoring process: Export Users To CSV]]></title>
            <link>https://medium.com/imenlo/my-refactoring-process-export-users-to-csv-3423a75ab5b6?source=rss-cd5ca983ec26------2</link>
            <guid isPermaLink="false">https://medium.com/p/3423a75ab5b6</guid>
            <category><![CDATA[ruby-on-rails-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[refactoring]]></category>
            <dc:creator><![CDATA[Sylvain Gautier]]></dc:creator>
            <pubDate>Thu, 20 Oct 2016 10:24:10 GMT</pubDate>
            <atom:updated>2016-10-20T10:24:10.264Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*HaMoVx6T9N08GFPJZsSnPA.jpeg" /></figure><p>Yesterday, I had to implement a simple CSV export in one of my client’s application. The functionality was pretty straightforward: on the Users’ page where all users are listed, I needed to add a button “Export to CSV” to download the CSV file. So let’s get started!</p><h3>Step 1 : make it work!</h3><p>I’m lazy so I googled “rails csv export” and ended on the great <a href="https://gorails.com/episodes/export-to-csv">GoRails</a> website which provides a lot of tutorials.</p><p>So I just copy pasted their code to make it work quickly (I just modified the attributes list to my need):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d127af57172c1423925755fbeb7fead5/href">https://medium.com/media/d127af57172c1423925755fbeb7fead5/href</a></iframe><h3>Step 2: make it work like you want</h3><p>The code worked great and in 2 minutes, I had CSV export on my app. I only had two issues with the CSV which was generated:</p><h4>1. The attributes names on the header row were in English but my application is in French, so I needed to translate them</h4><p>I used the same techniques that is used on my views: to rely on the built in I18n system. All my attributes names are translated in a fr.yml file in config/locales:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cd88081522a38d9db485a1cb2c0cd7a4/href">https://medium.com/media/cd88081522a38d9db485a1cb2c0cd7a4/href</a></iframe><p>So I adjusted the orirginal code to get the translated name of each attribute on the first row:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/147d3d9d4216ef78e34aa2af92d50c94/href">https://medium.com/media/147d3d9d4216ef78e34aa2af92d50c94/href</a></iframe><h4>2. The boolean attribute value needed to be human readable</h4><p>The attribute “accepts_emailing” is a boolean and when exported, the values in the CSV were true or false which is not really readable for a french user. I wanted them to be exported as ‘Oui’ and ‘Non’.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7466aed907337cbf632c0158bec5f36a/href">https://medium.com/media/7466aed907337cbf632c0158bec5f36a/href</a></iframe><h3>Step 3 : make it future-proof</h3><p>At this point, everything worked as expected. I needed to be sure that in 3 months, if I rename my attribute from <em>last_name</em> to <em>family_name</em>, my test will fail and I’ll have a chance to correct my CSV export before pushing to production…</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b433fd3ed6c2152df5d994e6419c5b93/href">https://medium.com/media/b433fd3ed6c2152df5d994e6419c5b93/href</a></iframe><h3>Step 4 : refactoring!</h3><p>So, my code works and I have a quick way to be noticed if I break something, I can start the refactoring process.</p><p>When I look at the to_csv method, I see a few problems:</p><ul><li>the method is fairly long: more than 10 lines of codes</li><li>it’s hard to see what’s going on just by looking at it</li><li>the logic in it is related to exporting to CSV, not related to the User model</li><li>if I want to provide exporting functionality to another model, I’ll have to copy/paste the all method. The only part which will change is the attributes array which is tied to the User model</li></ul><p>The first thing to do is extract all the logic to a Service object called ExportUsersToCsv:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b298d8632b0ec19bfb26888975adbd26/href">https://medium.com/media/b298d8632b0ec19bfb26888975adbd26/href</a></iframe><p>I just extracted the code and made some adjustments so it works outside the model.</p><p>Now that I’m working on an instance of class, I can extract more methods from the big <em>call</em> method:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2b75146e0a31b3eda248dc3073a74db0/href">https://medium.com/media/2b75146e0a31b3eda248dc3073a74db0/href</a></iframe><p>At this step, I realized that nothing in the code is related to User outside the users records in the initialize. I can now generalize the Service to ExportToCsv:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3fe6f5792b6722fb3b7876e4a64c82a5/href">https://medium.com/media/3fe6f5792b6722fb3b7876e4a64c82a5/href</a></iframe><p>One last step is to update the call in the controller:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1919cda168e8ce70cbcd67d2a7ede7ac/href">https://medium.com/media/1919cda168e8ce70cbcd67d2a7ede7ac/href</a></iframe><p>I just need to re-run the test and I can now deploy this new functionality to production. The great benefit is that I can add the export functionality to other models with very little code. The only thing to do is to add a constant CSV_ATTRIBUTES in the model to specify which attributes to export.</p><p><em>iMenlo is a Ruby on Rails development shop.</em></p><p><em>If you want to build your great idea, to create an internal app for your company or if you want help with your Rails app, do not hesitate to </em><a href="http://www.imenlo.com/"><em>contact us</em></a><em>!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3423a75ab5b6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/imenlo/my-refactoring-process-export-users-to-csv-3423a75ab5b6">My refactoring process: Export Users To CSV</a> was originally published in <a href="https://medium.com/imenlo">iMenlo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SaaS versus OpenSource]]></title>
            <link>https://medium.com/imenlo/saas-versus-opensource-4ef61930656d?source=rss-cd5ca983ec26------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ef61930656d</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[saas-tools]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Sylvain Gautier]]></dc:creator>
            <pubDate>Thu, 04 Aug 2016 08:00:12 GMT</pubDate>
            <atom:updated>2016-08-04T08:31:32.558Z</atom:updated>
            <content:encoded><![CDATA[<h4>Non, utiliser un logiciel Open Source ne veut pas dire dépenser moins d’argent…</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q-qSgKxq39yxez7j6jWY1w.jpeg" /></figure><p>Il existe maintenant des logiciels en SaaS pour la majorité des besoins que peuvent avoir les professionnels, qu’ils soient TPE, PME ou grands groupes. Par exemple, il n’est plus nécessaire de monter une infrastructure de messagerie, il vous suffit de payer un abonnement à Google App pour disposer de boîtes aux lettres professionnelles pour vous et vos employés. Vous pouvez également gérer l’ensemble de vos activités via des logiciels spécialisés (ERP, CRM, comptabilité, site internet, etc.).</p><p>Pour la majorité de ces SaaS, il existe un logiciel Open Source et gratuit proposant des fonctionnalités équivalentes. Et je trouve souvent fantastique de voir la qualité que certains de ces logiciels ont réussi à atteindre. Non seulement, ils sont aussi complets (voir plus !) que leur contrepartie propriétaire, mais ils disposent maintenant d’interfaces de grande qualité (ce qui leur faisait parfois défaut auparavant).</p><p>On peut ainsi envisager Gitlab à la place de Github pour héberger ses codes sources et collaborer sur le code. Et si l’on souhaite lancer une boutique e-commerce, Shopify est en train de devenir le leader des solutions SaaS tandis que Prestashop est clairement la référence OpenSource.</p><p>En revanche, quelque chose m’agace toujours un peu quand je discute avec des gens : c’est quand ils me disent : “J’ai choisi d’utiliser un logiciel Open Source parce que, tu comprends, c’est gratuit !” ou “Pourquoi je devrais payer Github 100 $ par mois pour héberger mes dépôts Git alors que je peux m’installer Gitlab chez un hébergeur pas cher ?”</p><p>Autant de bonnes raisons peuvent motiver à utiliser un logiciel OpenSource, autant je pense que le prix n’en est vraiment pas une. Parce que je pense réellement que ce n’est pas moins cher d’utiliser un logiciel OpenSource. Je pense même que c’est souvent plus cher que d’utiliser un logiciel SaaS.</p><p><strong>Lorsque vous utilisez un logiciel SaaS, ce n’est pas le logiciel que vous payez, c’est le service.</strong></p><p>En effet, lorsque vous choisissez un logiciel OpenSource, il faut prendre en compte :</p><ul><li><strong>l’hébergement du logiciel</strong> : que vous choisissiez un PaaS ou un serveur dédié, une partie du coût de l’hébergement sera dédiée aux logiciels OpenSource que vous aurez installés ;</li><li><strong>le temps passé</strong> à installer le logiciel, à le configurer, et surtout à le mettre à jour et à réaliser les montées de version ;</li><li><strong>l’écosystème</strong> : de plus en plus, les logiciels SaaS ont une logique de plateforme et proposent des intégrations avec d’autres logiciels SaaS. Cela permet facilement de partager des données entre applications et de personnaliser l’application pour des besoins spécifiques.</li></ul><p>Il faut également se poser les bonnes questions concernant :</p><ul><li><strong>le support</strong> : comment obtenir des réponses aux questions en cas de bug ou de mauvaise manipulation ? Si l’application plante ou qu’une montée de version ne se fait pas bien, qu’un correctif de sécurité urgent est déployé un samedi soir par l’éditeur : quelqu’un est-il disponible pour mettre à jour le logiciel ?</li><li><strong>la criticité des données</strong> : quel impact pour mon entreprise si les données sont perdues ou si l’application n’est pas disponible ? Par exemple, si une mauvaise configuration de l’antispam de messagerie vous fait perdre des emails, est-ce critique ?</li></ul><p>Globalement, il est intéressant de se demander si le temps que va passer la personne à gérer les solutions installées sera rentable par rapport au coût des solutions SaaS. et si sa disponibilité sera suffisante pour gérer correctement les points cités précédemment. En tenant compte de tous ces aspects, il est facile de déterminer le taux horaire de vos équipes et d’évaluer le coût d’une solution OpenSource par rapport à une solution SaaS. Il ne reste plus qu’à opter pour la solution qui apparaît la plus pertinente.</p><p>Encore une fois, ce n’est pas la qualité qui est remise en cause, mais bien le service qui est fondamentalement différent. Ces éditeurs de solutions OpenSource l’ont d’ailleurs bien compris et proposent souvent des versions SaaS de leur logiciel.</p><p>Chez iMenlo, le calcul a été vite fait. Nous sommes une petite structure de deux personnes et nous produisons de la valeur quand nous aidons nos clients, pas quand nous configurons Gitlab. Nous cherchons donc à maximiser notre temps de production et à minimiser les opérations qui ne produisent pas de valeur ajoutée. Nous sommes donc des gros consommateurs de solutions SaaS :</p><ul><li>Github pour le code</li><li>Sentry pour la gestion des erreurs applicatives</li><li>Google App pour la messagerie</li><li>OVH téléphonie / Aircall pour la téléphonie IP</li></ul><p>En conclusion, il est intéressant d’utiliser des solutions OpenSource si vous souhaitez monter en compétence sur l’infogérance de services web (par exemple si vous souhaitez proposer ce service à vos clients) ou si vous démarrez votre activité et que vous disposez de temps mais de peu de ressources au départ. Vous pouvez aussi vouloir contribuer à l’évolution de ces services en contribuant au code. Il existe également des activités où la réglementation nécessitera que vous hébergiez vous-même vos données.</p><p>En dehors de ces cas spécifiques, une petite entreprise gagnera très souvent à utiliser des services SaaS plutôt que des versions OpenSource. Le temps gagné par les équipes sera en effet bien supérieur au coût mensuel de ces logiciels.</p><p><em>iMenlo est une société spécialisée en stratégie et conception d’applications web.</em></p><p><em>Nous aidons nos clients à optimiser leurs processus métiers en les automatisant via des applications web, n’hésitez pas consulter notre méthodologie sur</em><a href="http://imenlo.com/"><em> notre site web</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ef61930656d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/imenlo/saas-versus-opensource-4ef61930656d">SaaS versus OpenSource</a> was originally published in <a href="https://medium.com/imenlo">iMenlo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Le code ça se réutilise ?]]></title>
            <link>https://medium.com/imenlo/le-code-%C3%A7a-se-r%C3%A9utilise-6d45877a5713?source=rss-cd5ca983ec26------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d45877a5713</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[ruby-on-rails-development]]></category>
            <dc:creator><![CDATA[Sylvain Gautier]]></dc:creator>
            <pubDate>Fri, 08 Jul 2016 14:24:04 GMT</pubDate>
            <atom:updated>2016-07-08T14:24:04.357Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nAB7zgPT1E55Do74A1bnrg.jpeg" /></figure><p>Lorsqu’un futur client nous présente son projet d’application, il n’est pas rare que nous ayons déjà développé des fonctionnalités similaires pour un autre client. Imaginons que votre projet d’application contienne une fonctionnalité de réservation en ligne. Nous vous montrerons ce que nous avons réalisé sur Allostudio, plateforme de réservation de studios de répétition. De même, si vous souhaitez pouvoir créer dynamiquement des questionnaires en ligne, nous vous ferons tester ce que nous avons fait sur Gimic ou sur une application pour Axa.</p><p>Après avoir démontré notre expertise sur telle ou telle problématique, la question qui revient toujours est : “<strong>Est-ce possible de réutiliser tout ou partie du code de cette application pour mon projet ?</strong>”</p><p>La réponse à cette question n’est pas évidente et c’est pour ça que j’ai choisi de la détailler ici. Pour résumer : oui et non.</p><p>En réalité, quand nous créons une nouvelle application en Ruby on Rails pour votre projet, nous réutilisons déjà énormément de code : nous réutilisons le code de Ruby on Rails. Rails est un framework incroyablement complet et puissant. Il gère nativement les interactions avec la base de données, le routage des requêtes, la génération des vues, les formulaires, l’internationalisation, etc. Il dispose par ailleurs nativement de helpers pour gagner du temps sur la mise en forme des données, la gestion des dates, les recherches complexes, etc. D’ailleurs, un aspect qui étonne toujours nos clients est lorsqu’après une journée de travail nous déployons une première version de l’application sur l’environnement de staging.</p><p>Pour revenir plus précisément à la question, il faut bien voir que lorsque nous implémentons un domaine fonctionnel sur une application, le résultat est généralement composé de trois choses :</p><ul><li>de code métier, spécifique à l’application que nous sommes en train de réaliser ;</li><li>de plugins (en ruby, javascript, CSS ou les trois), que nous avons choisi d’intégrer ou de créer, car ils sont génériques au problème et réutilisables indépendamment du contexte ;</li><li>de connaissances et bonnes pratiques sur les subtilités de l’implémentation de cette fonctionnalité.</li></ul><p>Ainsi, si nous devons refaire une gestion de réservations en ligne, nous n’allons pas réutiliser le code métier de l’application Allostudio. En effet, celui-ci est très spécifique et très lié au métier de l’application : une réservation va être prise par une personne au nom d’un de ses groupes, elle va être attachée à une salle et le montant pourra dépendre du type de salle, de l’heure et du jour de réservation, des conditions tarifaires du groupe etc.</p><p>En revanche, nous réutiliserons les librairies qui nous ont servi et nous serons capables de tirer profit de notre expérience pour aller vite dans son implémentation, sans refaire les mêmes erreurs et sans repasser par les étapes qui nous avaient amenés à la solution finale.</p><p>Pour conclure, notre force réside principalement dans l’utilisation de nos connaissances. Celles que nous avons des erreurs à éviter mais surtout celles de la problématique à résoudre. D’ailleurs, la résolution des problématiques est la partie la plus consommatrice de temps. Ensuite, il restera à adapter ces connaissances au métier de la nouvelle application : autre métier signifie autre modèle de données, autres contraintes, etc. L’étape finale sera d’implémenter ces réflexions par du code, mais c’est de loin la partie la plus facile !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d45877a5713" width="1" height="1" alt=""><hr><p><a href="https://medium.com/imenlo/le-code-%C3%A7a-se-r%C3%A9utilise-6d45877a5713">Le code ça se réutilise ?</a> was originally published in <a href="https://medium.com/imenlo">iMenlo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ruby on Rails, the iMenlo way]]></title>
            <link>https://medium.com/imenlo/ruby-on-rails-the-imenlo-way-d29965618630?source=rss-cd5ca983ec26------2</link>
            <guid isPermaLink="false">https://medium.com/p/d29965618630</guid>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[web-applications]]></category>
            <category><![CDATA[ruby-on-rails-development]]></category>
            <dc:creator><![CDATA[Sylvain Gautier]]></dc:creator>
            <pubDate>Tue, 28 Jun 2016 18:08:56 GMT</pubDate>
            <atom:updated>2016-07-05T12:29:06.087Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bdWfumSftUX2yr5HeNNd5g.png" /></figure><p>iMenlo est une agence de développement d’applications Ruby on Rails, créée par mon associé Benoit et moi. Nous réalisons des applications en Rails depuis 2009. Nous avons commencé sous Ruby 1.8 et Rails 2.3 et depuis 7 ans nous avons créé des dizaines d’applications pour nos clients, qu’ils soient startups, PME ou grands groupes.</p><p>Notre façon de coder a évolué avec les releases successives de Rails, qu’il s’agisse de l’introduction du Gemfile, de jQuery, de l’asset pipeline, de Turbolinks, du passage sous Git, etc. Nous avons également vu émerger des pratiques différentes issue de la communauté. Celles-ci ont parfois ensuite été intégrées dans Rails (comme Merb), ou parfois critiquées par son créateur, DHH.</p><p>Ainsi, au cours du temps, <strong>une opposition s’est développée entre la Rails way et d’autres conceptions sur la façon dont les applications en Rails doivent être développées</strong>. Nous nous sommes toujours intéressés à ces discussions et à ces critiques avec un esprit ouvert. J’aime beaucoup la façon que DHH a de casser les idées reçues en permanence, en plaçant <strong>la simplicité avant tout</strong> et en essayant de lutter contre la <strong>complexification et l’abstraction à outrance</strong>. Pour autant, cela ne nous a pas empêché de tester de nouvelles choses et de nouvelles pratiques quand nous les trouvions intéressantes.</p><p>En effet, lorsque nous commençons à travailler pour un client, nous le suivons généralement plusieurs années. Au cours de ces années, des besoins pour de nouvelles fonctionnalités apparaissent. De même, certaines parties du code sont complètement repensées pour s’adapter au business de l’entreprise, des migrations vers des nouvelles versions de Ruby ou Rails sont faites, etc. Et si développer la V1 d’une application Rails est relativement facile, créer une application qui s’adapte dans le temps, qui reste facile à modifier (parfois longtemps après) et facile à mettre à jour est une tâche bien plus ardue.</p><p>Ainsi, à chaque fois que nous rencontrons un problème sur ces sujets, nous réfléchissons à la manière d’améliorer les choses pour que cela ne se reproduise plus. Pour cela, nous regardons les nouvelles idées et méthodologies proposées par la communauté Rails.</p><p>Le développement web est une discipline très empirique. Lors de la conférence BaRuCo — Barcelona Ruby Conference, je me souviens de cette phrase de <a href="https://twitter.com/nusco">Paolo Perrotta</a> : “<strong>you throw spaghetti on the wall and you see what sticks</strong>”. C’est un peu ce que nous avons fait au cours des années. Nous avons introduit différentes méthodes de développement et nous avons observé que certaines d’entre elles nous aidaient beaucoup à réduire la complexité et à rendre le code plus maintenable et que d’autres produisaient plutôt l’effet inverse.</p><p>Ces expérimentations se sont traduites par <strong>des règles que nous appliquons chaque jour dans nos applications</strong>. Elles nous permettent de gagner du temps au moment du développement et lors de sa maintenance. Ces règles ne sont pas gravées dans le marbre. Elles évolueront sans doute avec l’évolution de la communauté, mais elles reflètent nos bonnes pratiques aujourd’hui. Nous n’avons pas la prétention de penser qu’il s’agisse de la meilleure façon de développer une application Rails, mais simplement que c’est la meilleure que nous ayons trouvée pour nous, actuellement.</p><h3>Règles pour les modèles</h3><h4>Pas de module</h4><p>Quand une application devient un peu complexe, l’organisation du code commence à devenir un vrai problème. A chaque nouveau besoin, on ajoute plusieurs méthodes dans les différents modèles. On se retrouve vite avec des modèles à rallonge (les fameux Fat models) avec une liste à la Prévert de méthodes sans rapport les unes avec les autres.</p><p>Pour mieux gérer cette problématique, nous avons un moment pensé que créer des modules représentant un sous ensemble de fonctionnalités d’un modèle pouvait être une bonne idée. L’idée étant d’avoir un modèle quasiment vide avec juste une liste d’include représentant les différentes responsabilités du modèle.</p><pre>class User &lt; ActiveRecord::Base<br>  include User::Subscription<br>  include User::BillingInformation<br>  include User::Moderation<br>end</pre><p>En réalité, c’est très compliqué à maintenir pour deux raisons : la première est que la classe a beaucoup trop de responsabilités et il devient très difficile d’introduire des changements sans effet de bord. La deuxième raison est que l’on se retrouve avec une sorte d’API interne de méthodes, longue comme le bras. Lorsque vous souhaitez modifier une méthode, vous devez regarder partout où elle est utilisée pour vérifier que la modification que vous allez apporter ne va pas créer d’effets de bords.</p><p>Pour ces raisons, nous avons choisi de ne plus utiliser de modules dans nos applications.</p><h4>Pas de concerns (sauf exception)</h4><p>Les concerns ont été introduits dans Rails 4, ils sont une version un peu améliorée des modules, et présentent donc les mêmes problèmes.</p><p>Nous évitons donc également de les utiliser, sauf cas très spécifique. Il y a par exemple une fonctionnalité que nous ajoutons dans presque toutes nos applications, c’est le soft delete. L’idée étant qu’un utilisateur a le droit de se tromper quand il supprime un élément. Avant que nous implémentions systématiquement cette fonctionnalité, nous avions des appels de nos clients nous expliquant qu’ils avaient supprimé par erreur une commande, une réservation, etc. et ils nous demandaient comment faire. La seule solution dans ce cas était d’extraire un backup et de recréer les données manuellement. Très compliqué.</p><p>Maintenant dans tous les modèles sensibles, il y a une colonne <em>deleted_at</em> qui représente la date de suppression. Et ces modèles incluent le concern SoftDelete :</p><pre>module SoftDelete<br>  extend ActiveSupport::Concern</pre><pre>  included do<br>    def self.not_deleted<br>      where(deleted_at: nil)<br>    end<br>  end</pre><pre>  def deleted?<br>    deleted_at.present?<br>  end</pre><pre>  def soft_delete<br>    update_attributes(deleted_at: Time.now)<br>  end</pre><pre>  def restore<br>    update_attributes(deleted_at: nil)<br>  end</pre><pre>end</pre><p>Dans le cas où un modèle a un certain nombre de dépendances qu’il faut supprimer aussi, il est toujours possible de surcharger les méthodes <em>soft_delete</em> et <em>restore</em> pour obtenir le comportement attendu.</p><h4>Pas de validation dans les modèles</h4><p>Cette règle est assez contre intuitive. Qui dit pas de validation dit incohérence de données dans la base de données et c’est le début des ennuis. En réalité, nous mettons des validations, mais uniquement au niveau des formulaires (voir la règle d’après) et pas au niveau des modèles.</p><p>La raison est que, dès qu’une application commence à avoir plusieurs types d’utilisateurs (client, commercial, administrateur, super administrateur, etc.), on se retrouve à bypasser des validations et à devoir introduire des conditions pour vérifier si on est dans tel ou tel cas de figure. On se retrouve vite avec une dizaine de lignes de validations avec des <em>if</em> et des <em>unless</em> et on ne sait plus trop pourquoi quand tel champ est à <em>vrai</em>, cette validation est sautée et pas une autre.</p><h4>Découpler les formulaires des modèles</h4><p>Le corollaire de la règle précédente est qu’il faut quand même valider que les formulaires remplis par l’utilisateur contiennent les informations attendues.</p><p>L’idée est donc de ne pas exposer un objet issu d’un modèle mais un formulaire qui est initialisé à partir d’un modèle. Cela permet de gérer en même temps les champs du modèle qui seront accessibles et modifiables par l’utilisateur.</p><p>Pour cela on utilise la gem <a href="https://github.com/apotonick/reform"><em>reform</em></a> qui fait partie des concepts introduits dans le livre <a href="https://leanpub.com/trailblazer">Trailblazer</a>.</p><p>Ainsi, si on veut permettre à un utilisateur de modifier son email et mot de passe (en vérifiant leurs présences), mais qu’on ne veut pas exposer le champ <em>role</em> qui représente ses droits, on pourra créer le formulaire UserForm de la façon suivante :</p><pre>class UserForm &lt; Reform::Form</pre><pre>  include Reform::Form::ActiveModel::ModelReflections<br>  property :email<br>  property :password</pre><pre>  validates :email, presence: true<br>  validates :password, presence: true</pre><pre>end</pre><p>Si maintenant, on souhaite permettre à un admin de modifier un utilisateur et ses droits sans qu’il ait besoin du mot de passe de l’utilisateur, on créera un autre formulaire :</p><pre>class AdminUserForm &lt; Reform::Form</pre><pre>  include Reform::Form::ActiveModel::ModelReflections<br>  property :email<br>  property :password<br>  property :role</pre><pre>  validates :email, presence: true</pre><pre>end</pre><h4>Pas de callbacks dans les modèles (sauf exception)</h4><p>Comme les validations, les callbacks dans les modèles ont souvent été une cause de soucis dans la maintenabilité de nos applications. Plus on introduit de fonctionnalités et plus des cas particuliers arrivent qui nécessitent de mettre en place des conditions spéciales pour que ce callback ne soit pas exécuté dans ce contexte mais qu’il le soit dans celui là, etc.</p><p>C’est notamment le cas pour l’envoi de mails via un callback, avec le recul. Dans bien des cas, je pense que c’est une très mauvaise idée. Vous créez un utilisateur en console et hop un email automatique est envoyé alors que vous vouliez lui en écrire un de façon personnalisée.</p><p>Nous avons remplacé les callbacks par des services (voir ci-dessous) qui sont exécutés depuis le contrôleur.</p><p>Pour autant, nous n’avons pas banni les callbacks et il y a des cas d’utilisation où je les trouve justifiés. Si vous créez un modèle <em>Article</em> avec un nom et un slug (son url), dans tous les cas celui-ci aura un slug. Du coup, avoir un callback qui le génère automatiquement me semble approprié.</p><pre>class Article<br>  before_create :set_slug</pre><pre>  private</pre><pre>  def set_slug<br>    return unless name.present? &amp;&amp; slug.blank?</pre><pre>    smart_slug = name.parameterize<br>    self.slug =<br>     if self.class.where(slug: smart_slug).empty?<br>       smart_slug<br>     else<br>       count = 1<br>       while self.class.where(slug: “#{smart_slug}-#{count}”).any?<br>         count += 1<br>       end<br>       &quot;#{smart_slug}-#{count}&quot;<br>     end<br>   end</pre><pre>end</pre><h4>Des services pour les fonctions métiers</h4><p>Introduire les services dans nos applications est probablement ce qui a le plus amélioré la qualité de notre code et résolu la majorité des soucis que nous avions.</p><p>Un service est une class Ruby qui a pour objet de réaliser une seule action (via la méthode <em>call</em>), liée aux objets qu’elle prend en paramètre. Exemple pour un site e-commerce, nous pouvons introduire le service <em>Order::Validate</em> chargé de valider une commande :</p><pre>class Order::Validate<br>  attr_reader :order</pre><pre>  def initialize(order)<br>    @order = order<br>  end</pre><pre>  def call<br>    update_order_state<br>    send_confirmation_to_customer<br>  end</pre><pre>  # private<br>  <br>  def update_order_state<br>    order.update_attributes(state: &#39;validated&#39;, validated_at: Time.now)<br>  end</pre><pre>  def send_confirmation_to_customer<br>    OrderMailer.send_confirmation_to_customer(order).deliver_later<br>  end</pre><pre>end</pre><p>Le gros avantage de cela est que l’API de validation d’une commande est très simple, il s’agit juste d’invoquer :</p><pre>Order::Validate.new(order).call</pre><p>Et du coup, les deux méthodes définies dans la classe <em>update_order_state</em> et <em>send_confirmation_to_customer</em> sont privées et réservées à la classe <em>Order::Validate</em>. Le jour où je souhaite modifier ou supprimer ces deux méthodes, je sais que je peux le faire sans effet de bord sur le reste de mon code.</p><h4>Small classes and short methods</h4><p><a href="http://www.sandimetz.com/">Sandi Metz</a> a beaucoup influencé la façon dont nous codons. Notamment avec son livre <a href="http://www.sandimetz.com/products">Practical Object-Oriented Design in Ruby</a> et ses fameuses <a href="https://robots.thoughtbot.com/sandi-metz-rules-for-developers">4 règles</a>.</p><p>Comme elle l’indique elle-même, l’idée n’est pas de suivre aveuglement ces règles. Mais quand je viens d’écrire une méthode de 10 lignes, j’ai maintenant le réflexe de la relire pour me demander si je ne pourrais pas découper cette méthode en plusieurs méthodes. Avec l’avantage que ces “sous méthodes” soient souvent réutilisables ensuite.</p><p>De la même façon, quand une classe commence à atteindre les 100 lignes de code, je me dis que cette classe fait peut-être trop de choses et que je pourrais peut-être en extraire des classes plus petites et avec une fonction bien précise. Cela fonctionne bien pour les classes de service notamment.</p><h3>Règles pour les contrôleurs</h3><h4>Que des contrôleurs REST</h4><p>Par défaut, un contrôleur Rails possède 7 actions : <em>index</em>, <em>new</em>, <em>create</em>, <em>show</em>, <em>edit</em>, <em>update</em>, et <em>destroy</em>.</p><p>Il est tentant de créer une action supplémentaire pour un besoin ponctuel. Imaginons par exemple que nous ayons un contrôleur <em>Orders</em> et que nous souhaitions avoir une page avec toutes les commandes en attente. Pourquoi ne pas ajouter une simple action <em>pending</em> ? En soi, je ne trouve pas que cela pose un problème.</p><p>Le souci c’est qu’une fois que cette action est là, lorsqu’il faudra ajouter les commandes annulées sur une page à part, on ajoutera l’action <em>cancelled</em> puis l’action <em>validated</em> pour les commandes validées. Il faudra ensuite pouvoir annuler une commande depuis l’admin, alors pourquoi ne pas ajouter l’action <em>cancel</em> qui annule une commande. Et on se retrouve très vite avec un contrôleur qui contient 30 actions sans forcément de liens entre elles.</p><p>Donc s’astreindre dès le début à systématiquement séparer les actions permet de séparer tout de suite les différentes responsabilités au niveau des contrôleurs.</p><p><a href="http://jeromedalbert.com/how-dhh-organizes-his-rails-controllers/">DHH utilise cette règle pour ses contrôleurs également.</a></p><h4>Pas de before_action dans les contrôleurs (sauf exception)</h4><p>Les before_action sont le pendant des callbacks du modèle. On se retrouve vite avec un callback hell avec des conditions dans tous les sens pour les appliquer ou non selon les cas.</p><p>Notre tendance maintenant est davantage de séparer les rôles via des namespaces (voir ci-dessous) et d’utiliser des variables helper_method dans certains cas.</p><pre>class Account::BaseController &lt; ApplicationController</pre><pre>  helper_method :account</pre><pre>  def account<br>    <a href="http://twitter.com/account">@account</a> ||= Account.find(params[:account_id])<br>  end<br>end</pre><p>Comme d’habitude, cela ne veut pas dire que nous n’en utilisons jamais, simplement que nous réfléchissons bien à leur utilité avant d’en créer un.</p><h4>Des namespaces pour les contrôleurs</h4><p>Qu’il s’agisse d’une application SaaS ou d’une application avec plusieurs rôles, attribuer des namespaces spécifiques selon les cas d’usage permet de simplifier la gestion des droits et des spécificités. En effet, celles-ci sont gérées directement au niveau d’une base class dont héritent tous les contrôleurs appartenant à ce namespace.</p><p>Un cas fréquent est le namespace admin :</p><pre>class Admin::BaseController &lt; ApplicationController<br>  layout &#39;admin/application&#39;<br>  before_action :check_user_role</pre><pre>  private</pre><pre>  def check_user_role<br>    redirect_to root_path unless current_user.has_role?(:admin)<br>  end</pre><pre>end</pre><h4>Pas de variable globale dans les contrôleurs</h4><p>Cette règle a été inspirée par les articles du <a href="http://blog.arkency.com/">blog d’Arkency</a> et notamment le livre <a href="http://rails-refactoring.com/">Fearless Refactoring</a>.</p><p>Plutôt que de compter sur des variables d’instance au niveau des vues, l’idée est d’appeler la vue en passant explicitement les variables qui seront utilisées dans la vue. Ainsi, on passe de ça :</p><pre>class AccountsController &lt; ApplicationController</pre><pre>  def index<br>    @accounts = Account.all.ordered.page(params[:page]).per(50)<br>  end</pre><pre>end</pre><p>à ça :</p><pre>class AccountsController &lt; ApplicationController</pre><pre>  def index<br>    render :index, locals: {<br>      accounts: Account.all.ordered.page(params[:page]).per(50)<br>    }<br>  end</pre><pre>end</pre><p>L’intérêt n’est pas forcément évident à première vue, surtout dans un exemple simple comme celui-ci. Pourtant, en explicitant les variables qui sont exposées à la vue, on se facilite les futurs refactoring : on n’est plus obligé de tracker quelles variables sont utilisées dans la vue (qui auraient pu être déclarées dans un contrôleur parent) et on sait explicitement ce qui est utilisé.</p><pre>def new<br>  render :new, locals: { article: ArticleForm.new(account) }<br>end</pre><pre>def create<br>  article_form = ArticleForm.new(account)</pre><pre>  if article_form.validate(params[:article])<br>    article_form.save<br>    redirect_to account_articles_path<br>  else<br>    render :new, locals: { article: article_form }<br>  end<br>end</pre><h3>Règles pour les vues</h3><h4>Des décorateurs pour les vues</h4><p>Au niveau des vues, les décorateurs ont vraiment eu un impact positif sur l’organisation du code car ils permettent d’isoler les méthodes spécifiquement dédiées aux vues. Nous utilisons la gem <a href="https://github.com/drapergem/draper">Draper</a> pour cela.</p><p>Et cela permet également de simplifier les vues et d’introduire des méthodes réutilisables dans plusieurs vues ou partials.</p><pre>class OrderDecorator &lt; ApplicationDecorator</pre><pre>  delegate_all<br> <br>  def created_at<br>    if object.created_at<br>       h.l(object.created_at, format: :date)<br>    else<br>     &#39;-&#39;<br>    end<br>  end</pre><pre>  def customer_link<br>    h.link_to(<br>      object.customer,<br>      h.account_customer_path(object.customer),<br>      class: ‘secondary-link’<br>    )<br>  end<br> <br>end</pre><p>Je serais ravi d’avoir vos retours d’expériences sur ces règles. Si vous en avez déjà implémenté certaines et si cela a fonctionné pour vous ou si vous gérez les problématiques que j’expose de façon différente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d29965618630" width="1" height="1" alt=""><hr><p><a href="https://medium.com/imenlo/ruby-on-rails-the-imenlo-way-d29965618630">Ruby on Rails, the iMenlo way</a> was originally published in <a href="https://medium.com/imenlo">iMenlo</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>