{"id":7880,"date":"2020-11-12T00:00:00","date_gmt":"2020-11-11T23:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7880"},"modified":"2024-11-06T15:54:47","modified_gmt":"2024-11-06T14:54:47","slug":"rails-nest-pas-simple","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple","title":{"rendered":"Rails n&rsquo;est pas simple\u00a0!"},"content":{"rendered":"<p><em>Article \u00e9crit par Fran\u00e7ois Vantomme<\/em><\/p>\n<p>Consid\u00e9rons ceci\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">User<\/span><span class=\"p\">.<\/span><span class=\"nf\">create<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">[<\/span><span class=\"ss\">:user<\/span><span class=\"p\">])<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>La ligne de code ci-dessus n\u2019est pas <strong>simple<\/strong>. Elle est facile \u00e0 \u00e9crire, mais il r\u00e9side une grande complexit\u00e9 dans le code qui se cache derri\u00e8re\u00a0:<\/p>\n<ul>\n<li>les param\u00e8tres devront souvent passer par des coercions sp\u00e9cifiques \u00e0 la base de donn\u00e9es\u00a0;<\/li>\n<li>les param\u00e8tres devront \u00eatre valid\u00e9s\u00a0;<\/li>\n<li>les param\u00e8tres peuvent \u00eatre modifi\u00e9s par des <em>callbacks<\/em>, pouvant occasionnellement causer des effets de bords\u00a0;<\/li>\n<li>des param\u00e8tres invalides conduisent \u00e0 la g\u00e9n\u00e9ration de messages d\u2019erreur qui d\u00e9pendent d\u2019une externalit\u00e9 (ex\u00a0: I18n)\u00a0;<\/li>\n<li>des param\u00e8tres valides d\u00e9coulera l\u2019instanciation d\u2019un objet, potentiellement accompagn\u00e9e d\u2019autres objets associ\u00e9s\u00a0;<\/li>\n<li>un objet, voire tout une grappe d\u2019objets seront stock\u00e9s en base de donn\u00e9es.<\/li>\n<\/ul>\n<p>Tel est le constat fait par Piotr Solnica (a.k.a Solnic) sur son blog <a href=\"https:\/\/solnic.codes\/2016\/05\/22\/my-time-with-rails-is-up\/\">dans un billet de 2016<\/a>.<\/p>\n<p>R\u00e9sumons-nous\u00a0et \u00e9vitons toute confusion entre \u00ab\u00a0simple\u00a0\u00bb et \u00ab\u00a0facile\u00a0\u00bb\u00a0:<\/p>\n<p><strong>Simple<\/strong>\u00a0: une ligne de code qui fait une seule petite chose tr\u00e8s sp\u00e9cifique.<\/p>\n<p><strong>Facile<\/strong>\u00a0: une ligne de code qui en fait beaucoup en faisant appel \u00e0 une m\u00e9thode du framework et r\u00e9sultant en l\u2019ex\u00e9cution d\u2019un millier de lignes de code.<\/p>\n<p>Ruby on Rails a \u00e9t\u00e9 pens\u00e9 pour \u00eatre facile \u00e0 utiliser. Ce qui est tr\u00e8s pratique pour un POC ou un petit projet. Mais cela manque clairement de s\u00e9paration des responsabilit\u00e9s \u2014\u00a0comme on a pu le constater avec l\u2019exemple ci-dessus\u00a0\u2014, ce qui est dommageable quand le projet commence \u00e0 grossir, car en cr\u00e9ant du couplage, le code devient alors plus difficile \u00e0 maintenir, \u00e0 tester et \u00e0 faire \u00e9voluer.<\/p>\n<h2 id=\"repenser-son-architecture\">Repenser son architecture<\/h2>\n<p>Une bonne architecture de projet sera votre meilleure alli\u00e9e aussi longtemps que vivra et \u00e9voluera votre application. Notre pr\u00e9c\u00e9dent article sur DRY (<em>don\u2019t repeat yourself<\/em>) ne vous aura pas \u00e9chapp\u00e9. Il s\u2019agit ici d\u2019appliquer ce principe \u00e0 l\u2019\u00e9chelle non plus d\u2019un projet, mais d\u2019une \u00e9quipe. Partager des conventions d\u2019architecture \u00e0 l\u2019\u00e9chelle d\u2019une \u00e9quipe, entre vos diff\u00e9rents projets, est d\u2019autant plus b\u00e9n\u00e9fique que cela en facilitera la prise en main tout en assurant \u00e0 votre projet une maintenabilit\u00e9, une \u00e9volutivit\u00e9 et une testabilit\u00e9 accrues.<\/p>\n<p>Rails propose en standard une architecture dite MVC (<em>Model, Vue, Controller<\/em>). Celle-ci s\u2019av\u00e8re ais\u00e9e \u00e0 prendre en main, pour autant, elle montre tr\u00e8s rapidement ses limites d\u00e8s que le projet commence \u00e0 s\u2019\u00e9toffer.<\/p>\n<blockquote><p>As everything with Rails, it was \u201cnice and easy in the beginning\u201d and then it would turn into unmaintainable crap.<br \/>\n\u2014 Piotr Solnica, 2016<\/p><\/blockquote>\n<p>Ce que je vous propose ici, c\u2019est d\u2019affiner cette architecture en lui apportant quelques notions librement inspir\u00e9es d\u2019autres \u00e9coles de pens\u00e9e. Pour bien comprendre vers quoi je veux vous mener, rien de tel qu\u2019un petit sch\u00e9ma\u00a0!<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/f.hubspotusercontent20.net\/hubfs\/5437879\/dry-rails.png\" alt=\"DryRails@2x.png\" loading=\"lazy\" \/><\/p>\n<p>Comme vous pouvez le constater, cela consiste principalement en un d\u00e9coupage plus fin des responsabilit\u00e9s entre les couches mod\u00e8le (<em>model<\/em>) et contr\u00f4leur (<em>controller<\/em>).<\/p>\n<p><strong>Le saviez-vous\u00a0?<\/strong> L\u2019architecture MVC a \u00e9t\u00e9 \u00e9labor\u00e9e dans les ann\u00e9es 1970 par Trygve Reenskaug pour Smalltalk-79 et ne s\u2019appliquait non pas \u00e0 un \u00e9cran entier, mais \u00e0 chacun de ses composants\u00a0! Chaque bouton, chaque <em>input<\/em> avait son mod\u00e8le, sa vue et son contr\u00f4leur qui lui \u00e9taient propres. [<a href=\"https:\/\/en.wikipedia.org\/wiki\/Model%E2%80%93view%E2%80%93controller\">MVC<\/a>]<\/p>\n<p>D\u00e9taillons ensemble ces diff\u00e9rentes notions, en commen\u00e7ant par la plus structurante mais trop souvent oubli\u00e9e\u00a0: les domaines.<\/p>\n<h3 id=\"domaines\">Domaines<\/h3>\n<p>Dans <a href=\"https:\/\/www.youtube.com\/watch?v=WpkDN78P884\">une conf\u00e9rence donn\u00e9e par Robert Martin<\/a> (a.k.a Uncle Bob) \u00e0 Ruby Midwest en 2011, il posait la question suivante apr\u00e8s avoir jet\u00e9 un \u0153il \u00e0 l\u2019arborescence d\u2019un projet\u00a0:<\/p>\n<blockquote><p>Hmm\u2026 it looks like a Rails app. Why should the top level directory structure communicate that information to you\u00a0? What does this application do\u00a0?<br \/>\n\u2014 Robert Martin, 2011<\/p><\/blockquote>\n<p>Et de poursuivre\u00a0:<\/p>\n<blockquote><p>The most visible level, the level that everybody goes to first\u00a0: nothing here talks about what this application does\u00a0! [\u2026] So apparently, the most important thing about this application is the framework upon which it is built.<br \/>\n\u2014 Robert Martin, 2011<\/p><\/blockquote>\n<p>Or, lorsqu\u2019on regarde un plan dessin\u00e9 par un architecte qu\u2019y voit-on\u00a0? Une grande entr\u00e9e, de nombreuses \u00e9tag\u00e8res, des tables au centre\u2026 on dirait bien une biblioth\u00e8que\u00a0! Le premier niveau de lecture nous informe tout de suite qu\u2019il s\u2019agit d\u2019une biblioth\u00e8que, et non pas d\u2019une construction en b\u00e9ton. D\u2019un seul coup d\u2019\u0153il, on comprend \u00e0 quel besoin r\u00e9pond ce b\u00e2timent.<\/p>\n<p>Ainsi, les domaines (<em>domains<\/em>) servent \u00e0 d\u00e9limiter les diff\u00e9rents aspects m\u00e9tiers de l\u2019application. Ils d\u00e9finissent l\u2019arborescence de notre projet pour tout ce qui a trait \u00e0 la mod\u00e9lisation du besoin exprim\u00e9 par le M\u00e9tier.<\/p>\n<p><strong>Note<\/strong>\u00a0: ce que je nomme ici le M\u00e9tier \u2014 avec une majuscule\u00a0\u2014 ce sont les interlocuteurs qui ensemble ont une connaissance fine du besoin que tente d\u2019adresser l\u2019application.<\/p>\n<pre><code>app\/domain\/ \u251c\u2500\u2500 customer\/ \u2502\u00a0\u00a0 \u251c\u2500\u2500 contracts\/ \u2502\u00a0\u00a0 \u251c\u2500\u2500 entities\/ \u2502\u00a0\u00a0 \u251c\u2500\u2500 repositories\/ \u2502\u00a0\u00a0 \u251c\u2500\u2500 services\/ \u2502\u00a0\u00a0 \u2514\u2500\u2500 use_cases\/ \u2514\u2500\u2500 security\/     \u251c\u2500\u2500 entities\/     \u251c\u2500\u2500 repositories\/     \u2514\u2500\u2500 use_cases\/ <\/code><\/pre>\n<h3 id=\"contrats\">Contrats<\/h3>\n<p>L\u2019entr\u00e9e au sein d\u2019un domaine se fait dans le respect d\u2019un contrat (<em>contract<\/em>). Celui-ci \u00e9tablit la nature des donn\u00e9es attendues en entr\u00e9e par le cas d\u2019usage (<em>use case<\/em>) que l\u2019on souhaite adresser. Si le contrat n\u2019est pas respect\u00e9, une erreur d\u00e9taillant les raisons du refus sera imm\u00e9diatement retourn\u00e9e au contr\u00f4leur (<em>controller<\/em>), sans poursuivre plus avant.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Customer<\/span>   <span class=\"k\">module<\/span> <span class=\"nn\">Contracts<\/span>     <span class=\"k\">class<\/span> <span class=\"nc\">ListEmails<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">MyApp<\/span><span class=\"o\">::<\/span><span class=\"no\">ApplicationContract<\/span>       <span class=\"n\">params<\/span> <span class=\"k\">do<\/span>         <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:page<\/span><span class=\"p\">).<\/span><span class=\"nf\">hash<\/span> <span class=\"k\">do<\/span>           <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:number<\/span><span class=\"p\">).<\/span><span class=\"nf\">value<\/span><span class=\"p\">(<\/span><span class=\"ss\">:integer<\/span><span class=\"p\">,<\/span> <span class=\"ss\">gt?: <\/span><span class=\"mi\">0<\/span><span class=\"p\">)<\/span>           <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:size<\/span><span class=\"p\">).<\/span><span class=\"nf\">value<\/span><span class=\"p\">(<\/span><span class=\"ss\">:integer<\/span><span class=\"p\">,<\/span> <span class=\"ss\">gt?: <\/span><span class=\"mi\">0<\/span><span class=\"p\">)<\/span>         <span class=\"k\">end<\/span>          <span class=\"n\">optional<\/span><span class=\"p\">(<\/span><span class=\"ss\">:filter<\/span><span class=\"p\">).<\/span><span class=\"nf\">hash<\/span> <span class=\"k\">do<\/span>           <span class=\"n\">optional<\/span><span class=\"p\">(<\/span><span class=\"ss\">:subject<\/span><span class=\"p\">).<\/span><span class=\"nf\">filled<\/span><span class=\"p\">(<\/span><span class=\"ss\">:string<\/span><span class=\"p\">)<\/span>           <span class=\"n\">optional<\/span><span class=\"p\">(<\/span><span class=\"ss\">:recipient<\/span><span class=\"p\">).<\/span><span class=\"nf\">filled<\/span><span class=\"p\">(<\/span><span class=\"ss\">:string<\/span><span class=\"p\">)<\/span>         <span class=\"k\">end<\/span>       <span class=\"k\">end<\/span>        <span class=\"n\">rule<\/span><span class=\"p\">(<\/span><span class=\"ss\">:recipient<\/span><span class=\"p\">)<\/span> <span class=\"k\">do<\/span>         <span class=\"n\">key<\/span><span class=\"p\">.<\/span><span class=\"nf\">failure<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"has invalid format\"<\/span><span class=\"p\">)<\/span> <span class=\"k\">unless<\/span> <span class=\"sr\">\/@\/<\/span><span class=\"p\">.<\/span><span class=\"nf\">match?<\/span><span class=\"p\">(<\/span><span class=\"n\">value<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ainsi, les contrats agissent comme des sas de d\u00e9contamination\u00a0: tout ce qui respecte ledit contrat est de fait consid\u00e9r\u00e9 comme digne de confiance. D\u00e8s lors, le code m\u00e9tier est \u00e9pur\u00e9 de tout code d\u00e9fensif, devenu inutile au-del\u00e0 de ce sas.<\/p>\n<h3 id=\"cas-dusage\">Cas d\u2019Usage<\/h3>\n<p>Le contrat respect\u00e9, les donn\u00e9es sont transmises au cas d\u2019usage (<em>use case<\/em>) afin de proc\u00e9der \u00e0 son ex\u00e9cution. Un cas d\u2019usage repr\u00e9sente un sc\u00e9nario \u00e9l\u00e9mentaire, par exemple, \u00ab\u00a0lister les adresses d\u2019un client\u00a0\u00bb ou \u00ab\u00a0ajouter un produit au panier\u00a0\u00bb. Un cas d\u2019usage pourra ainsi faire appel \u00e0 un service (<em>service<\/em>), \u00e0 des r\u00e9pertoires (<em>repositories<\/em>), et manipulera des entit\u00e9s (<em>entities<\/em>) qui seront retourn\u00e9es encapsul\u00e9es dans une structure <code>Result::Success<\/code> en cas de succ\u00e8s. Dans le cas contraire, une structure <code>Result::Failure<\/code> sera retourn\u00e9e, pr\u00e9cisant la raison de l\u2019\u00e9chec. Le r\u00e9sultat ainsi structur\u00e9 de l\u2019ex\u00e9cution du cas d\u2019usage nous garantit un traitement facilit\u00e9 de celui-ci par le contr\u00f4leur.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Customer<\/span>   <span class=\"k\">module<\/span> <span class=\"nn\">UseCases<\/span>     <span class=\"k\">class<\/span> <span class=\"nc\">GetEmail<\/span>       <span class=\"kp\">include<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Monads<\/span><span class=\"p\">[<\/span><span class=\"ss\">:result<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:do<\/span><span class=\"p\">]<\/span>       <span class=\"kp\">include<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Matcher<\/span><span class=\"o\">::<\/span><span class=\"no\">ResultMatcher<\/span><span class=\"p\">.<\/span><span class=\"nf\">for<\/span><span class=\"p\">(<\/span><span class=\"ss\">:call<\/span><span class=\"p\">)<\/span>       <span class=\"kp\">include<\/span> <span class=\"no\">MyApp<\/span><span class=\"o\">::<\/span><span class=\"no\">Deps<\/span><span class=\"p\">[<\/span><span class=\"ss\">sent_emails_repo: <\/span><span class=\"s2\">\"customer.repositories.sent_emails\"<\/span><span class=\"p\">,<\/span>                           <span class=\"ss\">contract: <\/span><span class=\"s2\">\"customer.contracts.get_email\"<\/span><span class=\"p\">]<\/span>        <span class=\"k\">def<\/span> <span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span> <span class=\"o\">=<\/span> <span class=\"p\">{})<\/span>         <span class=\"n\">validate<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">).<\/span><span class=\"nf\">bind<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">params<\/span><span class=\"o\">|<\/span>           <span class=\"n\">email_uid<\/span> <span class=\"o\">=<\/span> <span class=\"n\">params<\/span><span class=\"p\">[<\/span><span class=\"ss\">:uid<\/span><span class=\"p\">]<\/span>           <span class=\"n\">email<\/span> <span class=\"o\">=<\/span> <span class=\"n\">sent_emails_repo<\/span><span class=\"p\">.<\/span><span class=\"nf\">get_by_uid<\/span><span class=\"p\">(<\/span><span class=\"n\">uid<\/span><span class=\"p\">)<\/span>            <span class=\"k\">if<\/span> <span class=\"n\">email<\/span>             <span class=\"no\">Success<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>           <span class=\"k\">else<\/span>             <span class=\"no\">Failure<\/span><span class=\"p\">([<\/span><span class=\"ss\">:resource_not_found<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"Email with uid <\/span><span class=\"si\">#{<\/span><span class=\"n\">uid<\/span><span class=\"si\">}<\/span><span class=\"s2\"> not found\"<\/span><span class=\"p\">])<\/span>           <span class=\"k\">end<\/span>         <span class=\"k\">end<\/span>       <span class=\"k\">end<\/span>        <span class=\"kp\">private<\/span>        <span class=\"k\">def<\/span> <span class=\"nf\">validate<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">)<\/span>         <span class=\"n\">validation<\/span> <span class=\"o\">=<\/span> <span class=\"n\">contract<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">)<\/span>          <span class=\"k\">if<\/span> <span class=\"n\">validation<\/span><span class=\"p\">.<\/span><span class=\"nf\">success?<\/span>           <span class=\"no\">Success<\/span><span class=\"p\">(<\/span><span class=\"n\">validation<\/span><span class=\"p\">.<\/span><span class=\"nf\">to_h<\/span><span class=\"p\">)<\/span>         <span class=\"k\">else<\/span>           <span class=\"no\">Failure<\/span><span class=\"p\">([<\/span><span class=\"ss\">:validation_error<\/span><span class=\"p\">,<\/span> <span class=\"n\">validation<\/span><span class=\"p\">.<\/span><span class=\"nf\">errors<\/span><span class=\"p\">.<\/span><span class=\"nf\">to_h<\/span><span class=\"p\">]<\/span>         <span class=\"k\">end<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Sans nous attarder sur l\u2019impl\u00e9mentation technique qu\u2019on abordera en seconde partie d\u2019article, remarquons que l\u2019on retrouve ici quelques notions d\u00e9j\u00e0 \u00e9voqu\u00e9es dans des articles pr\u00e9c\u00e9dents, telles que l\u2019injection de d\u00e9pendance, le <em>pattern matching<\/em> ou encore le <a href=\"https:\/\/www.synbioz.com\/blog\/tech\/peregrinations-vers-une-architecture-decouplee\">d\u00e9couplage<\/a>, fil rouge de ce billet.<\/p>\n<h3 id=\"services\">Services<\/h3>\n<p>Un service (<em>service<\/em>) ressemble peu ou prou \u00e0 un cas d\u2019usage, \u00e0 ceci pr\u00e8s qu\u2019il n\u2019est pas appel\u00e9 par un contr\u00f4leur mais par un cas d\u2019usage ou un autre service. On se trouve au sein du domaine, en zone de confiance, nous avons pleine ma\u00eetrise des donn\u00e9es d\u2019entr\u00e9e du service\u00a0: ainsi, nul besoin de les garantir par un contrat.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Customer<\/span>   <span class=\"k\">module<\/span> <span class=\"nn\">Services<\/span>     <span class=\"k\">class<\/span> <span class=\"nc\">SendEmail<\/span>       <span class=\"kp\">include<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">::<\/span><span class=\"no\">Monads<\/span><span class=\"p\">[<\/span><span class=\"ss\">:result<\/span><span class=\"p\">]<\/span>       <span class=\"kp\">include<\/span> <span class=\"no\">MyApp<\/span><span class=\"o\">::<\/span><span class=\"no\">Deps<\/span><span class=\"p\">[<\/span><span class=\"ss\">sent_emails_repo: <\/span><span class=\"s2\">\"customer.repositories.sent_emails\"<\/span><span class=\"p\">]<\/span>        <span class=\"k\">def<\/span> <span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>         <span class=\"no\">SimpleMailer<\/span><span class=\"p\">.<\/span><span class=\"nf\">with<\/span><span class=\"p\">(<\/span>           <span class=\"ss\">recipients: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">recipients<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">subject: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">subject<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">body: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">body<\/span>         <span class=\"p\">).<\/span><span class=\"nf\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">deliver_now<\/span>          <span class=\"n\">email<\/span> <span class=\"o\">=<\/span> <span class=\"n\">sent_emails_repo<\/span><span class=\"p\">.<\/span><span class=\"nf\">persist!<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>          <span class=\"no\">Success<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Besoin de faire appel \u00e0 un syst\u00e8me externe\u00a0? De g\u00e9n\u00e9rer un code r\u00e9pondant \u00e0 des contraintes du M\u00e9tier\u00a0? D\u2019impl\u00e9menter un comportement qui peut \u00eatre mutualis\u00e9\u00a0? Pensez \u00e0 isoler cela dans un service\u00a0! Pour faire \u00e9cho \u00e0 l\u2019article duplication ou co\u00efncidence, chaque besoin exprim\u00e9 par le M\u00e9tier devra trouver corps dans une impl\u00e9mentation unique et non ambigu\u00eb, faisant autorit\u00e9 \u00e0 travers toute l\u2019application.<\/p>\n<h3 id=\"rpertoires\">R\u00e9pertoires<\/h3>\n<p>Les r\u00e9pertoires (<em>repositories<\/em>) sont une passerelle entre la repr\u00e9sentation m\u00e9tier des donn\u00e9es \u2014\u00a0les entit\u00e9s\u00a0\u2014 et leur persistance. Seuls les r\u00e9pertoires ont la responsabilit\u00e9 de construire une entit\u00e9, de la persister, de l\u2019effacer\u2026 bref. Contrairement \u00e0 un projet Rails classique, la structure de la base de donn\u00e9es n\u2019impacte pas la mod\u00e9lisation des entit\u00e9s que l\u2019on manipule.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Customer<\/span>   <span class=\"k\">module<\/span> <span class=\"nn\">Repositories<\/span>     <span class=\"k\">class<\/span> <span class=\"nc\">SentEmails<\/span>       <span class=\"k\">def<\/span> <span class=\"nf\">persist!<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>         <span class=\"n\">record<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Email<\/span><span class=\"p\">.<\/span><span class=\"nf\">create!<\/span><span class=\"p\">(<\/span>           <span class=\"ss\">uid: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">uid<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">body: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">body<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">subject: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">subject<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">workflow: <\/span><span class=\"n\">workflow<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">recipients: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">recipients<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">sent: <\/span><span class=\"kp\">true<\/span>         <span class=\"p\">)<\/span>          <span class=\"no\">Mapper<\/span><span class=\"p\">.<\/span><span class=\"nf\">from_record<\/span><span class=\"p\">(<\/span><span class=\"n\">record<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>        <span class=\"kp\">private<\/span>        <span class=\"k\">class<\/span> <span class=\"nc\">Mapper<\/span>         <span class=\"k\">def<\/span> <span class=\"nc\">self<\/span><span class=\"o\">.<\/span><span class=\"nf\">from_record<\/span><span class=\"p\">(<\/span><span class=\"n\">record<\/span><span class=\"p\">)<\/span>           <span class=\"no\">Customer<\/span><span class=\"o\">::<\/span><span class=\"no\">Entities<\/span><span class=\"o\">::<\/span><span class=\"no\">SentEmail<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span>             <span class=\"ss\">internal_id: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">id<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">uid: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">uid<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">body: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">body<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">subject: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">subject<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">recipients: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">recipients<\/span>           <span class=\"p\">)<\/span>         <span class=\"k\">end<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>De plus, tout en pr\u00e9sentant une interface similaire \u00e0 celle des autres r\u00e9pertoires, il se peut qu\u2019un r\u00e9pertoire interroge en toute transparence une API, un fichier, ou la m\u00e9moire, plut\u00f4t que la base de donn\u00e9es de l\u2019application.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Customer<\/span>   <span class=\"k\">module<\/span> <span class=\"nn\">Repositories<\/span>     <span class=\"k\">class<\/span> <span class=\"nc\">InMemorySentEmails<\/span>       <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span>         <span class=\"vi\">@store<\/span> <span class=\"o\">=<\/span> <span class=\"p\">{}<\/span>       <span class=\"k\">end<\/span>        <span class=\"k\">def<\/span> <span class=\"nf\">persist!<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>         <span class=\"n\">record<\/span> <span class=\"o\">=<\/span> <span class=\"vi\">@store<\/span><span class=\"p\">[<\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">uid<\/span><span class=\"p\">]<\/span> <span class=\"o\">=<\/span> <span class=\"p\">{<\/span>           <span class=\"ss\">uid: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">uid<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">body: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">body<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">subject: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">subject<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">recipients: <\/span><span class=\"n\">email<\/span><span class=\"p\">.<\/span><span class=\"nf\">recipients<\/span><span class=\"p\">,<\/span>           <span class=\"ss\">sent: <\/span><span class=\"kp\">true<\/span>         <span class=\"p\">}<\/span>          <span class=\"no\">Mapper<\/span><span class=\"p\">.<\/span><span class=\"nf\">from_record<\/span><span class=\"p\">(<\/span><span class=\"n\">record<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>        <span class=\"k\">class<\/span> <span class=\"nc\">Mapper<\/span>         <span class=\"k\">def<\/span> <span class=\"nc\">self<\/span><span class=\"o\">.<\/span><span class=\"nf\">from_record<\/span><span class=\"p\">(<\/span><span class=\"n\">record<\/span><span class=\"p\">)<\/span>           <span class=\"no\">Customer<\/span><span class=\"o\">::<\/span><span class=\"no\">Entities<\/span><span class=\"o\">::<\/span><span class=\"no\">SentEmail<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span>             <span class=\"ss\">uid: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">uid<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">body: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">body<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">subject: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">subject<\/span><span class=\"p\">,<\/span>             <span class=\"ss\">recipients: <\/span><span class=\"n\">record<\/span><span class=\"p\">.<\/span><span class=\"nf\">recipients<\/span>           <span class=\"p\">)<\/span>         <span class=\"k\">end<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Tout bien consid\u00e9r\u00e9e, la base de donn\u00e9es n\u2019est qu\u2019un d\u00e9tail. Ce n\u2019est pas le c\u0153ur du besoin exprim\u00e9, juste une incidence technique. R\u00e9duire le couplage avec celle-ci nous permet de nous en abstraire, voire d\u2019en changer, ais\u00e9ment.<\/p>\n<h3 id=\"entits\">Entit\u00e9s<\/h3>\n<p>Comme \u00e9nonc\u00e9 ci-dessus, une entit\u00e9 (<em>entity<\/em>) est la repr\u00e9sentation, au sein d\u2019un domaine et du point de vue du M\u00e9tier, d\u2019une brique \u00e9l\u00e9mentaire de l\u2019application. Elle repr\u00e9sente quelque chose que le M\u00e9tier peut toucher du doigt et doit de pr\u00e9f\u00e9rence r\u00e9pondre \u00e0 une nomenclature d\u00e9finie avec celui-ci.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Customer<\/span>   <span class=\"k\">module<\/span> <span class=\"nn\">Entities<\/span>     <span class=\"k\">class<\/span> <span class=\"nc\">SentEmail<\/span>       <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"o\">**<\/span><span class=\"n\">kwargs<\/span><span class=\"p\">)<\/span>         <span class=\"n\">attrs<\/span> <span class=\"o\">=<\/span> <span class=\"n\">kwargs<\/span><span class=\"p\">.<\/span><span class=\"nf\">symbolize_keys<\/span>         <span class=\"vi\">@internal_id<\/span> <span class=\"o\">=<\/span> <span class=\"n\">attrs<\/span><span class=\"p\">[<\/span><span class=\"ss\">:internal_id<\/span><span class=\"p\">]<\/span>         <span class=\"vi\">@uid<\/span> <span class=\"o\">=<\/span> <span class=\"n\">attrs<\/span><span class=\"p\">[<\/span><span class=\"ss\">:uid<\/span><span class=\"p\">]<\/span>         <span class=\"vi\">@body<\/span> <span class=\"o\">=<\/span> <span class=\"n\">attrs<\/span><span class=\"p\">[<\/span><span class=\"ss\">:body<\/span><span class=\"p\">]<\/span>         <span class=\"vi\">@subject<\/span> <span class=\"o\">=<\/span> <span class=\"n\">attrs<\/span><span class=\"p\">[<\/span><span class=\"ss\">:subject<\/span><span class=\"p\">]<\/span>         <span class=\"vi\">@recipients<\/span> <span class=\"o\">=<\/span> <span class=\"n\">attrs<\/span><span class=\"p\">[<\/span><span class=\"ss\">:recipients<\/span><span class=\"p\">]<\/span>       <span class=\"k\">end<\/span>        <span class=\"nb\">attr_reader<\/span> <span class=\"ss\">:internal_id<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:uid<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:body<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:recipients<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:subject<\/span>        <span class=\"k\">def<\/span> <span class=\"nf\">sent?<\/span>         <span class=\"kp\">true<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ainsi, et en totale ind\u00e9pendance du mode de persistance choisi, les entit\u00e9s nous servent \u00e0 manipuler les notions et concepts n\u00e9cessaires pour r\u00e9pondre au besoin exprim\u00e9 par le M\u00e9tier. Il est entendu que chaque entit\u00e9 est contenue et se limite \u00e0 un domaine pr\u00e9cis. Ce faisant, pour reprendre un exemple classique, un produit dans un catalogue et ce m\u00eame produit dans une ligne de facturation se mod\u00e9liseront diff\u00e9remment selon leur domaine respectif, ne pr\u00e9sentant que ce qu\u2019il y a de pertinent dans le contexte dans lequel ces entit\u00e9s seront employ\u00e9es.<\/p>\n<h3 id=\"modles\">Mod\u00e8les<\/h3>\n<p>Les mod\u00e8les (<em>models<\/em>) <code>ActiveRecord<\/code> sont r\u00e9duits \u00e0 leur strict minimum. Aucun code m\u00e9tier puisqu\u2019on est ici en dehors d\u2019un domaine. Il s\u2019agit simplement d\u2019une mod\u00e9lisation de la structure de la base de donn\u00e9es de l\u2019application. On peut \u00e0 la rigueur y trouver quelques <code>scopes<\/code> pour aider au requ\u00eatage au sein des r\u00e9pertoires, ou la d\u00e9claration d\u2019un <code>enum<\/code>. Mais dans la majorit\u00e9 des cas, on se contentera de d\u00e9clarer une classe h\u00e9ritant d\u2019<code>ApplicationRecord<\/code>, la magie de Rails et d\u2019ActiveRecord op\u00e8rera.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Email<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">ApplicationRecord<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"contrleurs\">Contr\u00f4leurs<\/h3>\n<p>Les contr\u00f4leurs (<em>controllers<\/em>) ont eux aussi un r\u00f4le limit\u00e9. Ils servent \u00e0 l\u2019aiguillage. Un contr\u00f4leur appel un cas d\u2019usage et en fonction du retour de ce dernier (<code>Result::Success<\/code> ou <code>Result::Failure<\/code>), fera tel ou tel rendu, avec ou sans message d\u2019erreur selon le cas. Les donn\u00e9es retourn\u00e9es par le contr\u00f4leur seront pr\u00e9alablement s\u00e9rialis\u00e9es afin de correspondre aux attentes de la vue ou du consommateur de l\u2019API.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">EmailsController<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">ApplicationController<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">template<\/span>     <span class=\"n\">resolve<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"customer.use_cases.get_email_template\"<\/span><span class=\"p\">).<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">.<\/span><span class=\"nf\">to_h<\/span><span class=\"p\">)<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">m<\/span><span class=\"o\">|<\/span>       <span class=\"n\">m<\/span><span class=\"p\">.<\/span><span class=\"nf\">success<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">email<\/span><span class=\"o\">|<\/span>         <span class=\"n\">render<\/span> <span class=\"ss\">json: <\/span><span class=\"no\">EmailSerializer<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">).<\/span><span class=\"nf\">as_json<\/span>       <span class=\"k\">end<\/span>        <span class=\"n\">m<\/span><span class=\"p\">.<\/span><span class=\"nf\">failure<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">error<\/span><span class=\"o\">|<\/span>         <span class=\"n\">handle_error<\/span><span class=\"p\">(<\/span><span class=\"n\">error<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"srialisation\">S\u00e9rialisation<\/h3>\n<p>La s\u00e9rialisation permet l\u2019interface entre les donn\u00e9es servies au contr\u00f4leur par le domaine et la structure de donn\u00e9es que l\u2019on souhaite pr\u00e9senter au consommateur de l\u2019API ou \u00e0 la vue.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">EmailSerializer<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">initialize<\/span><span class=\"p\">(<\/span><span class=\"n\">email<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@email<\/span> <span class=\"o\">=<\/span> <span class=\"n\">email<\/span>   <span class=\"k\">end<\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">as_json<\/span>     <span class=\"p\">{<\/span>       <span class=\"ss\">body: <\/span><span class=\"vi\">@email<\/span><span class=\"p\">.<\/span><span class=\"nf\">body<\/span><span class=\"p\">,<\/span>       <span class=\"ss\">subject: <\/span><span class=\"vi\">@email<\/span><span class=\"p\">.<\/span><span class=\"nf\">subject<\/span><span class=\"p\">,<\/span>       <span class=\"ss\">recipients: <\/span><span class=\"vi\">@email<\/span><span class=\"p\">.<\/span><span class=\"nf\">recipients<\/span>     <span class=\"p\">}<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>On peut, si on le souhaite, distinguer s\u00e9rialisation (<em>serializer<\/em>) et pr\u00e9sentation (<em>presenter<\/em>) selon que l\u2019on cible respectivement un consommateur d\u2019API ou une vue.<\/p>\n<p>En v\u00e9rit\u00e9, vous \u00eates libres de vous doter des outils et concepts qui \u0153uvreront \u00e0 clarifier votre base de code, vous aide \u00e0 la maintenir et \u00e0 la faire \u00e9voluer sans peine. La cl\u00e9 d\u2019une architecture r\u00e9ussie r\u00e9side dans une approche incr\u00e9mentale et inclusive\u00a0: \u00e9vitez \u00e0 tout prix de vouloir mettre en place trop de concepts mal maitris\u00e9s. Dosez. Et accompagnez les membres de l\u2019\u00e9quipe et nouveaux arrivants de mani\u00e8re \u00e0 ce que chacun s\u2019approprie les outils \u00e0 sa disposition.<\/p>\n<h2 id=\"avantages\">Avantages<\/h2>\n<h3 id=\"diffrer-les-dcisions\">Diff\u00e9rer les d\u00e9cisions<\/h3>\n<blockquote><p>A good architecture maximizes the number of decisions NOT made.<br \/>\n\u2014 Uncle Bob<\/p><\/blockquote>\n<p>L\u2019architecture propos\u00e9e ici nous permet de concentrer nos efforts sur le besoin exprim\u00e9 plut\u00f4t que sur des choix techniques. Doit-on utiliser une base de donn\u00e9es relationnelle ou noSQL\u00a0? Plut\u00f4t PostgreSQL ou MySQL\u00a0? Peu importe, la base de donn\u00e9es est un d\u00e9tail, isolez-la\u00a0!, nous dit Uncle Bob. Commen\u00e7ons par exemple par une persistance en m\u00e9moire et nous aviserons ensuite, \u00e0 mesure que les contraintes techniques se pr\u00e9cisent. En effet, gr\u00e2ce \u00e0 la pr\u00e9sence de r\u00e9pertoires qui font l\u2019interface entre les entit\u00e9s et leur persistance, il est tr\u00e8s facile d\u2019en substituer un par un autre.<\/p>\n<p>En fait, chacune des notions ici pr\u00e9sent\u00e9es a des responsabilit\u00e9s tr\u00e8s limit\u00e9es et participe de la r\u00e9duction du couplage dans notre application. Il est d\u00e8s lors tr\u00e8s simple de remplacer, d\u2019alt\u00e9rer, de simuler le comportement de l\u2019un des composants de cette architecture.<\/p>\n<h3 id=\"test\">Test<\/h3>\n<p>Voici le r\u00e9sultat de l\u2019ex\u00e9cution d\u2019un projet Rails architectur\u00e9 selon les principes \u00e9voqu\u00e9s ici-m\u00eame.<\/p>\n<pre><code>Finished in 4.997038s, 105.8627 runs\/s, 173.3027 assertions\/s. 529 runs, 866 assertions, 0 failures, 0 errors, 0 skips <\/code><\/pre>\n<p>Quelques secondes pour l\u2019ensemble de la suite de tests. Et toutes les couches sont test\u00e9es\u00a0: tests de bout \u00e0 bout (<em>end to end<\/em>), tests unitaires, appels en base de donn\u00e9es, rien n\u2019est \u00e9pargn\u00e9.<\/p>\n<p>La raison de cette v\u00e9locit\u00e9\u00a0? La majorit\u00e9 des objets manipul\u00e9s sont de simples classes Ruby (<em>PORO, Pure Old Ruby Object<\/em>) sans aucune d\u00e9pendance \u00e0 <code>ActiveRecord<\/code> ou autre ActiveMachin.<\/p>\n<p>L\u2019autre raison, c\u2019est qu\u2019en testant chacune des couches, on peut s\u2019autoriser \u00e0 en simuler (<em>stub<\/em>) les d\u00e9pendances. Ainsi, lorsqu\u2019on teste un cas d\u2019usage, on ne teste pas de nouveau les services dont il d\u00e9pend \u2014\u00a0d\u00e9j\u00e0 test\u00e9s en isolation par ailleurs\u00a0\u2014, on ne passe pas non plus par la couche de persistance\u00a0: les r\u00e9pertoires seront simul\u00e9s eux aussi.<\/p>\n<h3 id=\"un-bon-outillage\">Un bon outillage<\/h3>\n<p>Une bonne architecture, surtout si on souhaite capitaliser dessus \u00e0 l\u2019\u00e9chelle d\u2019une \u00e9quipe et \u00e0 travers plusieurs projets, repose sur de bons outils. Des outils \u00e9prouv\u00e9s et pens\u00e9s dans le respect des principes SOLID, favorisant un faible couplage et une responsabilit\u00e9 limit\u00e9e.<\/p>\n<p>De tels outils existent dans l\u2019\u00e9cosyst\u00e8me Ruby depuis quelques ann\u00e9es, je pense notamment aux gems <a href=\"https:\/\/rom-rb.org\/\">dry-rb<\/a> que l\u2019on retrouve notamment dans les projets <a href=\"https:\/\/hanamirb.org\/\">Ruby Object Mapper<\/a> (a.k.a rom-rb), <a href=\"https:\/\/trailblazer.to\/\">Hanami<\/a> ou encore <a href=\"https:\/\/dry-rb.org\/gems\/dry-validation\/\">Trailblazer<\/a>.<\/p>\n<p>D\u00e9couvrons ensemble trois d\u2019entre elles\u00a0: <code>dry-validation<\/code>, <code>dry-types<\/code> et <code>dry-system<\/code> que vous avez pu entrevoir dans les extraits de code en premi\u00e8re partie d\u2019article.<\/p>\n<h3 id=\"dry-validation\">DRY Validation<\/h3>\n<p>Il s\u2019agit l\u00e0 de la gem utilis\u00e9e par nos contrats. <a href=\"https:\/\/dry-rb.org\/gems\/dry-types\/\">dry-validation<\/a> a vu le jour en 2015 et repose sur des contrats sans \u00e9tat qu\u2019il nous appartient de d\u00e9finir.<\/p>\n<p>Nous avons donc ici un d\u00e9couplage entre un mod\u00e8le \u2014\u00a0qu\u2019il s\u2019agisse d\u2019un mod\u00e8le ActiveRecord ou d\u2019une entit\u00e9\u00a0\u2014 et sa validation. On s\u2019\u00e9vite ainsi de potentiels conflits de m\u00e9thodes (notre mod\u00e8le peut tout \u00e0 fait poss\u00e9der un attribut <code>errors<\/code> par exemple). De plus, <code>dry-validation<\/code> supporte la validation de structures de donn\u00e9es complexes et permet la distinction entre les r\u00e8gles m\u00e9tier et le contr\u00f4le purement technique des types de donn\u00e9es.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">ListEmails<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Ant<\/span><span class=\"o\">::<\/span><span class=\"no\">ApplicationContract<\/span>   <span class=\"n\">params<\/span> <span class=\"k\">do<\/span>     <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:page<\/span><span class=\"p\">).<\/span><span class=\"nf\">hash<\/span> <span class=\"k\">do<\/span>       <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:number<\/span><span class=\"p\">).<\/span><span class=\"nf\">value<\/span><span class=\"p\">(<\/span><span class=\"ss\">:integer<\/span><span class=\"p\">,<\/span> <span class=\"ss\">gt?: <\/span><span class=\"mi\">0<\/span><span class=\"p\">)<\/span>       <span class=\"n\">required<\/span><span class=\"p\">(<\/span><span class=\"ss\">:size<\/span><span class=\"p\">).<\/span><span class=\"nf\">value<\/span><span class=\"p\">(<\/span><span class=\"ss\">:integer<\/span><span class=\"p\">,<\/span> <span class=\"ss\">gt?: <\/span><span class=\"mi\">0<\/span><span class=\"p\">)<\/span>     <span class=\"k\">end<\/span>      <span class=\"n\">optional<\/span><span class=\"p\">(<\/span><span class=\"ss\">:filter<\/span><span class=\"p\">).<\/span><span class=\"nf\">hash<\/span> <span class=\"k\">do<\/span>       <span class=\"n\">optional<\/span><span class=\"p\">(<\/span><span class=\"ss\">:subject<\/span><span class=\"p\">).<\/span><span class=\"nf\">filled<\/span><span class=\"p\">(<\/span><span class=\"ss\">:string<\/span><span class=\"p\">)<\/span>       <span class=\"n\">optional<\/span><span class=\"p\">(<\/span><span class=\"ss\">:recipient<\/span><span class=\"p\">).<\/span><span class=\"nf\">filled<\/span><span class=\"p\">(<\/span><span class=\"ss\">:string<\/span><span class=\"p\">)<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span>    <span class=\"n\">rule<\/span><span class=\"p\">(<\/span><span class=\"ss\">filter: :recipient<\/span><span class=\"p\">)<\/span> <span class=\"k\">do<\/span>     <span class=\"n\">key<\/span><span class=\"p\">.<\/span><span class=\"nf\">failure<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"has invalid format\"<\/span><span class=\"p\">)<\/span> <span class=\"k\">unless<\/span> <span class=\"sr\">\/@\/<\/span><span class=\"p\">.<\/span><span class=\"nf\">match?<\/span><span class=\"p\">(<\/span><span class=\"n\">value<\/span><span class=\"p\">)<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span>  <span class=\"n\">contract<\/span> <span class=\"o\">=<\/span> <span class=\"no\">ListEmails<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span> <span class=\"n\">params<\/span> <span class=\"o\">=<\/span> <span class=\"p\">{<\/span>   <span class=\"ss\">page: <\/span><span class=\"p\">{<\/span> <span class=\"ss\">number: <\/span><span class=\"mi\">1<\/span><span class=\"p\">,<\/span> <span class=\"ss\">size: <\/span><span class=\"mi\">25<\/span> <span class=\"p\">},<\/span>   <span class=\"ss\">filter: <\/span><span class=\"p\">{<\/span> <span class=\"ss\">recipient: <\/span><span class=\"s2\">\"jane@doe.org\"<\/span> <span class=\"p\">}<\/span> <span class=\"p\">}<\/span>  <span class=\"n\">contract<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">)<\/span> <span class=\"c1\"># =&gt; #&lt;Dry::Validation::Result{:page=&gt;{:number=&gt;1, :size=&gt;25}, :filter=&gt;{:recipient=&gt;\"jane@doe.org\"}} errors={}&gt;<\/span>   <span class=\"n\">params<\/span> <span class=\"o\">=<\/span> <span class=\"p\">{<\/span>   <span class=\"ss\">filter: <\/span><span class=\"p\">{<\/span> <span class=\"ss\">recipient: <\/span><span class=\"s2\">\"jane.doe.org\"<\/span> <span class=\"p\">}<\/span> <span class=\"p\">}<\/span>  <span class=\"n\">contract<\/span><span class=\"p\">.<\/span><span class=\"nf\">call<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">)<\/span> <span class=\"c1\"># =&gt; #&lt;Dry::Validation::Result{:filter=&gt;{:recipient=&gt;\"jane.doe.org\"}} errors={:page=&gt;[\"is missing\"], :filter=&gt;{:recipient=&gt;[\"has invalid format\"]}}&gt;<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"dry-types--dry-struct\">DRY Types &amp; DRY Struct<\/h3>\n<p>Cette gem apparue en 2016 est dans la lign\u00e9e de DataMapper ou Virtus que certains parmi vous connaissent peut-\u00eatre un peu mieux.<\/p>\n<p><a href=\"https:\/\/www.synbioz.com\/blog\/tech\/retour-sur-la-takeoff-2016#building-a-web-api-with-hanami\">dry-types<\/a> peut \u00eatre utilis\u00e9e conjointement avec <code>dry-validation<\/code> et permet de cr\u00e9er des types de donn\u00e9es tr\u00e8s simplement, d\u2019en d\u00e9finir les contraintes, d\u2019en personnaliser le constructeur, et m\u00eame de les composer pour en cr\u00e9er de nouveaux (ex\u00a0: <code>Types::Integer | Types::String<\/code>).<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">module<\/span> <span class=\"nn\">Types<\/span>   <span class=\"kp\">include<\/span> <span class=\"no\">Dry<\/span><span class=\"o\">.<\/span><span class=\"no\">Types<\/span><span class=\"p\">()<\/span>    <span class=\"no\">IsoCode<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">String<\/span><span class=\"p\">.<\/span><span class=\"nf\">constrained<\/span><span class=\"p\">(<\/span><span class=\"ss\">format: <\/span><span class=\"sr\">\/A([A-Z]{2})z\/<\/span><span class=\"p\">)<\/span>    <span class=\"no\">ParsedDate<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">Date<\/span><span class=\"p\">.<\/span><span class=\"nf\">constructor<\/span> <span class=\"p\">{<\/span> <span class=\"o\">|<\/span><span class=\"n\">value<\/span><span class=\"o\">|<\/span> <span class=\"o\">::<\/span><span class=\"no\">DateTime<\/span><span class=\"p\">.<\/span><span class=\"nf\">parse<\/span><span class=\"p\">(<\/span><span class=\"n\">value<\/span><span class=\"p\">)<\/span> <span class=\"p\">}<\/span> <span class=\"k\">end<\/span>  <span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">IsoCode<\/span><span class=\"p\">[<\/span><span class=\"s2\">\"FRA\"<\/span><span class=\"p\">]<\/span> <span class=\"c1\"># Dry::Types::ConstraintError: \"FRA\" violates constraints (format?(\/A([A-Z]{2})z\/, \"FRA\") failed)<\/span> <span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">IsoCode<\/span><span class=\"p\">[<\/span><span class=\"s2\">\"FR\"<\/span><span class=\"p\">]<\/span> <span class=\"c1\"># =&gt; \"FR\"<\/span>  <span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">ParsedDate<\/span><span class=\"p\">[<\/span><span class=\"s2\">\"2020-10-01T07:43:31+00:00\"<\/span><span class=\"p\">]<\/span> <span class=\"c1\"># =&gt; Thu, 01 Oct 2020 07:43:31 +0000<\/span> <span class=\"no\">Types<\/span><span class=\"o\">::<\/span><span class=\"no\">ParsedDate<\/span><span class=\"p\">[<\/span><span class=\"s2\">\"today\"<\/span><span class=\"p\">]<\/span> <span class=\"c1\"># Dry::Types::CoercionError: invalid date<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"dry-system\">DRY System<\/h3>\n<p>Cr\u00e9\u00e9e en 2015, cette gem se veut \u00eatre un orchestrateur pour les d\u00e9pendances de votre projet, \u00e9vitant ainsi l\u2019injection de d\u00e9pendance manuelle \u00e0 travers chaque brique applicative. Chaque d\u00e9pendance est ainsi pr\u00eate \u00e0 l\u2019emploi, disponible via un objet nomm\u00e9 <em>container<\/em>, sans avoir \u00e0 se soucier \u00e0 chaque utilisation de l\u2019importer, de comment la configurer ou comment l\u2019instancier.<\/p>\n<p>L\u2019objectif recherch\u00e9 est la consistance de l\u2019application ainsi architectur\u00e9e et la r\u00e9duction de sa complexit\u00e9. Cette gem est notamment utilis\u00e9e par Hanami, framework web concurrent de Rails [dont on vous a d\u00e9j\u00e0 tr\u00e8s bri\u00e8vement parl\u00e9 sur ce blog][*].<\/p>\n<p>Si vous souhaitez utiliser <code>dry-system<\/code> avec Rails, il est recommand\u00e9 d\u2019utiliser <code>dry-rails<\/code> qui met en place un conteneur d\u2019application pour vous et offre des fonctionnalit\u00e9s suppl\u00e9mentaires par-dessus.<\/p>\n<h2 id=\"pour-aller-plus-loin\">Pour aller plus loin<\/h2>\n<p>Pour reprendre la main sur votre architecture logicielle et \u00eatre en mesure de garantir une longue et belle vie \u00e0 votre application et aux d\u00e9veloppeurs qui la chouchouteront, il y a quelques principes \u00e0 garder en t\u00eate en permanence. Chaque d\u00e9cision peut \u00eatre structurante, c\u2019est pourquoi il est important de se demander si l\u2019on ne se r\u00e9p\u00e8te pas\u00a0? Si l\u2019on n\u2019est pas en train de cr\u00e9er du couplage\u00a0? Si l\u2019on ne peut pas reporter cette d\u00e9cision \u00e0 plus tard, quand on aura plus de contexte\u00a0? Si l\u2019on ne prend pas la voie de la facilit\u00e9 au d\u00e9triment de la simplicit\u00e9\u00a0? Ne fabriquons pas les cha\u00eenes que nous aurons \u00e0 porter plus tard\u00a0!<\/p>\n<p>Et pour les plus radicaux d\u2019entre vous, demandez-vous ceci\u00a0: dans les limites des domaines de mon application, puis-je facilement m\u2019abstraire d\u2019ActiveSupport\u00a0? Quel serait le co\u00fbt d\u2019une mont\u00e9e de version du framework\u00a0? Puis-je imaginer remplacer ActiveRecord par Ruby Object Mapper\u00a0? Allez, soyons fous\u00a0: suis-je capable de m\u2019abstraire totalement du <em>framework<\/em>\u00a0? De faire de Rails un d\u00e9tail d\u2019impl\u00e9mentation que je pourrais remplacer par, disons, Hanami au hasard\u00a0?<\/p>\n<p>L\u2019\u00e9cosyst\u00e8me Ruby est riche aujourd\u2019hui de nombreux outils qui ne demandent qu\u2019\u00e0 \u00eatre d\u00e9couverts\u00a0! Essayez, exp\u00e9rimentez, apprenez, ouvrez-vous \u00e0 d\u2019autres horizons, d\u2019autres approches, d\u2019autres pratiques. Aiguisez votre esprit critique, confrontez-les \u00e0 vos pratiques actuelles, vous en ressortirez grandis\u00a0!<\/p>\n<h2 id=\"resources\">Resources<\/h2>\n<ul>\n<li><a href=\"https:\/\/solnic.codes\">Piotr Solnica Blog<\/a><\/li>\n<li><a href=\"https:\/\/youtu.be\/WpkDN78P884\">Ruby Midwest 2011 &#8211; Architecture the Lost Years by Robert Martin<\/a><\/li>\n<li><a href=\"https:\/\/youtu.be\/RhdlBHHimeM\">Software Art Thou\u00a0: Glenn Vanderburg &#8211; Real Software Engineering<\/a><\/li>\n<li><a href=\"https:\/\/www.lilobase.me\/le-domain-driven-design-sous-langle-strategique-une-introduction\/\">Le Domain Driven Design sous l\u2019angle strat\u00e9gique, une introduction<\/a><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Faire simple n&rsquo;est pas chose facile\u00a0!<\/p>\n","protected":false},"author":10,"featured_media":12532,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34],"tags":[],"class_list":["post-7880","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Rails n&#039;est pas simple\u00a0! - Ouidou<\/title>\n<meta name=\"description\" content=\"D\u00e9couvrez pourquoi Rails n&#039;est pas simple et comment ma\u00eetriser ce framework gr\u00e2ce aux conseils \u00e9clair\u00e9s de nos experts.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Rails n&#039;est pas simple\u00a0! - Ouidou\" \/>\n<meta property=\"og:description\" content=\"D\u00e9couvrez pourquoi Rails n&#039;est pas simple et comment ma\u00eetriser ce framework gr\u00e2ce aux conseils \u00e9clair\u00e9s de nos experts.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2020-11-11T23:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-11-06T14:54:47+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/11\/Rails-nest-pas-simple-.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"Rails n&rsquo;est pas simple\u00a0!\",\"datePublished\":\"2020-11-11T23:00:00+00:00\",\"dateModified\":\"2024-11-06T14:54:47+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple\"},\"wordCount\":2945,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/11\\\/Rails-nest-pas-simple-.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple\",\"name\":\"Rails n'est pas simple\u00a0! - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/11\\\/Rails-nest-pas-simple-.png\",\"datePublished\":\"2020-11-11T23:00:00+00:00\",\"dateModified\":\"2024-11-06T14:54:47+00:00\",\"description\":\"D\u00e9couvrez pourquoi Rails n'est pas simple et comment ma\u00eetriser ce framework gr\u00e2ce aux conseils \u00e9clair\u00e9s de nos experts.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/11\\\/Rails-nest-pas-simple-.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2020\\\/11\\\/Rails-nest-pas-simple-.png\",\"width\":1105,\"height\":564,\"caption\":\"Rails n\u2019est pas simple ! - visuel article technique\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/rails-nest-pas-simple#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Rails n&rsquo;est pas simple\u00a0!\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Rails n'est pas simple\u00a0! - Ouidou","description":"D\u00e9couvrez pourquoi Rails n'est pas simple et comment ma\u00eetriser ce framework gr\u00e2ce aux conseils \u00e9clair\u00e9s de nos experts.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple","og_locale":"fr_FR","og_type":"article","og_title":"Rails n'est pas simple\u00a0! - Ouidou","og_description":"D\u00e9couvrez pourquoi Rails n'est pas simple et comment ma\u00eetriser ce framework gr\u00e2ce aux conseils \u00e9clair\u00e9s de nos experts.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple","og_site_name":"Ouidou","article_published_time":"2020-11-11T23:00:00+00:00","article_modified_time":"2024-11-06T14:54:47+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/11\/Rails-nest-pas-simple-.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"Rails n&rsquo;est pas simple\u00a0!","datePublished":"2020-11-11T23:00:00+00:00","dateModified":"2024-11-06T14:54:47+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple"},"wordCount":2945,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/11\/Rails-nest-pas-simple-.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple","name":"Rails n'est pas simple\u00a0! - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/11\/Rails-nest-pas-simple-.png","datePublished":"2020-11-11T23:00:00+00:00","dateModified":"2024-11-06T14:54:47+00:00","description":"D\u00e9couvrez pourquoi Rails n'est pas simple et comment ma\u00eetriser ce framework gr\u00e2ce aux conseils \u00e9clair\u00e9s de nos experts.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/11\/Rails-nest-pas-simple-.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2020\/11\/Rails-nest-pas-simple-.png","width":1105,"height":564,"caption":"Rails n\u2019est pas simple ! - visuel article technique"},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/rails-nest-pas-simple#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"Rails n&rsquo;est pas simple\u00a0!"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7880","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7880"}],"version-history":[{"count":5,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7880\/revisions"}],"predecessor-version":[{"id":16609,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7880\/revisions\/16609"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/12532"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7880"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7880"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7880"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}