<?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 Nico Prat on Medium]]></title>
        <description><![CDATA[Stories by Nico Prat on Medium]]></description>
        <link>https://medium.com/@nicooprat?source=rss-1f3e932b4cc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*pYn4OY7CJUlmOceaH4cMhw.jpeg</url>
            <title>Stories by Nico Prat on Medium</title>
            <link>https://medium.com/@nicooprat?source=rss-1f3e932b4cc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:19:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nicooprat/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[Générer un site statique, dynamiquement]]></title>
            <link>https://medium.com/nicooprat/g%C3%A9n%C3%A9rer-un-site-statique-dynamiquement-c3d44dc748be?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3d44dc748be</guid>
            <category><![CDATA[puppeteer]]></category>
            <category><![CDATA[netlify]]></category>
            <category><![CDATA[vue]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Fri, 23 Sep 2022 19:27:06 GMT</pubDate>
            <atom:updated>2022-09-23T20:18:40.383Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*qqVQHrY17h2R2UlRcQJdIQ.png" /></figure><h4>Retour d’expérience avec Nuxt 3, Netlify &amp; Puppeteer</h4><p><strong>TL;DR</strong></p><ol><li>Créer un script Puppeteer pour scraper et enregistrer les données dans des fichiers JSON</li><li>Utiliser Nuxt pour développer puis générer un site en les important</li><li>Déployer automatiquement chez Netlify, avec un CRON hebdomadaire</li></ol><h3>Il y a quelques années…</h3><p>J’avais décidé de “scraper” différents réseaux sociaux que j’utilise pour maintenir automatiquement mon site perso à jour. Tous ne proposaient pas d’API, ou bien elles étaient trop compliquées, et ça m’a paru une solution plus simple, notamment <strong>grâce à </strong><a href="https://apify.com/"><strong>Apify</strong></a><strong> qui permet d’abstraire une partie du travail</strong>. C’était aussi l’occasion d’essayer de nouvelles technologies, même si ça en jette moins que OAuth ou GraphQL 😬</p><p>Cela dit, le “scraping” fait partie de ces outils généralement <strong>simples à mettre en place</strong>, mais <strong>coûteux à maintenir</strong>, et il a bien sûr fallu régulièrement régler des problèmes de mise à jour : le code de ces sites changent, et les règles que j’ai utilisées étaient obsolètes.</p><p>A ce problème s’ajoute la difficulté de contrôler <strong>quand est-ce qu’il y a un problème, et quel est ce problème</strong>. Comme beaucoup d’outil SaaS, Apify est pratique quand tout fonctionne, moins quand il faut débugger et sortir des sentiers battus : j’avais programmé le déploiement chaque semaine, et les données étaient parfois incomplètes, voire complètement manquantes. Le site était alors partiellement vide ou indisponible, et il était <strong>difficile d’annuler le déploiement</strong>, et encore mieux d’en être alerté.</p><p>Cette fois j’ai tenté de simplifier la situation tout en conservant le même fonctionnement.</p><h4>🔎 Scraper avec Puppeteer</h4><p>Malgré un nom toujours aussi difficile à écrire correctement (ce n’est pas pour rien que le site officiel est <a href="https://pptr.dev/">https://pptr.dev/</a> je suppose), Puppeteer reste l’outil de prédilection pour “scraper”, en permettant de contrôler un navigateur de manière programmatique.</p><p>En l’utilisant directement, sans passer par Apify, <strong>ce qu’on perd en outillage et en écosystème, on le gagne en simplicité d’usage et en contrôle</strong>. L’arrêt de la fonctionnalité de streaming d’Apify, qui restait une bonne option pour débugger, m’a définitivement convaincu de changer mon fusil d’épaule.</p><figure><a href="https://crawlee.dev/"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IHekILdQ6suKSFW3w2fGzw.png" /></a><figcaption>Crawlee est la librairie de scrapping open-source proposée par Apify</figcaption></figure><p>Ces derniers ont d’ailleurs récemment annoncé leur nouvel outil open-source <a href="https://crawlee.dev/"><strong>Crawlee</strong></a> qui permet d’utiliser leurs technologies (retries, proxies automatiques, queuing, crawling…) sans passer par leur service. Après quelques essais je me suis rendu compte que ça ne m’était de toute façon pas nécessaire tant mon cas d’usage est simple. Exemple raccourci :</p><pre>import { writeFile } from &#39;fs/promises&#39;<br>import { launch } from &#39;puppeteer&#39;</pre><pre>;(async () =&gt; {<br>  const browser = await launch()<br>  const page = await browser.newPage()</pre><pre>  await page.setViewport({<br>    width: 800,<br>    height: 600,<br>  })</pre><pre>  await page.goto(&#39;https://mobile.twitter.com/&#39;)</pre><pre>  await page.waitForSelector(&#39;article&#39;)</pre><pre>  const tweets = await page.$$eval(&#39;article&#39;, (els) =&gt; {<br>    return { ... } // Map elements<br>  })</pre><pre>  await writeFile(<br>    &#39;./storage/twitter.json&#39;,<br>    JSON.stringify({ tweets }),<br>  )</pre><pre>  browser.close()<br>})()</pre><p>J’ai donc décidé d’être pragmatique et d’écrire un seul script qui “scrap” les sites un par un, puis enregistre les données au format JSON. De cette façon, on peut ensuite les importer comme n’importe quel autre fichier, parfait pour une génération de site statique ; on y gagne même un typage Typescript automatique, plus besoin de maintenir les définitions manuellement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*Tv7ykbqfmnYfEdxbllC2aQ.png" /><figcaption>Typescript déduit automatiquement le typage depuis des données JSON</figcaption></figure><p>De cette façon il est aussi plus facile de <strong>débugger directement dans le navigateur </strong>avec les options launch({ headless: false, devtools: true }) de Puppeteer. Enfin, on <strong>contrôle aussi mieux les cas d’erreurs</strong>, car le script échoue au moindre problème, et l’ensemble de la chaîne s’arrête : plus de déploiement hasardeux en cas de pépin.</p><h4>💻 Développer avec Nuxt 3 (RC)</h4><p>J’ai eu la chance de participer à la conférence VueJS Amsterdam en juin 2022, et beaucoup ont parlé de Nuxt 3. <strong>L’expérience développeur avait l’air prometteuse</strong>, et j’avais déjà utilisé la version précédente avec plaisir ; c’était donc l’occasion idéale de m’y remettre.</p><p>Pour résumer mon expérience, on a vraiment l’impression que <strong>tous les aspects du framework ont été modernisés</strong> pour faciliter son usage, en plus de conserver ses fonctionnalités phares, avec notamment :</p><ul><li><strong>nuxi</strong> qui permet d’effectuer les opérations de maintenance facilement</li><li>les <strong>auto-imports</strong> qui accélèrent l’écriture et simplifie le code</li><li>le support complet de <strong>Typescript</strong> qui améliore la robustesse</li><li><strong>Vue 3</strong>, bien sûr, qui rend le tout plus élégant et moderne</li></ul><p>Enfin, je tenais particulièrement à la possibilité de déployer un minimum de Javascript avec la génération “full static” qui est promise depuis longtemps. <strong>Malheureusement à l’heure où j’écris ces lignes, c’est encore à améliorer car le build embarque encore ~200kb de JS.</strong> Dommage, mais à ce stade il s’agit toujours d’une Release Candidate, patience donc…</p><p>J’ai aussi pu jouer un peu avec Nuxt Content, une sorte de CMS uniquement basé sur le système de fichiers (donc sans base de données), qui me paraît très prometteur et dont je parlerais une prochaine fois…</p><h4>🚀 Déployer avec Netlify</h4><p>Cela fait maintenant des années que j’utilise exclusivement Netlify pour tous mes projets. C’est une plateforme largement connue désormais, mais je reviens sur les quelques fonctionnalités qui m’ont rendu la vie facile dans mon cas :</p><ul><li><strong>déploiement automatique</strong> depuis Github : toujours aussi rapide et fiable, avec une <a href="https://docs.netlify.com/site-deploys/overview/">configuration en quelques clics</a></li><li><strong>hébergement, HTTPS et DNS managés</strong> : une fois mon nom de domaine (Gandi) <a href="https://docs.netlify.com/domains-https/netlify-dns/">correctement configuré</a>, tout se déroule chez Netlify</li><li><strong>fonctions programmées</strong> : depuis peu il est possible <a href="https://docs.netlify.com/netlify-labs/experimental-features/scheduled-functions">d’exécuter des fonctions sur le modèle CRON</a>, parfait pour mon usage</li><li><a href="https://docs.netlify.com/site-deploys/notifications/"><strong>notifications de déploiement</strong></a><strong> personnalisées</strong> : permet de recevoir un mail après un build réussi ou échoué, par exemple</li></ul><p>Voilà comment déclencher très simplement un déploiement de manière hebdomadaire, qui me notifiera par mail du résultat :</p><pre>// ./functions/scheduled-webhook.js</pre><pre>module.exports.handler = async function(event, context) {<br>  await fetch(&#39;<a href="https://api.netlify.com/build_hooks/62d72302d788632771285f9d&#39;">https://api.netlify.com/build_hooks/xxx&#39;</a>, {<br>    method: &#39;POST&#39;,<br>  });</pre><pre>  return {<br>    statusCode: 200,<br>  };<br>};</pre><pre>// ./netlify.toml</pre><pre>[functions.&quot;scheduled-webhook&quot;]<br>schedule = &quot;<a href="http://twitter.com/weekly">@weekly</a>&quot;</pre><p>Sur ma liste de choses à implémenter à l’avenir, on peut aussi citer :</p><ul><li>la fonctionnalité (payante) <a href="https://docs.netlify.com/monitor-sites/analytics/"><strong>d’analytics</strong></a> qui propose des données simples mais RGPD-friendly car gérées côté serveur</li><li>le <a href="https://github.com/netlify/netlify-plugin-lighthouse"><strong>plugin Lighthouse</strong></a> qui teste le site à chaque déploiement et affiche les scores directement dans l’interface</li><li>le <a href="https://github.com/netlify-labs/netlify-plugin-a11y"><strong>plugin a11y</strong></a> (terrible acronyme pour signifier accessibilité) qui fait la même chose avec <a href="https://www.deque.com/axe/">Axe</a>, l’outil de diagnostic le plus répandu</li><li>la <a href="https://docs.netlify.com/forms/setup/"><strong>gestion de formulaire</strong></a> ultra simplifiée, parfait pour un site perso</li></ul><h3>En bref</h3><p>Pour voir le résultat final, ça se passe ici :<br>➡️ <a href="https://nicooprat.com/">https://nicooprat.com/</a></p><p>Pour jeter un œil au code, c’est par là :<br>➡️ <a href="https://github.com/nicooprat/nicooprat">https://github.com/nicooprat/nicooprat</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*aVvqgLg6_nIRn-4atZ9wcQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3d44dc748be" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/g%C3%A9n%C3%A9rer-un-site-statique-dynamiquement-c3d44dc748be">Générer un site statique, dynamiquement</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Générer des mails en un clin d’œil avec Vue et MJML]]></title>
            <link>https://medium.com/nicooprat/g%C3%A9n%C3%A9rer-des-mails-en-un-clin-d%C5%93il-avec-vue-et-mjml-6057e11fdff6?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/6057e11fdff6</guid>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[email]]></category>
            <category><![CDATA[mjml]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Sat, 13 Jun 2020 13:20:30 GMT</pubDate>
            <atom:updated>2020-06-13T13:20:30.771Z</atom:updated>
            <content:encoded><![CDATA[<h4>Une solution developer-friendly pour un résultat flexible et compatible</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OBBIcin_dEoIVnZjKXkbag.png" /></figure><p>La gestion des mails est rarement une partie de plaisir dans le développement d’une application, mais il est encore plus rare de pouvoir s’en passer. Entre la solution minimaliste du <strong>format texte uniquement</strong>, et les <strong>outils graphiques tout intégrés</strong> tels que Mailchimp, il n’est pas toujours facile de trouver un <strong>compromis</strong>.</p><p>Ces dernières années on a vu apparaître une nouvelle approche dans la construction de mail, à savoir des <strong>langages qui abstraient HTML</strong> et génèrent un code <strong>compatible avec un maximum de clients mails</strong>. C’est l’occasion parfaite pour intégrer cet outil à un framework comme Vue. On parlera ici de <a href="https://mjml.io/"><strong>MJML</strong></a>, la solution de Mailjet, que vous pouvez tester ici : <a href="https://mjml.io/try-it-live">https://mjml.io/try-it-live</a>. Comparons avec les solutions via interface graphique :</p><p><strong>Avantages 👍</strong></p><ul><li>expérience développeur (code proche de HTML)</li><li>maintenance (gestion de source avec Git)</li><li>flexibilité (génération automatique complète selon les données)</li><li>partage de code (avec le frontend essentiellement)</li></ul><p><strong>Inconvénients 👎</strong></p><ul><li>inaccessible (ou presque) aux non-développeurs</li><li>demande l’apprentissage d’un nouveau langage</li><li>restreint les possibilités graphiques pour garantir la compatibilité</li></ul><p>On pourrait tout à fait utiliser cet outil dans l’interface de Mailjet et se limiter à un usage ponctuel, mais on va voir ici comment mieux intégrer cet outil dans un <strong>projet Vue</strong> et l’automatiser <strong>côté serveur</strong> (avec Node). Voilà le plan :</p><ol><li>Créer un <strong>template générique</strong></li><li>Récupérer des <strong>données</strong> selon le contexte</li><li>Générer le code <strong>MJML</strong> avec Vue</li><li>Réutiliser <strong>vue-router</strong> et <strong>vue-i18n</strong></li><li>Compiler le code MJML en <strong>HTML</strong></li><li><strong>Envoyer</strong> le mail</li></ol><p>Avant de passer ces points en revue, voilà un aperçu de ce que donne ce système :</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=http%3A%2F%2Frepl.it%2F%40nicooprat%2Fvue-i18n-vue-server-renderer-mjml-clone%3Flite%3Dtrue&amp;display_name=repl.it&amp;url=http%3A%2F%2Frepl.it%2F%40nicooprat%2Fvue-i18n-vue-server-renderer-mjml-clone%3Flite%3Dtrue&amp;image=https%3A%2F%2Frepl.it%2Fpublic%2Fimages%2Freplit-logo-800x600.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=repl" width="800" height="600" frameborder="0" scrolling="no"><a href="https://medium.com/media/94c9479eef1421eeaf4633f838c152dc/href">https://medium.com/media/94c9479eef1421eeaf4633f838c152dc/href</a></iframe><p>Il est aussi possible de voir le résultat dans l’éditeur MJML en ligne de Mailjet : <a href="https://mjml.io/try-it-live/H1udcVZ6I">https://mjml.io/try-it-live/H1udcVZ6I</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/796/1*-4aGYxBisynLlhnhxdZu2w.png" /></figure><h4>1⃣ Créer un template Vue générique</h4><p>On peut reprendre le code d’exemple de MJML et y ajouter des directives Vue. Je n’ai pas trouvé de limites particulières à l’usage. Les principales restrictions viendront donc principalement de MJML dans un souci de compatibilité. Exemple rapide avec v-if, v-for et v-bind :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e06be7ccc71f2fceedd9e85fc35e0192/href">https://medium.com/media/e06be7ccc71f2fceedd9e85fc35e0192/href</a></iframe><h4>2⃣ Contextualiser les données</h4><p>Passons rapidement sur ce point qui n’est pas spécifique à Vue ou MJML. La première étape consiste à récupérer les données qui vont alimenter le template. Selon la complexité, à vous de voir comment vous organiser. De notre côté, on a une douzaine de types de mails différents, on a donc créé une configuration où chaque mail est identifié par un code. On a ensuite plusieurs niveaux de contexte :</p><ul><li><strong>commun à tous les mails</strong> : par exemple l’email du destinataire</li><li><strong>commun à un type de mail</strong> : par exemple une illustration d’entête</li><li><strong>spécifique à un mail précis</strong> : par exemple le texte principal</li><li><strong>spécifique à un destinataire précis</strong> : par exemple sa langue d’affichage</li></ul><p>Dans l’exemple, le contexte est simulé de manière statique dans plusieurs fichiers : <a href="https://repl.it/@nicooprat/From-Vue-to-HTML-through-MJML#config.js">config.js</a> , <a href="https://repl.it/@nicooprat/From-Vue-to-HTML-through-MJML#users.js">users.js</a> , <a href="https://repl.it/@nicooprat/From-Vue-to-HTML-through-MJML#router.js">router.js</a> , et enfin la configuration des mails dans <a href="https://repl.it/@nicooprat/From-Vue-to-HTML-through-MJML#emails.js">email.js</a></p><h4>3⃣ Générer le template MJML</h4><p>Une fois toutes les variables en main, on peut générer dynamiquement le template grâce à vue-server-renderer de manière très simple :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4d3d65575886d4d728289db6c1e76bec/href">https://medium.com/media/4d3d65575886d4d728289db6c1e76bec/href</a></iframe><p>On est vraiment très proche du code frontend, qui aurait crû qu’il serait si simple de faire du SSR (Server Side Rendering) ?</p><p>Puisqu’on veut générer des balises MJML (<a href="https://mjml.io/documentation/#components">liste des composants</a>), on doit par contre ignorer les éléments HTML commençant par mjml- pour éviter des erreurs puisque Vue aurait cherché un composant du même nom ; heureusement il existe l’option ignoredElements pour ne pas prendre en compte un pattern spécifique.</p><h4>4⃣ Utiliser vue-router et vue-i18n</h4><p>Profitons-en pour partager la définition des routes et des traductions, puisque c’est l’un des avantages à utiliser Vue côté serveur. À nouveau, rien de bien différent du frontend, si ce n’est qu’il faut forcer vue-router à créer des liens absolus, ce qui oblige à passer par une méthode par exemple :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ae816152f796462cfa80dd3c2d79349a/href">https://medium.com/media/ae816152f796462cfa80dd3c2d79349a/href</a></iframe><h4>5⃣ De MJML à HTML</h4><p>Le plus dur est fait ! La librairie officielle MJML pour Node est particulièrement simple d’utilisation :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d15c8f3e279a38d238e3dce74731b262/href">https://medium.com/media/d15c8f3e279a38d238e3dce74731b262/href</a></iframe><p>Vous remarquerez qu’il est nécessaire de supprimer un attribut ajouté par vue-server-renderer, à savoir data-server-rendered pour éviter que le compiler MJML émette un warning.</p><h4>6⃣ Envoyer le mail avec Mailjet</h4><p>Dernière étape, envoyer ce mail ; Mailjet propose une librairie officielle pour Node :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c96f995bd994d18629b6ae5d4c263420/href">https://medium.com/media/c96f995bd994d18629b6ae5d4c263420/href</a></iframe><p><a href="https://repl.it/@nicooprat/vue-i18n-vue-server-renderer-mjml-clone">Dans le code d’example</a>, vous pouvez créer un fichier .env avec vos clés d’API Mailjet pour faire un test d’envoi :</p><pre>MAILJET_PUBLIC=xxx<br>MAILJET_PRIVATE=xxx</pre><h3>Quelques bémols</h3><p>On pourra reprocher à ce système qu’il devient difficile pour les non-développeurs (designers, équipe produit, marketing…) d’avoir un <strong>aperçu visuel du rendu dans un contexte particulier</strong>. Comment être sûr que le mail de bienvenue ressemble bien à ce qu’on imagine ? Que les traductions sont bien prises en compte ?</p><p>On peut envoyer des mails de test via Mailjet directement mais ce n’est pas le plus rapide et pratique ; de plus ces mails sont comptés dans les quota. Pour notre part on utilise actuellement la fonctionnalité de <strong>snapshots de Jest</strong> pour avoir un exemple “type” de chaque configuration de mail, mais ça reste le point faible de notre solution pour le moment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6057e11fdff6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/g%C3%A9n%C3%A9rer-des-mails-en-un-clin-d%C5%93il-avec-vue-et-mjml-6057e11fdff6">Générer des mails en un clin d’œil avec Vue et MJML</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Render Vue en terre inconnue]]></title>
            <link>https://medium.com/nicooprat/render-vue-en-terre-inconnue-2e421a270897?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e421a270897</guid>
            <category><![CDATA[vue]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Sun, 03 May 2020 16:41:05 GMT</pubDate>
            <atom:updated>2020-05-03T16:41:05.578Z</atom:updated>
            <content:encoded><![CDATA[<h4>Deux cas d’usage de render functions avec Vue</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DVcJJIif6dWdNEgUPk64-A.png" /></figure><p>Nativement, il existe trois solutions pour décrire la vue d’un composant : les <strong>templates</strong>, la méthode majoritaire et historique parmi les frameworks frontend ; la syntaxe <strong>JSX,</strong> qui vient du monde de React ; et enfin la dernière dont on va parler ici, la fameuse fonction <strong>render</strong> des composants. Pour rappel il s’agit de ce genre de code (<a href="https://fr.vuejs.org/v2/guide/render-function.html#Exemple-complet">docs</a>) :</p><pre>render(h) {<br>  return h(&#39;h1&#39;, this.blogTitle)<br>}</pre><p>Très complète mais forcément très verbeuse, on ne l’utilise que dans des cas très particuliers où la seule manière d’aboutir au résultat attendu est de <strong>“tordre” la façon dont est rendu le code du composant</strong>. Par exemple, le système de slots dans Vue étant parfois limité (il est impossible dans un template de boucler sur les slots, c’est à dire une sorte de &lt;slot v-for=&quot;&quot; /&gt;), c’est souvent dans ce cas qu’elle m’est avérée nécessaire. Voici deux cas rencontrés que j’ai trouvé intéressants à développer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/741/1*km4D1inh2ACH5E3InnYu1A.png" /><figcaption><strong>vue-columns</strong> : <a href="https://github.com/nicooprat/vue-columns/">code</a> &amp; <a href="https://vue-columns.netlify.app/">démo</a></figcaption></figure><h4>Vue-columns</h4><p>Ma première aventure avec les render functions a été de réaliser une sorte de layout “masonry” (à la Pinterest), c’est à dire en colonnes où chaque élément a sa propre hauteur sans impacter ses copains de la même ligne. Et non, ce n’est toujours pas possible seulement en CSS malheureusement (<a href="https://github.com/w3c/csswg-drafts/issues/4650#issuecomment-620864503">pour l’instant</a>) !</p><p>Après avoir tourné le problème dans tous les sens et écarté les solutions classiques qui agissent sur le DOM après rendu (trop de cas limites et problèmes de performances), on a fini par statuer qu’une simple répartition par colonnes nous suffirait. Puisqu’il n’est pas possible d’agir de cette manière sur les slots en utilisant un template, voilà donc en substance en quoi la solution retenue consiste :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ce3ef0212ba37a5d2181aac38e7cece0/href">https://medium.com/media/ce3ef0212ba37a5d2181aac38e7cece0/href</a></iframe><p>Le code est légèrement simplifié, mais l’idée est là : d’abord créer un élément parent, puis autant d’éléments que de colonnes demandées via la prop columns, et enfin y répartir les vnodes enfants à base de i,j et autres % dignes de mes cours d’IUT. Si vous vous demandez à quoi fait référence ctx , il s’agit d’une particularité des <a href="https://fr.vuejs.org/v2/guide/render-function.html#Composants-fonctionnels">composants fonctionnels</a>.</p><p>Le composant s’utilise de cette manière, avec ici un exemple simple de gestion du <em>responsive</em> avec la libraire <a href="https://github.com/AlexandreBonaventure/vue-mq">vue-mq</a> :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b52ddc3c6769882f9ce74067c1f3dda3/href">https://medium.com/media/b52ddc3c6769882f9ce74067c1f3dda3/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*xddtcr_JlaqQHWW1O5IN_g.png" /><figcaption><strong>vue-enqueue</strong> : <a href="https://github.com/nicooprat/vue-enqueue">code</a> &amp; <a href="https://vue-enqueue.netlify.app/">démo</a></figcaption></figure><h3>Vue-enqueue</h3><p>Une autre aventure intéressante fut le problème d’enchaînement de modales pour éviter leur superposition. On a rencontré des cas où il arrive qu’un utilisateur modifie ses données, et ce faisant déclenche d’autres actions (par exemple des récompenses, à la sauce <em>gamification</em>). Pour éviter la frustration d’être coupé dans son travail, on a cherché à retarder l’affichage de la seconde modale une fois la première fermée.</p><p>Les premières pistes se sont tournées vers une gestion classique, à savoir une queue via des propriétés data ou encore un store Vuex à part pour gérer les enchaînements. On s’est vite rendu compte qu’on multiplierait le code métier spécifique et aussi les cas particuliers. Sans compter qu’en utilisant le framework <a href="https://element.eleme.io/#/en-US/component/installation">ElementUI</a> pour nos interfaces, on a pas complètement la main sur la logique d’affichage de ces composants. On aurait aussi pu jouer avec une <a href="https://fr.vuejs.org/v2/guide/custom-directive.html">directive</a> mais il aurait fallu tricher car on ne peut pas interférer dans le rendu du composant.</p><p>On s’est alors rendu compte qu’il était superflu de créer plus de logique métier, et qu’il était plus pragmatique de simplement <strong>conditionner l’affichage lui-même</strong>. On s’est alors tourné vers la render function via un composant renderless, c’est à dire qui ne génère aucun code en lui-même. Voilà ce que ça donne :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c8d75e32d1038fdd153a60d63eada70/href">https://medium.com/media/7c8d75e32d1038fdd153a60d63eada70/href</a></iframe><p>Je mets de côté la logique d’ajout ou de suppression des composants à la queue selon la valeur de this.$slots.default qui n’est pas très intéressante. Par contre je laisse la partie qui englobe le slot dans l’élément transition natif à Vue afin de conserver l’animation à l’affichage des modales, pour montrer qu’on peut <strong>facilement s’adapter à des cas particuliers</strong>.</p><p>Enfin, pour que cette queue soit partagée entre tous les composants qui l’utilisent, il suffit de déclarer la variable en dehors de l’export . Il faut par contre bien le lier ensuite à chaque instance via la propriété data pour conserver la réactivité et ainsi appliquer de nouveau la fonction de rendu quand la variablequeue est modifié. Enfin, l’astuce fonctionne ici parce que queue est un Array, et non pas d’un <a href="https://developer.mozilla.org/fr/docs/Glossaire/Primitive">type primitif</a> comme String ou Number, auquel cas ce ne serait plus la référence vers la variable qui serait utilisée, mais un clone de la valeur en tant que telle. Bref !</p><p>On est alors sûrs et certains que deux composants ne seront jamais affichés en même temps et que l’ordre d’affichage est bien respecté, car on est <strong>au plus “bas niveau” du cycle de vie de Vue</strong>. Il aurait été plus verbeux, spécifique et hasardeux d’opter pour une solution “haut niveau” avec Vuex par exemple. Ce composant s’utilise tout simplement de cette façon :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e00767ad6e2bbdb34f64f8d6dcaa7e83/href">https://medium.com/media/e00767ad6e2bbdb34f64f8d6dcaa7e83/href</a></iframe><h3>En bref</h3><p>Bien qu’elles soient superflues dans 99% des cas et qu’on leur préférera les templates (ou JSX), les fonctions de rendu deviennent <strong>indispensables pour le 1% restant</strong>. En plus de résoudre des problèmes particulièrement atypiques, apprendre à les utiliser permet de <strong>mieux comprendre le fonctionnement de Vue</strong>, comme si on jetait pour la première fois un œil sous le capot.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e421a270897" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/render-vue-en-terre-inconnue-2e421a270897">Render Vue en terre inconnue</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Du Angular plein la Vue]]></title>
            <link>https://medium.com/nicooprat/du-angular-plein-la-vue-d11f3a7fdd8e?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/d11f3a7fdd8e</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[iframe]]></category>
            <category><![CDATA[front]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Mon, 27 Apr 2020 08:04:09 GMT</pubDate>
            <atom:updated>2020-05-04T07:41:47.214Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-nc/4.0/</cc:license>
            <content:encoded><![CDATA[<h3>Du AngularJS plein la Vue</h3><h4>Cohabitation de deux apps front-end</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CL66msZW3DQpP-v2mpjH_A.png" /></figure><blockquote><strong>TL;DR. </strong>Grâce à une simple iframe, deux versions de notre app peuvent coexister, en ajustant les styles et en synchronisant les URL entre parent et enfant.</blockquote><h4><strong>📺️ </strong><a href="https://vue-embed-angular.netlify.app/"><strong>Démo</strong></a></h4><h4><strong>💾 </strong><a href="https://github.com/nicooprat/vue-embed-angular"><strong>Code</strong></a></h4><figure><a href="https://vue-embed-angular.netlify.app/"><img alt="" src="https://cdn-images-1.medium.com/max/448/1*ZCFxe4S7GFO9bS936ABgUA.gif" /></a><figcaption><a href="https://vue-embed-angular.netlify.app/">Démo de la solution, exemple minimaliste</a></figcaption></figure><h3>Pourquoi ?</h3><p>Dans la vie d’un projet front-end de long terme, il arrive généralement le moment fatidique où il est nécessaire de mettre à jour ou de changer le framework utilisé. Plusieurs options s’offrent à nous, plus ou moins radicales :</p><p><strong>Tout jeter à la poubelle :</strong> satisfaisant dans le cas d’une app récente ou peu complexe, comme un MVP, mais rarement réalisable pour des apps d’un minimum d’envergure.</p><p><strong>Remplacement progressif :</strong> on peut transiter brique par brique, mais il faut que les technologies puissent coexister, ce qui n’est pas forcément le cas — notamment concernant les routeurs ou encore les différents outils de build tels que Webpack. De plus il subsiste toujours le risque que l’ancienne version ne soit jamais définitivement remplacée et continue de “polluer” le projet pour des années.</p><p>Il existe évidemment une infinité de variations entre ces deux extrêmes. Dans notre cas, nous avions comme problématique de :</p><ul><li>faire <strong>cohabiter</strong> notre v1 (Angular) et notre v2 (Vue)</li><li>continuer à <strong>apporter de la valeur</strong> à nos clients régulièrement (nouvelles fonctionnalités, correction de bugs, …)</li><li>créer une <strong>nouvelle version autonome</strong> sur des bases saines, sans conserver la dette technique accumulée au cours des dernières années</li><li>offrir une <strong>expérience cohérente</strong>, au moins visuellement</li><li>servir l’ancienne app <strong>complète ou embarquée</strong> selon les cas</li><li>garantir une <strong>compatibilité IE 11</strong> (encore majoritaire chez nos clients)</li></ul><p>Nous avons donc approché le problème d’une autre façon, grâce à une des briques fondamentales du web trop souvent moquée : <strong>l’iframe</strong> ! L’idée était d’embarquer l’ancienne version dans la nouvelle, puis de la maquiller suffisamment pour garder une app homogène, et enfin de la convertir page par page de façon transparente pour nos clients et indolore pour l’équipe. Ainsi on a pu :</p><ul><li>éviter les <strong>conflits de styles</strong></li><li><strong>échanger des données</strong> entre les deux versions</li><li>être <strong>compatible tous navigateurs</strong></li><li><strong>conserver ou embarquer</strong> l’ancienne application selon les clients</li><li>faire <strong>évoluer</strong> la nouvelle version sans gêne</li></ul><p>La solution se résume à 80% par un simple composant Vue (on parlera des fameux 20% restants par la suite) :</p><pre>&lt;template&gt;<br>  &lt;iframe :src=&quot;iframeSrc&quot;/&gt;<br>&lt;/template&gt;</pre><p>Mais revenons en détail sur ces différents points…</p><h3>Comment ?</h3><h4>1⃣ Isolation des styles</h4><p>CSS étant déjà particulièrement difficile à gérer à grande échelle, faire cohabiter ancien et nouveau code n’était pas une option. Une iframe nous permet de manière simple et parfaitement robuste d’éviter les conflits. On a seulement donné quelques coups de pinceaux, uniquement dans le cas de l’application embarquée ; pour savoir si l’app tourne dans une iframe, une simple condition suffit :</p><pre>if (window.self !== window.top) {<br>  document.querySelector(&#39;html&#39;).className += &#39; v2&#39;;<br>}</pre><p>On a ensuite pu appliquer ces retouches de manière chirurgicale sans impacter la v1 qui devait pouvoir continuer sa vie chez certains clients :</p><pre>html.v2 {<br>  background: red;<br>}</pre><p>De cette manière on a pu masquer les éléments structurants comme la navigation, le pied de page, … Et ajuster certains styles génériques pour que l’illusion soit suffisante. Je reviendrai toutefois en fin d’article sur quelques cas particuliers qui ont posé problème.</p><h4>2⃣ Conversation entre 2 apps</h4><p>En reprenant les conventions de Vue, on peut considérer notre iframe comme un composant à part entière :</p><ul><li>Une <strong>prop descendante</strong> via l’attribut src qui définit l’URL de l’iframe</li><li>Des <strong>évènements remontant</strong> grâce à postMessage() (<a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage">MDN</a>)</li></ul><p>Simple et efficace, cette communication nous permet de ne pas nous soucier de l’implémentation du routeur de l’app enfant et de garantir la sécurité des messages transmis grâce au paramètre targetOrigin (<a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#Syntax">MDN</a>).</p><h4>3⃣ Synchronisation des URL</h4><p>Maintenant que nos deux applications cohabitent, le but est de pouvoir naviguer de l’une à l’autre sans friction pour l’utilisateur. Deux bonnes nouvelles viennent largement nous faciliter la tâche :</p><ul><li>Vue conserve le même élément HTML iframe et ne modifie que son attribut src, donc ne charge l’app enfant qu’une seule fois</li><li>Le routeur Angular (ui-router) gère naturellement ces changements d’URL et s’actualise de lui-même (j’imagine que c’est le cas pour tous les routeurs de frameworks front-end)</li></ul><p>C’est beau le web, non ? Il ne nous reste qu’à créer une correspondance des URL entre les deux versions. On a opté pour une façon simple et flexible, à savoir la propriété meta des routes définies pour vue-router (<a href="https://router.vuejs.org/guide/advanced/meta.html">docs</a>). Par exemple :</p><pre>{<br>  path: &#39;/new&#39;,<br>  component: IframeAngular,<br>  meta: {<br>    iframe: &#39;/old&#39;<br>  }<br>}</pre><p>Du côté du composant, pour mettre à jour l’attribut src de l’iframe, il suffit de réagir à cette propriété meta, par exemple de cette façon :</p><pre>computed: {<br>  iframeSrc() {<br>    return `${baseUrl}/#!${this.$route.meta.iframe}`<br>  }<br>}</pre><p>Dans l’autre sens, on écoute le message envoyé par l’app enfant pour remplacer la route de l’app parente (code simplifié). On utilise la méthode .replace() plutôt que .push() car le navigateur a déjà enregistré la navigation provenant de l’iframe (on aurait besoin de faire deux retours en arrière sinon) :</p><pre>mounted() {<br>  window.addEventListener(&quot;message&quot;, this.syncRoute);<br>},<br>destroyed() {<br>  window.removeEventListener(&quot;message&quot;, this.syncRoute);<br>},<br>methods: {<br>  syncRoute({ data }) {<br>    const match = this.$router.options.routes.find(route =&gt; route.meta.iframe === data.iframeUrl);<br>    this.$router.replace(match);<br>  }<br>}</pre><p>Dans notre cas on avait aussi besoin de synchroniser les paramètres des URL mais je ne le traiterai pas ici, par soucis de simplicité.</p><h4>4⃣ Synchronisation de la hauteur de l’iframe</h4><p>Une iframe a pour inconvénient de ne pas avoir de dimensions dynamiques, mais en utilisant ResizeObserver et à nouveau les évènements via postMessage(), on peut réagir au changement de dimensions dans l’app enfant, et ainsi informer le parent de redéfinir la hauteur de l’iframe (penser à inclure le <a href="https://github.com/que-etc/resize-observer-polyfill">polyfill</a> pour ResizeObserver si nécessaire) pour éviter d’afficher des barres de défilement :</p><pre>const resizeObserver = new ResizeObserver(() =&gt; {<br>  parent.window.postMessage({ iframeHeight: document.body.offsetHeight }, &quot;*&quot;); // targetOrigin à spécifier<br>});<br>resizeObserver.observe(document.body);</pre><p>On peut alors écouter ce message et mettre à jour une propriété data de notre composant Vue pour appliquer le style de manière dynamique :</p><pre>&lt;template&gt;<br>  &lt;iframe :src=&quot;iframeSrc&quot; :style=&quot;{ height: `${iframeHeight}px` }&quot;/&gt;<br>&lt;/template&gt;</pre><h3>Cas limites (les fameux 20%)</h3><h4>Sécurité</h4><p>Le dialogue à travers l’iframe via l’API postMessage() nécessite de gérer les CORS. Dans notre cas ce n’est pas un problème puisque les domaines sont les mêmes, seules les URL sont préfixées. Dans le cas contraire, il faut que l’app enfant spécifie le domaine vers lequel elle envoie son message (ou &quot;*&quot;, mais c’est mal). Plus d’infos sur le <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#Security_concerns">MDN</a>.</p><h4>CSS</h4><p>Certainement ce qui nous a posé le plus de problèmes et nécessité les solutions les plus… bricolées : la propriété position: fixed n’est pas supportée au sein d’une iframe et se comporte comme position: absolute. On a donc dû trouver des compromis pour nos modales, notifications, et autres élément d’interface du même genre. On a pris le parti de les afficher au milieu de l’écran grâce à de savants calculs, mais c’est clairement la partie dont on est le moins fiers !</p><h3>Conclusion</h3><p>En attaquant le problème sous cet angle, on ne s’attendait pas à ce que les fonctionnalités de base soient si simples à mettre en place. Malgré les 20% qui nous font encore parfois découvrir des bugs tirés par les cheveux, on a pu mettre en place une solution qui contente l’équipe produit &amp; design, les commerciaux, et surtout l’équipe technique en quelques jours. La contrainte du support IE 11 était clairement un risque, mais cette bonne vieille iframe a fait des miracles !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d11f3a7fdd8e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/du-angular-plein-la-vue-d11f3a7fdd8e">Du Angular plein la Vue</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Icon.vue]]></title>
            <link>https://medium.com/nicooprat/icon-vue-31cccfe4c2bf?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/31cccfe4c2bf</guid>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[icons]]></category>
            <category><![CDATA[svg]]></category>
            <category><![CDATA[webpack]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Wed, 20 Feb 2019 10:05:34 GMT</pubDate>
            <atom:updated>2019-03-20T09:03:18.837Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d0AeftXVKkOLSmYunB7sUw.png" /><figcaption><a href="https://iconmonstr.com/product-2-svg/">Icon from Iconmonstr</a></figcaption></figure><p>Aujourd’hui le but du jeu est d’avoir un <strong>composant Vue à la fois flexible et complet pour charger des icônes en SVG</strong> :</p><ul><li>Simplifie l’ajout de nouvelles icônes</li><li>Ne crée pas de requête HTTP supplémentaires</li><li>Optimise le code SVG</li><li>Conserve la flexibilité des composants Vue</li><li>S’adapte visuellement au contexte</li></ul><blockquote><em>👉 Voici un dépôt d’exemple créé avec Vue CLI : </em><a href="https://github.com/nicooprat/icon.vue"><em>https://github.com/nicooprat/icon.vue</em></a></blockquote><p>La première étape consiste à ajouter un loader Webpack qui permet d’importer des SVG et de les traiter comme des composants Vue avec le plugin <strong>vue-svg-loader</strong>(<a href="https://vue-svg-loader.js.org/">documentation</a>), permettant aussi d’optimiser le code au passage.</p><p><em>Attention toutefois aux options de SVGO par défaut, notamment la suppression de l’attribut </em><em>viewbox qui peut poser des problèmes en terme de responsive par exemple.</em></p><p>Une fois installé il suffit de configurer vue.config.js :</p><pre>module.exports = {<br>  chainWebpack: (config) =&gt; {<br>    const svgRule = config.module.rule(&#39;svg&#39;)<br>    svgRule.uses.clear()</pre><pre>    // Use inline SVG by default, add ?external to the URL if you want external loading<br>    // See: <a href="https://vue-svg-loader.js.org/faq.html#how-to-use-both-inline-and-external-svgs">https://vue-svg-loader.js.org/faq.html#how-to-use-both-inline-and-external-svgs</a><br>    svgRule<br>      .oneOf(&#39;external&#39;)<br>      .resourceQuery(/external/)<br>      .use(&#39;file-loader&#39;)<br>      .loader(&#39;file-loader&#39;)<br>      .options({<br>        name: &#39;assets/[name].[hash:8].[ext]&#39;,<br>      })<br>      .end()<br>      .end()<br>      .oneOf(&#39;inline&#39;)<br>      .use(&#39;vue-svg-loader&#39;)<br>      .loader(&#39;vue-svg-loader&#39;)<br>      .options({<br>        svgo: {<br>          // Options: <a href="https://github.com/svg/svgo/blob/master/.svgo.yml">https://github.com/svg/svgo/blob/master/.svgo.yml</a><br>          plugins: [{ removeViewBox: false }, { prefixIds: true }, { removeXMLNS: true }]<br>        }<br>      })<br>  },<br>}</pre><p>Grâce au plugin <strong>babel-plugin-wildcard</strong>(<a href="https://github.com/vihanb/babel-plugin-wildcard/">documentation</a>) l’import des icônes se fait simplement de cette manière :</p><pre>import * as Icons from &#39;../assets/icons&#39;</pre><p>Si ESlint n’apprécie pas, vous pouvez précéder l’import de cette ligne :</p><pre>// eslint-disable-next-line import/no-unresolved, import/no-extraneous-dependencies</pre><p>Il suffira par la suite d’ajouter des fichiers SVG dans ce dossier. Ce plugin Webpack peut poser des problèmes de mise en cache, le plus simple est donc d’ajouter ce script au package.json à utiliser en cas de problème :</p><pre>&quot;scripts&quot;: {<br>  &quot;clear:babel-cache&quot;: &quot;rimraf -rf ./node_modules/.cache/babel-loader/*&quot;<br>}</pre><p>On peut ensuite inclure dynamiquement le code SVG de l’icône demandée :</p><pre>&lt;template&gt;<br>  &lt;component :is=&quot;icon&quot;/&gt;<br>&lt;/template&gt;</pre><p>Et appeler notre icône ailleurs dans l’app de cette façon :</p><pre>&lt;Icon icon=&quot;help&quot;/&gt;</pre><p>Bien sûr il est toujours possible, comme n’importe quel composant Vue, de transmettre (et potentiellement de surcharger) des attributs :</p><pre>&lt;Icon icon=&quot;help&quot; class=&quot;red&quot; width=&quot;16&quot; height=&quot;16&quot;/&gt;</pre><p>Il peut être utile d’ajouter ce style pour que l’icône soit de la même couleur que le texte courant (bien penser à l’attribut scoped) :</p><pre>&lt;style scoped&gt;<br>  path {<br>    fill: currentColor;<br>  }<br>&lt;/style&gt;</pre><p>On peut aussi ajouter la propriété install à notre composant Icon pour l’instancier globalement plus facilement :</p><pre>export default {<br>  ...<br>  install(Vue) {<br>    Vue.component(this.name, this)<br>  },<br>}</pre><p>Il ne reste qu’à ajouter à notre main.js :</p><pre>import Icon from &#39;@/components/Icon.vue&#39;<br>Vue.use(Icon)</pre><h3>Updates</h3><ol><li>On peut aussi ajouter un validator pour la prop du component : <a href="https://github.com/nicooprat/icon.vue/commit/5c6a7781b5abc8b8153c5ae381b8bfb26e48bd61">commit</a></li><li>J’ai fini par préfixer les icônes par icon- pour éviter les conflits avec les éléments HTML existants : <a href="https://github.com/nicooprat/icon.vue/commit/a297d004e8683667d70a53b2ccae9cd955a1d060">commit</a>, <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element">référence</a></li></ol><h3>Ressources d’icônes</h3><p>Voici quelques sets d’icônes propres et cohérents que je recommande. Pensez à respecter les accords de license ;)</p><ul><li><a href="https://iconmonstr.com/">iconmonstr - Free simple icons for your next project</a></li><li><a href="https://www.ikonate.com/">Ikonate - fully customisable &amp; accessible vector icons</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31cccfe4c2bf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/icon-vue-31cccfe4c2bf">Icon.vue</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Webpack & Bugsnag]]></title>
            <link>https://medium.com/nicooprat/webpack-bugsnag-69835095b61c?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/69835095b61c</guid>
            <category><![CDATA[webpack]]></category>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[bugsnag]]></category>
            <category><![CDATA[nuxt]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Tue, 18 Dec 2018 12:20:43 GMT</pubDate>
            <atom:updated>2018-12-18T12:20:43.073Z</atom:updated>
            <content:encoded><![CDATA[<h4>Releases et sourcemaps en production (exemple avec Nuxt)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qHx6p1cSOL-Ih4V9XbDjcw.png" /></figure><p>Difficile d’être serein quand on déploie une app sans être sûr que l’on sera alerté des erreurs rencontrés par les utilisateurs ! De nombreux services comme <a href="https://sentry.io/">Sentry</a> ou <a href="https://rollbar.com/">Rollbar</a> le permettent, pour ma part j’utilise <a href="https://www.bugsnag.com/">Bugsnag</a> (question de préférences ou de prix). C’est devenu indispensable pour moi, mais c’est toujours aussi <strong>complexe à intégrer au tooling et au processus de déploiement continu</strong>, donc voici un retour d’expérience d’une mise en place avec Webpack. <em>Attention je ne parle pas ici de comment intercepter les erreurs dans l’app elle-même !</em></p><p>⏭ <a href="#7647">TL;DR : la configuration complète</a></p><h4>1️⃣ Installer les plugins</h4><p>Ajouter les dépendances :</p><pre>yarn add -D webpack-bugsnag-plugins</pre><p>Puis les importer dans votre config Webpack :</p><pre>const { BugsnagBuildReporterPlugin, BugsnagSourceMapUploaderPlugin } = require(‘webpack-bugsnag-plugins’)</pre><h4>2️⃣ Créer une nouvelle release</h4><p>Pour plus de simplicité, je me base sur le <strong>hash du commit courant pour nommer la release</strong>, en ajoutant une variable d’environnement temporaire RELEASE au moment du build (ici en utilisant Nuxt) :</p><pre>&quot;generate&quot;: &quot;RELEASE=$(git rev-parse HEAD) nuxt build&quot;</pre><h4>3️⃣ Rapporter la release à Bugsnag</h4><p>Utilisons le premier plugin fourni par Bugsnag pour l’informer d’une nouvelle release :</p><pre>new BugsnagBuildReporterPlugin({<br>  apiKey: &#39;XXX&#39;,<br>  appVersion: process.env.RELEASE,<br>  releaseStage: &#39;production&#39;<br>})</pre><p>Si vous utilisez Webpack tel quel, il suffit d’ajouter ce plugin à la propriété plugins de votre configuration : <a href="https://webpack.js.org/concepts/plugins/#configuration">https://webpack.js.org/concepts/plugins/#configuration</a></p><p>Si vous utilisez Nuxt, il faut l’ajouter à la propriété build du fichier nuxt.config.js : <a href="https://nuxtjs.org/api/configuration-build#extend">https://nuxtjs.org/api/configuration-build#extend</a></p><pre>export default {<br>  build: {<br>    extend (config, { isClient }) {<br>      if (!isDev &amp;&amp; isClient) {<br>        config.plugins.push(<br>          new BugsnagBuildReporterPlugin({<br>            apiKey: &#39;XXX&#39;,<br>            appVersion: process.env.RELEASE,<br>            releaseStage: &#39;production&#39;<br>          })<br>        )<br>      }<br>    }<br>  }<br>}</pre><p><em>Notez aussi que seul les fichiers côté </em><em>client sont concernés, puisque Bugsnag est pensé pour gérer les navigateurs et non pas le serveur. Il est probable de pouvoir gérer les deux, mais je n’en ai pas eu l’utilité donc je n’ai pas testé cet aspect.</em></p><h4>4️⃣ Générer les sourcemaps</h4><p>Les rapports d’erreurs seront peu utiles s’ils renvoient vers les lignes des fichiers compilés et illisibles. Les sourcemaps permettent de lier celles-ci aux lignes de codes correspondantes dans les fichiers source. Webpack les génère automatiquement en ajoutant cette configuration : <a href="https://webpack.js.org/configuration/devtool/#devtool">https://webpack.js.org/configuration/devtool/#devtool</a></p><pre>{<br>  &quot;devtool&quot;: &quot;#source-map&quot;<br>}</pre><p>Avec Nuxt, même principe, on modifie la config à la volée :</p><pre>export default {<br>  build: {<br>    extend (config, { isClient }) {<br>      if (!isDev &amp;&amp; isClient) {<br>        config.devtool = &#39;#source-map&#39;<br>      }<br>    }<br>  }<br>}</pre><h4>5️⃣ Transférer les sourcemaps</h4><p>Ne reste plus qu’à transmettre des fichiers à Bugsnag en utilisant le deuxième plugin fourni :</p><pre>new BugsnagSourceMapUploaderPlugin({<br>  apiKey: &#39;XXX&#39;,<br>  appVersion: process.env.RELEASE,<br>  releaseStage: &#39;production&#39;,<br>  overwrite: true,<br>})</pre><p>La propriété overwrite permet d’écraser des fichiers au nom identique. Si vous laissez à false (par défaut), en cas de build identique (si vous déployez deux fois le même commit, ou bien si les fichiers n’ont pas été modifiés), Webpack créera une erreur qui bloquera le processus entier ; donc je conseille de laisser à true à défaut d’une solution plus élégante.</p><p>Si vous utilisez Nuxt, comme d’habitude, on modifie la config à la volée :</p><pre>if (!isDev &amp;&amp; isClient) {<br>  config.devtool = &#39;#source-map&#39;<br>  config.plugins.push(<br>    new BugsnagSourceMapUploaderPlugin({<br>      apiKey: &#39;c1e2241fdaa9785ed9f9288526498ae4&#39;,<br>      appVersion: process.env.RELEASE,<br>      releaseStage: &#39;production&#39;,<br>      overwrite: true,<br>    })<br>  )<br>}</pre><h4>6️⃣ Éviter les sourcemaps lisibles en production</h4><p>Pour que vos sourcemaps ne soient pas déployés en même temps que le reste de l’app et <strong>empêcher les curieux de fouiller trop facilement dans vos fichiers sources</strong>, il suffit de les supprimer en fin de script :</p><pre>&quot;generate&quot;: &quot;RELEASE=$(git rev-parse HEAD) nuxt generate<strong> &amp;&amp; rm dist/**/*.map&quot;</strong></pre><h4>⏭ Résumé</h4><p>Voilà l’ensemble de la configuration nécessaire pour intégrer Bugsnag à vos build Webpack :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a416cc03b1bb1abaa80bd5948f26cbc0/href">https://medium.com/media/a416cc03b1bb1abaa80bd5948f26cbc0/href</a></iframe><h4>⤴️ Aller plus loin ?</h4><p><a href="https://logrocket.com/">LogRocket</a> est un service complémentaire spécialisé dans le suivi du parcours utilisateur avant que l’erreur apparaisse. C’est un plus qui peut paraître superflu, mais si vous utilisez un gestionnaire d’état (Vuex pour Vue, Redux pour React, etc.) LogRocket permet de <a href="https://github.com/LogRocket/logrocket-vuex">garder un historique des mutations</a>. Je n’ai pas encore poussé aussi loin, mais le résultat semble prometteur :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*cnc9v7fVtgrbrzWyXzbr9A.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=69835095b61c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/webpack-bugsnag-69835095b61c">Webpack &amp; Bugsnag</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BlendWebMix 2018]]></title>
            <link>https://medium.com/nicooprat/blendwebmix-2018-e132656bf502?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/e132656bf502</guid>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Mon, 29 Oct 2018 15:53:32 GMT</pubDate>
            <atom:updated>2018-10-30T20:49:08.243Z</atom:updated>
            <content:encoded><![CDATA[<h4>Quelques retours et idées autour de certaines conférences auxquelles j’ai assisté cette année</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KZf4K1bgRnMEP4ZKOY_ZHA.png" /></figure><h3><a href="https://www.blendwebmix.com/programme/conferences/internet-is-for-everyone/">Peerocracry</a></h3><p>Aral Balkan propose l’expression de “<strong>surveillance capitalism</strong>”, régime dans lequel nos données et donc nos identités appartiennent et sont surveillées par les plus grosses corporations. Il en profite pour déconstruire les différentes échelles de propriété des données : <strong>corporatisme</strong> (les sociétés privées), <strong>socialisme</strong> (les états), <strong>municipalisme</strong> (les cités, comme Barcelone pionnière dans cette expérimentation) ; lui propose une vision plus libertaire avec une propriété individuelle et donc décentralisée au maximum : la <strong><em>peerocracy</em></strong>. Les avantages pour les citoyens sont clairs, mais la route est longue… En tout cas, la conférence montre à quel point ce débat récent de propriété des données numériques fait écho à d’autres débats plus vieux et plus large sur la propriété tout court…</p><h3><a href="https://www.blendwebmix.com/programme/conferences/entreprise-liberee-au-dela-du-bullshit/">Table ronde : entreprise libérée, au delà du bullshit</a></h3><p>J’étais notamment venu pour écouter la personne de LinkValue, entreprise que je connais pour avoir poussé assez loin le concept, malheureusement elle n’a fait qu’animer la session et n’a pas pris pars au débat, dommage. J’ai trouvé l’avis de François Geuze intéressant bien qu’étant réfractaire dans son inquiétude de ce que ce nouveau type d’entreprise ne soit qu’une “belle” façon de perdre certains acquis, à l’instar du statut d’auto-entrepreneur qui libère enfin des rigidités du CDI… mais qui ne garanti plus aucune sécurité. Dommage que les participants n’aient pas donné plus de détails d’implémentation concrète de “l’entreprise libérée” (quelques principes de <a href="https://fr.wikipedia.org/wiki/Holacratie">l’holacratie</a> ont été évoqués). L’idée de <strong>transparence comme fondation</strong> me paraît partagée cela dit ; à se demander s’il ne s’agirait pas d’une mauvaise traduction du mot “open” en Anglais (<a href="https://fr.wikipedia.org/wiki/Entreprise_lib%C3%A9r%C3%A9e">apparemment non</a>) ?</p><h3><a href="https://www.blendwebmix.com/programme/conferences/dev-ces-precurseurs-qui-signorent/">Dév, ces précurseurs qui s’ignorent</a></h3><p>Conférence typique de sujets classés “tech” mais qui devrait selon moi <strong>s’adresser aux managers</strong> (ou n’importe quel autre nom plus trendy qu’on leur donne ici ou là). On a parlé du rôle des développeurs en dehors de leur strict métier : questionner, proposer, remettre en question des choix, techniques ou non d’ailleurs. Finalement ça pourrait s’appliquer à tout le monde dans une entreprise, et ça rejoindrait l’idée d’entreprise libérée. Bref, ce qui m’a embêté ici, c’était l’impression qu’on pointait du doigt ces exécutants qui ne prenait pas assez l’initiative en allant proposer à leur hiérarchie (“persévérez même si votre manager qui est toujours surbooké vous envoie balader”) ; alors qu’à mon sens il faudrait <strong>revoir cet organigramme</strong> et, quitte à garder une verticalité, <strong>placer les managers “sous” les équipes techniques</strong> afin qu’ils créent les espaces et les temps nécessaires, pour que les équipes se sentent à l’aise et soient “force de proposition” ; comportement qui émergerait naturellement si le cadre était propice à mon sens.</p><h3><a href="https://www.blendwebmix.com/programme/conferences/lavenir-du-numerique-a-lere-de-lanthropocene/">L’avenir du numérique à l’ère de l’anthropocène</a></h3><p>Conférence qui propose la <strong>sobriété technologique</strong> comme nouveau fondement du progrès ; soit on le fait de manière intelligente dès aujourd’hui, soit on le fera par contrainte d’ici quelques décennies puisque les matières premières viendront à manquer. C’est toujours intéressant de revenir sur terre (de manière un peu brutale cela dit) puisqu’à force de travailler dans un monde numérique et par définition <strong>immatériel</strong> à nos yeux, on en oublie qu’il <strong>repose sur du concret</strong>. À titre d’exemple, d’après les conférenciers, si les prédictions concernant l’internet des objets se réalisent, nous n’aurons de toute façon pas suffisamment de matériel : matières premières, infrastructures, énergie… En somme, c’est “<strong>l’avenir du passé</strong>”, ou encore “les années 2050 telles qu’on les imaginait en 2000” ; sauf qu’il va falloir changer de cap.</p><h3><a href="https://www.blendwebmix.com/programme/conferences/qwant/">Peut-on offrir une user experience personnalisée tout en protégeant la vie privée des utilisateurs ?</a></h3><p>Monsieur Nitot, qu’on ne présente plus, est venu nous parler de l’histoire du web, de l’importance de la vie privée et de son travail chez Qwant. Des banalités qui ont laissé place à un paradigme proposé par (l’un de) leur nouveau projet, Qwant Masq. On pourrait le résumer à une <strong>base de donnée côté utilisateur</strong> dont le but est de personnaliser, par exemple, les résultats de recherche, sans pour autant perdre la propriété de ces données qui le permettent ; comme c’est le cas d’habitude puisqu’elles sont stockées côté serveur. Je trouve ce concept de “<strong>local-first</strong>” très intéressant et me demande s’il va faire des emules puisqu’il répond à des problématiques très actuelles. Ah, et “one more thing”, Qwant se lancera prochainement sur le marché de la cartographie avec… Qwant Maps (original non ?). De la même façon, Qwant enverra les mêmes cartes à tout le monde, sans pistage, mais les lieux suggérés pourront l’être en fonction de votre historique personnel, stocké dans votre navigateur. Approche intéressante !</p><h3><a href="https://www.blendwebmix.com/programme/conferences/vanilla-js-2018/">Vanilla JS 2018</a></h3><p>Le conférencier nous raconte son essai de créer une webapp (très) moderne en utilisant un maximum de normes récentes mais aucun outil externe (framework, library, npm, webpack… interdit !). Sans partisanisme sur l’utilité des frameworks d’une manière générale, il a réussi à trouver le juste milieu entre récit personnel, théorie et exemples concrets ; assez rare dans les conférences tech ! On en retiendra que <strong>l’universalité du web</strong> a toujours pour revers de médaille un coût quant à la <strong>compatibilité</strong> à atteindre ; situation qui devrait toutefois s’arranger une fois IE 11 laissé pour mort, puisque les nouveautés Javascript depuis 2015 seront disponibles partout ailleurs (plus besoin de Babel !). Autre enseignement, c’est un <strong>monde de lobbies</strong> : le cas des webcomponents, dont le futur reste assez incertain, le prouve ; avec Google qui pousse et Mozilla qui freine, ce dernier allant jusqu’à refuser d’implémenter les imports HTML. Enfin, on se rend à nouveau compte de <strong>l’utilité des frameworks</strong> qui nous permettent de nous distancer de ces problématiques qui rendraient notre quotidien de développeur invivable ! Un bon rappel.</p><h3><a href="https://www.blendwebmix.com/programme/conferences/sortez-vos-manettes-on-va-faire-des-maths/">Jeu vidéo et éducation : sortez vos manettes, on va faire des maths</a></h3><p>J’étais assez frustré de ne pas voir présentés les jeux éducatifs créés par cette entreprise jusqu’à ce que quelqu’un le fasse remarquer et à qui on a répondu qu’ils évitaient l’auto-promo : louable, mais je pense qu’on peut montrer du concret sans tomber dans ce travers… Bref, des réflexions intéressantes sur comment <strong>apprendre en jouant, et non pas l’inverse</strong> : par exemple éviter les simples quiz plantés bêtement sur une histoire “prétexte”. Ou encore favoriser <strong>l’appropriation par la création</strong> (en partie) du jeu par les enfants eux-mêmes. Pour ma part je me suis demandé quel est fondamentalement l’apport du jeu vidéo par rapport au jeu tout court… Loin d’être un vieux con je me méfie juste de cette impression d’inventer quelque chose, alors que seuls les outils sont nouveaux (ça y est on a überisé l’éducation !). Et d’ailleurs en parlant de vieux con, jusqu’à quel âge peut-on apprendre en jouant ?</p><h3><a href="https://www.blendwebmix.com/programme/conferences/prendre-un-engagement-contractuel-tout-en-etant-agile-retour-dexperiences/">Prendre un engagement contractuel tout en étant agile : retour d’expériences</a></h3><p>En tant qu’indépendant, la facturation (qui n’est qu’une partie du contrat) agile est quelque chose que j’ai toujours souhaité, mais jamais vraiment réussi à mettre en place : incompréhensions, craintes, manque de confiance… Un tour d’horizon des mises en applications s’est avéré riche en enseignements, avec des noms de contrats particulièrement originaux : “Money for nothing, any change for free”, “Stop ou encore”, … Les différentes implémentations se retrouvent en ligne, mais l’idée générale est de trouver une <strong>situation de satisfaction mutuelle</strong>, éviter les biais qui font que l’une des parties a intérêt à retarder les développements par exemple ; en somme <strong>créer les règles du jeu les plus saines possibles</strong>. Plus généralement, on nous conseille de parler de “co-traitance” plutôt que “sous-traitance”, même si je reste sceptique sur un tel niveau de “bienveillance” entre deux entreprises. Enfin, assumer le potentiel surcoût, l’un des principaux obstacles, car l’agilité reste la garantie d’un résultat final plus qualitatif pour le client.</p><h3><a href="https://www.blendwebmix.com/programme/conferences/product-manager-un-metier-dinterfaces/">Product manager, un métier d’interfaces</a></h3><p>Manager, product manager, product owner… Finalement tout ça se recoupe souvent selon les termes des entreprises, mais l’idée centrale reste celle d’un <strong>individu qui fait le pont entre les différentes équipes</strong>, et aussi (surtout) <strong>avec le client</strong>. Ici on le décrit comme un <strong>facilitateur</strong>, voire un <strong>traducteur</strong> ; je trouve intéressant le rapprochement qu’on peut faire avec le DDD (Domain Driven Development) qui préconise l’utilisation d’un <strong>langage commun</strong> (Ubiquitous Language) entre toutes les parties prenantes d’un projet. Comme souvent, les problèmes viennent généralement <strong>d’un manque ou d’une mauvaise communication</strong>. Enfin, la conférencière insiste sur la nécessité que l’équipe technique soit <strong>décisionnaire</strong> ; on retrouve là à nouveau les principes de l’holacratie, où ce sont les personnes compétentes qui ont autorité dans leur domaine. Comme quoi, tous ces sujets se recoupent ; c’est ça l’esprit Blend *<em>drop the mic*</em> !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e132656bf502" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/blendwebmix-2018-e132656bf502">BlendWebMix 2018</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ACF Blocks avec Gutenberg et Sage]]></title>
            <link>https://medium.com/nicooprat/acf-blocks-avec-gutenberg-et-sage-d8c20dab6270?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8c20dab6270</guid>
            <category><![CDATA[gutenberg]]></category>
            <category><![CDATA[advanced-custom-fields]]></category>
            <category><![CDATA[sage]]></category>
            <category><![CDATA[wordpress]]></category>
            <category><![CDATA[laravel-blade]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Mon, 22 Oct 2018 18:05:08 GMT</pubDate>
            <atom:updated>2020-08-12T11:13:01.347Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d2eKaVHd298yui16vA4H5Q.png" /></figure><h4>Combiner la flexibilité de Gutenberg, la simplicité d’ACF et la robustesse de Sage</h4><p><strong>Ressources :</strong></p><p>💬 <a href="https://discourse.roots.io/t/sage-gutenberg-and-acf-blocks/13945/2">Thread d’origine sur le forum de Sage</a> : infos, bugs et discussions<br>📦 <a href="https://github.com/MWDelaney/sage-acf-wp-blocks">Sage-acf-wp-blocks</a> : package Composer pour <strong>Sage</strong><br>📦 <a href="https://github.com/palmiak/timber-acf-wp-blocks">Timber-acf-wp-blocks</a> : package Composer pour <strong>Timber</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*qu4eRloaBNWT24oCvfPWZQ.png" /></figure><p><strong>Gutenberg est la future révolution de WordPress</strong> qui permet enfin de “modulariser” l’édition des pages et articles : l’expérience de l’auteur est vraiment remise au cœur de WordPress. Malheureusement, celle du développeur est quelque peu mise à mal…</p><p>Par exemple, bien qu’il soit <strong>possible de rendre un bloc réutilisable</strong>, il est <strong>impossible de faire varier son contenu</strong> sans le rendre à nouveau unique (imaginez un bloc “citation” avec une certaine mise en page… mais avec toujours la même citation !). Peut-être dans une future version ?</p><p>Ensuite, pour créer un nouveau bloc de manière programmatique (hors éditeur backoffice), il faut s’accrocher : l’aperçu du travail nécessaire pour <a href="https://www.smashingmagazine.com/2018/10/gutenberg-testimonials-sliderblock/">créer le moindre bloc</a> est particulièrement décourageant. Sans parler de <strong>choix d’architecture peu intuitifs</strong> : créer un bloc “statique” aura un template React, mais un bloc “dynamique” (afficher les 5 derniers articles par exemple) aura un template PHP à l’ancienne.</p><p>Aussi, <strong>le contenu est toujours stocké en base de données au format HTML</strong> (par souci de rétro-compatibilité je suppose, mais dommage de ne pas passer à une représentation objet) ; cela dit un bloc peut également gérer certaines meta-données en JSON dans un commentaire HTML. Pire encore, les deux peuvent cohabiter, la liberté étant laissée au développeur. Confus, peu pratique et vraiment pas sexy…</p><p>Enfin, étant habitué à <strong>utiliser </strong><a href="https://roots.io/sage/"><strong>Sage</strong></a><strong> et le moteur de template </strong><a href="https://laravel.com/docs/5.5/blade"><strong>Blade</strong></a>, cette dualité abouti à maintenir deux types de templates, dont un avec React qui viendrait s’incruster dans la fête.</p><p>En bref, si j’étais particulièrement enthousiaste à l’idée de voir Gutenberg donner un coup de jeune à WordPress, j’ai vite déchanté après quelques présentations des dessous de la machine.</p><h3>ACF à la rescousse</h3><p>Heureusement, une fois n’est pas coutume, Advanced Custom Fields va nous sauver la mise. <a href="https://www.advancedcustomfields.com/blog/acf-5-8-introducing-acf-blocks-for-gutenberg/">La dernière version beta (5.8)</a> propose <strong>d’assigner des groupes de champs personnalisés à des blocs</strong> : plus qu’une seule façon de gérer nos <strong>templates</strong>, pas de question à se poser quant au <strong>stockage des données</strong>, et pas de <strong>nouveau langage</strong> à apprendre ! Une fois installée vous pourrez rapidement aboutir à ce résultat :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5rOZoThjws9iqc1rs0-7Ww.png" /><figcaption><a href="https://www.advancedcustomfields.com/blog/acf-5-8-introducing-acf-blocks-for-gutenberg/">Exemple d’un bloc Témoignage avec champs personnalisés</a></figcaption></figure><p>Si vous avez déjà utilisé ACF vous ne serez pas dépaysés puisque <strong>l’utilisation est parfaitement identique à vos habitudes</strong>. En terme de code, la marche à franchir est donc nettement plus simple qu’apprendre, entre autres, React :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bc5c1d693878bd46be3f226c1b19b430/href">https://medium.com/media/bc5c1d693878bd46be3f226c1b19b430/href</a></iframe><p>Le code est ici réduit au strict minimum : déclarer un nouveau bloc, et indiquer à WordPress quel HTML il doit rendre. En l’occurrence, en incluant un fichier PHP à ce chemin : /template-paths/block/content-{$slug}.php.</p><h3>Rendre la création de bloc générique</h3><p>Pour éviter d’avoir à dupliquer ce code à chaque nouveau bloc créé, on va le rendre <strong>générique</strong> et se baser sur des <strong>conventions</strong> : tous les fichiers du dossier blocks sont les <strong>templates des blocs correspondants</strong>, et leurs metadonnées (name, title, category) sont <strong>gérées en commentaire</strong> (comme pour les templates personnalisés de WordPress en fait). On aura donc par exemple, pour un bloc ayant pour name “testimonial” :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/001b0a804044efe6b4b14b0eecd59f73/href">https://medium.com/media/001b0a804044efe6b4b14b0eecd59f73/href</a></iframe><p>D’après mes tests, <strong>seuls les champs titre et category sont nécessaires</strong>, et le <strong>champ name est déduit du nom du fichier</strong>. On peut d’ailleurs en profiter pour avoir des styles particuliers en utilisant l’identifiant unique du bloc, par exemple si vous avez créé un ACF de type couleur. Côté PHP on a plus qu’à parcourir le dossier contenant nos templates et les déclarer comme blocs personnalisés :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7122fc94a3e73ce05a2d544be4715cd7/href">https://medium.com/media/7122fc94a3e73ce05a2d544be4715cd7/href</a></iframe><p>La création d’un nouveau bloc ne nécessite donc <strong>plus qu’une seule étape</strong> : créer un template. Ne reste qu’à lui assigner des champs personnalisés comme vous en avez l’habitude dans l’interface d’ACF.</p><h3>Encore plus fort avec Blade</h3><p>En bonus, l’ensemble des fonctionnalités proposées avec Blade peuvent être disponibles très facilement. À l’intérieur d’un bloc, on pourra donc, par exemple, <strong>appeler un autre composant</strong> tel que components/btn.blade.php :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/db587009e8f3bc60919dec93d4baccc1/href">https://medium.com/media/db587009e8f3bc60919dec93d4baccc1/href</a></iframe><p>La seule différence est la façon dont on doit appeler le template du bloc, cette fois avec \App\template(&quot;blocks/${slug}&quot;, [&#39;block&#39; =&gt; $block]) (ligne 5) :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f8bcb92b1c87e58e0d00a0f33ee22213/href">https://medium.com/media/f8bcb92b1c87e58e0d00a0f33ee22213/href</a></iframe><p>J’en ai profité pour fusionner (ligne 4) les différentes classes qu’on peut attribuer : le nom du bloc bien sûr, mais aussi l’alignement (par défaut dans Gutenberg) et les classes additionnelles que l’auteur peut ajouter.</p><h3>Conclusion</h3><p>C’est encore une technique à mettre à l’épreuve du temps puisque j’ai tout juste fait ces tests, mais cela permet de rendre la création de bloc à la fois plus <strong>simple</strong>, plus <strong>souple</strong> et plus <strong>robuste</strong> en alliant trois technologies ; et ce sans apprendre de nouveau langage ou remettre en question vos connaissances de WordPress.</p><p>Seul bémol que j’ai trouvé pour l’instant, l’impossibilité de traduire les noms des blocs, puisque ceux-ci sont indiqués en commentaire. Ce n’est pas un problème dans la majorité des cas, mais ça peut être gênant si vous souhaitez partager publiquement un bloc personnalisé. Si vous avez une idée…</p><p>En tout cas, le code est très certainement améliorable, donc je suis ouvert aux propositions :)</p><h3>Edit 2020</h3><p>Excellente nouvelle : depuis ACF 5.9, il est possible d’utiliser les InnerBlocks de Gutenberg, c’est à dire de rendre des blocs imbriqués les uns dans les autres, ce qui multiplie encore la flexibilité de cette solution : <a href="https://www.advancedcustomfields.com/blog/acf-5-9-exciting-new-features/">https://www.advancedcustomfields.com/blog/acf-5-9-exciting-new-features/</a></p><p>Il suffit d’ajouter le support de cette fonctionnalité de cette façon :</p><pre>acf_register_block_type(array(<br>   ...,<br>   &#39;supports&#39;   =&gt; array(<br>    &#39;__experimental_jsx&#39; =&gt; true<br>   ),<br>));</pre><p>Et de rendre cette balise spécifique (une seule par bloc, pour le moment) :</p><pre>&lt;div&gt;<br>  &lt;InnerBlocks /&gt;<br>&lt;/div&gt;</pre><p>On peut par exemple facilement créer des blocs uniquement visuels comme des cartes qui permettent d’y imbriquer n’importe quel contenu à son tour dans Gutenberg :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yW8rXZuUVRAIzXoYRC1aFw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8c20dab6270" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/acf-blocks-avec-gutenberg-et-sage-d8c20dab6270">ACF Blocks avec Gutenberg et Sage</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Making-of : un site ni statique, ni dynamique, bien au contraire]]></title>
            <link>https://medium.com/nicooprat/making-of-un-site-ni-statique-ni-dynamique-bien-au-contraire-dd2c6446a494?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd2c6446a494</guid>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[nuxtjs]]></category>
            <category><![CDATA[scraping]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Wed, 23 May 2018 14:46:17 GMT</pubDate>
            <atom:updated>2018-05-24T12:31:21.376Z</atom:updated>
            <content:encoded><![CDATA[<h4>Le meilleur des deux mondes avec Nuxt, Netlify et Apify 🔥</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8y_JGiYg07vZ-3Ko." /><figcaption>Cette couverture manque cruellement d’originalité, promis le reste vaut le coup ! (<a href="https://unsplash.com/@alejandroescamilla?utm_source=medium&amp;utm_medium=referral">Alejandro Escamilla</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a>)</figcaption></figure><p>C’était un vendredi soir et il était temps de repenser mon site perso après 3 ans de vie, soit une éternité sur l’Internet. L’idée était d’avoir quelque chose qui se met à jour en fonction de mon activité sur les différents réseaux pour éviter l’effet “site mort”, tout en gardant un fonctionnement simple, tant en développement qu’en maintenance.</p><p>Pas question donc d’utiliser Wordpress avec des plugins pour chaque réseau, et à l’inverse impossible de se contenter d’un bon vieux HTML si c’est pour passer 1h de mise à jour pour chaque nouvel article sur Medium.</p><p>C’était donc l’occasion idéale de tester <strong>Nuxt</strong>. Il s’agit d’un petit framework bâti sur <strong>Vue</strong> (à l’instar de Next qui l’est sur React), permettant d’une part de<strong> faciliter le démarrage d’un projet</strong> (architecture, plugins basiques, helpers en tout genre), mais surtout de <strong>générer un site statique</strong> ; et c’est ce qui va nous intéresser le plus ici.</p><p>Sommaire :</p><ol><li><a href="#911b">Récupérer des données dynamiquement avec Apify</a></li><li><a href="#1a56">Générer un site statique avec Nuxt</a></li><li><a href="#c4d7">Déployer facilement chez Netlify</a></li></ol><h3>1️⃣ Récupérer des données dynamiquement avec Apify</h3><figure><a href="https://www.apify.com/"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GFrDMwdx2vxl8ayoaZEkuQ.png" /></a><figcaption>Apify — scrap all the things!</figcaption></figure><p>Le problème dans un premier temps, c’est de pouvoir <strong>récupérer les données</strong>. Certains réseaux ne le proposent pas du tout (Medium), de manière un peu complexe (Twitter), ou encore dans un format peu pratique (flux RSS chez Github). Le plus simple serait donc de scanner la page de notre profil sur chacun des sites !</p><p>Apify est un service en ligne (gratuit dans des limites que nous serons loin d’atteindre ici) qui permet <strong>d’automatiser le <em>scrapping</em></strong> : c’est à dire récupérer le contenu d’un site. Comme les bons vieux aspirateurs de site, oui ! Mais en mieux.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B_vtBL-RZvw59HLULcqyVw.png" /></figure><h4>Scrap it</h4><p>La première étape consiste à créer un crawler. Celui-ci a besoin à minima d’une <strong>URL de départ</strong>, et d’une <strong>fonction en Javascript qui scanne la page et retourne un tableau</strong>. Dans notre cas nous n’aurons pas besoin de plus compliqué, mais sachez qu’il est aussi possible de suivre des liens internes par exemple, et ainsi récupérer les données de manière récurrente sur toute une arborescence ; si jamais vous vous lancez dans un clone d’Amazon, ça peut servir. Il y a des tonnes d’options qu’on ne passera pas en revue ici.</p><blockquote>À noter que chez Medium il est impossible d’avoir une page qui répertorie nos propres articles uniquement, sans commentaires (un comble). Le plus simple est donc de créer une publication dans laquelle on ajoute manuellement nos articles, <a href="https://medium.com/nicooprat">comme ici</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*bPCgZZiDaVHDUUFeHykybQ.png" /></figure><p>Après avoir renseigné l’URL, il faudra jouer avec l’inspecteur de votre navigateur préféré pour <strong>trouver les bons sélecteurs CSS</strong>. Voilà un exemple d’à quoi ressemble ma fonction en question (jQuery est proposé par défaut, mais ES6 n’est pas disponible pour l’instant) :</p><pre>function pageFunction(context) {<br>    var $ = context.jQuery<br>    return $(&#39;div[data-post-id]&#39;).map(function() {<br>        const thumb = $(this).find(&#39;.u-backgroundSizeCover&#39;)<br>        return {<br>            link: $(this).find(&#39;a[data-post-id]&#39;).attr(&#39;href&#39;),<br>            thumb: thumb.length &amp;&amp; thumb.css(&#39;background-image&#39;).slice(4, -1).replace(/&quot;/g, &quot;&quot;) || false,<br>            title: $(this).find(&#39;h3&#39;).text(),<br>            excerpt: $(this).find(&#39;h3&#39;).next().text(),<br>            date: $(this).find(&#39;[datetime]&#39;).attr(&#39;datetime&#39;)<br>        }<br>    }).get()<br>}</pre><p>Ce qui nous donne un résultat ressemblant à ceci après avoir fait tourner un test du crawler :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PIRrp6dlYEADo8-JxcfqUA.png" /><figcaption>Résultat d’un run du crawler Apify</figcaption></figure><h4>Schedule it</h4><p>Ne nous reste plus qu’à créer un scheduler et définir la fréquence à laquelle le script sera exécuté. Libre à vous de le définir en fonction de votre activité. Pour l’instant j’ai conservé la valeur @daily par défaut, mais ma fibre écolo me dit que je pourrais la réduire à une semaine… À voir à la longue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IeH_mwO95UX8ZlZ0-9Ir9w.png" /><figcaption>Ne pas oublier de programmer l’exécution des crawlers</figcaption></figure><p>Vous pouvez aussi créer un scheduler qui lance plusieurs crawlers, ou encore refactoriser un peu tout ça avec le système des Actors (beta), des fonctions en tout genre qu’on peut lancer de la même manière, pas uniquement des crawlers ; <a href="https://github.com/cermak-petr/act-crawl-manager">celui-ci par exemple</a>. Pas la peine de compliquer la chose pour l’instant en tout cas ! On y reviendra en fin d’article.</p><h4>Consume it</h4><p>Ne reste plus qu’à utiliser ces données ! Pour chaque crawler, dans son <strong>onglet API</strong>, plusieurs URL sont proposées en guise de <strong>webhooks</strong> : lire, modifier, supprimer… Mais surtout <strong>récupérer le résultat de la dernière exécution</strong> :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o7fWardnzbQEacHvpWmEPw.png" /></figure><p>Le résultat est sous la forme d’un JSON tout ce qu’il y a de plus simple :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*O2kl1Wg5-UVvTd77jvsYkw.png" /></figure><p>Cette URL contient un token qui est nécessaire de masquer du public, puisqu’on pourrait par exemple appeler la fonction de suppression grâce à celui-ci. Le problème ne se pose pas dans notre cas comme on va le voir dans la 2ème partie, puisque les contenus sont récupérés puis générés côté serveur uniquement. On verra enfin dans la 3ème partie comment cacher ces URLs dans Git.</p><h3>2️⃣ Générer un site statique avec Nuxt</h3><figure><a href="https://nuxtjs.org/"><img alt="" src="https://cdn-images-1.medium.com/max/783/1*Eri18Gty99ZF0g8QaLtZ3Q.png" /></a></figure><p>Si vous avez déjà un peu d’expérience avec <strong>Vue</strong> (et ses compagnons Vue-router et Vuex, optionnels), vous ne serez pas dépaysés avec Nuxt. Je ne détaillerai pas la procédure d’installation (enfantine) ni les avantages de cette solution (nombreux), mais m’attarderai plutôt sur les fonctionnalités qui nous intéressent particulièrement dans notre cas : <strong>récupérer du contenu dynamique puis en générer un site statique</strong>.</p><h4>Server-side rendering et asyncData</h4><p>Nuxt propose un concept de <strong>pages différentes des composants</strong>. Ou plutôt, les pages sont des composants comme les autres (dans le dossier pages plutôt que components) mais uniquement de premier niveau (dans l’arborescence des composants) et qui bénéficient d’une méthode particulière : asyncData .</p><p>Dans d’autres systèmes, on parle aussi de smart components, qui récupèrent les données, et de dumb components, qui ne font qu’utiliser les données qu’on leur transmet ou inclure d’autres dumb components.</p><p><a href="https://nuxtjs.org/guide/async-data">Comme l’explique le guide</a> (d’une grande qualité et entièrement traduit en Français d’ailleurs), la méthode asyncData est appelée avant l’instantiation du composant, et doit <strong>retourner un objet qui sera fusionné avec le reste de la propriété </strong><strong>data</strong>. Attention, il est donc impossible d’avoir accès au composant lui-même avec this (puisqu’il n’existe pas encore) !</p><p>En utilisant <a href="https://github.com/axios/axios">Axios</a> pour gérer les requêtes AJAX, on pourra simplement avoir une fonction de ce genre :</p><pre>import axios from &#39;axios&#39;</pre><pre>export default {<br>  ...,  <br>  async asyncData({params, error}) {<br>    const medium = await cachios.get(&#39;<a href="https://api.apify.com/v1/KJmGFZ2mADwTHyKpp/crawlers/4jqjYdusZaPwu9bW7/lastExec?token=SJpxzSMzhGXDC8nJYND48RWNu">https://api.apify.com/v1/KJmGFZ2mADwTHyKpp/crawlers/4jqjYdusZaPwu9bW7/lastExec?token=X</a>XX&#39;)</pre><pre>    return {<br>      medium: medium.data[0].pageFunctionResult<br>    }<br>  })<br>}</pre><p>À ce propos, vous pouvez utilisez le package <a href="https://github.com/AlbinoDrought/cachios">Cachios</a> qui permet d’abstraire Axios avec une gestion de cache simplissime, afin d’éviter que chaque rechargement de page ne soit trop long à cause de ces appels répétitifs (à vous d’indiquer le paramètre ttl, par exemple 86400 pour une journée de cache).</p><p>Vous pouvez ensuite passer ces données comme d’habitude avec Vue dans vos composants enfants de cette manière :</p><pre>&lt;medium :articles=&quot;medium&quot;/&gt;</pre><h4>Générer une version statique</h4><p>Nuxt propose <strong>deux scripts NPM pour déployer votre site</strong> : build pour compiler une version classique d’une SPA, et generate pour d’abord <strong>créer des fichiers HTML respectant votre arborescence</strong> (par défaut uniquement les routes statiques, et non pas celles qui se basent sur un ID par exemple /user/:id, <a href="https://nuxtjs.org/api/configuration-generate#routes">à moins que vous les spécifiez</a>).</p><p>Cette méthode s’appuie sur le <strong>SSR</strong> (Server Side Rendering), c’est à dire que <strong>Node génère vos pages tel que le ferait un navigateur</strong> (Client Side Rendering). Que ce soit en terme de performance ou de référencement, cette technique est très utile. La contrepartie, c’est d’avoir un code qui fonctionne aussi bien d’un côté que de l’autre. Attention donc à <strong>ne pas utiliser la variable </strong><strong>window par exemple</strong>, et à choisir des <strong>packages compatibles</strong>.</p><p>La commande generate crée un dossier dist dans lequel vous trouverez comme d’habitude l’ensemble des fichiers statiques compilés, mais aussi des fichiers HTML. On pourra alors tout simplement diriger le traffic web vers ce dossier.</p><h3>3️⃣ Déployer facilement chez Netlify</h3><figure><a href="https://www.netlify.com/"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u4Om0Wn0pQkjHRwYY2zlPg.png" /></a></figure><h4>Déploiement continu</h4><p>J’ai déjà loué les mérites de Netlify précédemment, mais je recommence volontiers ici tant je suis impressionné par la simplicité et l’efficacité de ce service. Il s’agit d’une <strong>plateforme de déploiement et d’hébergement de sites statiques</strong>. La première étape consiste à lier un dépôt Git à votre projet :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*m3lgs_aTVjWagCM2pGeKww.png" /></figure><p>Une fois votre dépôt sélectionné, vous pouvez spécifier la commande generate à utiliser, et le dossier dist vers lequel rediriger :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*H6jgoRRGQJbPt9hwX5QGPQ.png" /></figure><p>Netlify commence le travail tout de suite et propose des URL de test par défaut, puis chaque push sur la branche que vous avez spécifiée déclenchera un nouveau déploiement. La liste des fonctionnalités ne s’arrête pas là et on s’attardera sur les trois dernières :</p><ul><li>ajout de snippets (Google Analytics)</li><li>optimisation des assets (Nuxt le fait déjà) → performances</li><li>prerendering (idem) → SEO</li><li>une URL par branche (tester de nouveaux développements)</li><li>notifications de déploiement (Slack)</li><li><strong>webhooks de build</strong> (permet de déclencher un build à l’appel de l’URL donnée)</li><li><strong>variables d’environnements</strong> (pour cacher certaines données sensibles)</li><li><strong>gestion des formulaires</strong> (contact)</li></ul><h4>Automatiser la mise à jour du site</h4><p>On a donc maintenant un site <strong>utilisant des données dynamiques</strong> et qui est mis à jour <strong>automatiquement à chaque changement dans notre code</strong>. Mais il reste à le mettre à jour en fonction de nos contenus. Netlify propose de créer des <strong>webhooks</strong> (sous la forme “https://api.netlify.com/build_hooks/XXX”) que l’on pourra appeler pour déclencher un build sans modification de code :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/901/1*iusXduA0WmYdB4bC5tSTpA.png" /></figure><p>Différents niveaux de complexité s’offre à vous à ce moment-là. Sachant que les données sont rechargées quotidiennement chez Apify, j’ai d’abord choisi le plus simple en déclenchant ce webhook via <a href="http://easycron.com/">un cron en webservice</a> avec EasyCron (gratuit).</p><p>J’ai ensuite utilisé la fonctionnalité Actors d’Apify pour appeler le webhook une fois les crawlers terminés en créant un nouvel Actor à partir d’un modèle public :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*KAIJaN1wBMohAlOWfShkRQ.png" /><figcaption>Dupliquer un actor public : <strong>petr_cermak/crawl-manager</strong></figcaption></figure><p>Il vous suffira alors de le configurer en spécifiant les IDs des différents crawlers à exécuter, ainsi que l’URL du webhook de Netlify à appeler en fin de tâche (attention à bien préciser &quot;parallel&quot;: 1 car l’offre gratuite ne permet pas plus) :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*58PEWJjofA_d3yw5u_l8-g.png" /><figcaption>Configurer l’actor en fonction de vos IDs et URL</figcaption></figure><h4>Variables d’environnement</h4><p>Les différentes URLs que vous utilisez pour récupérer les données d’Apify contiennent des <strong>tokens qui doivent être masqué du public</strong>. En générant le site avec Nuxt, on les cache déjà du navigateur, mais il faut aussi l’ignorer dans votre dépôt Git.</p><p>Dans un premier temps, ajoutez le <strong>package </strong><a href="https://github.com/motdotla/dotenv"><strong>dotenv</strong></a> pour pouvoir utiliser un fichier .env qui sera <strong>chargé dans l’environnement</strong> de Node puis transmis à Nuxt dans la variable process.env. Indiquer sur chaque ligne les URL de cette manière :</p><pre>medium=<a href="https://api.apify.com/v1/KJmGFZ2mADwTHyKpp/crawlers/4jqjYdusZaPwu9bW7/lastExec/results?token=SJpxzSMzhGXDC8nJYND48RWNu">https://api.apify.com/v1/KJmGFZ2mADwTHyKpp/crawlers/4jqjYdusZaPwu9bW7/lastExec/results?token=X</a>XX</pre><p>Ignorez ce fichier dans votre .gitignore et créez un clone .env.dist que vous ajouterez cette fois bien à l’index, mais qui contient uniquement les clés sans les valeurs, c’est à dire :</p><pre>medium=</pre><p>Cela permettra à d’autres développeurs ou simplement votre vous-même du futur de se rappeler les différentes valeurs nécessaires au bon fonctionnement du site ;) Enfin, vos appels dans votre méthode asyncData deviendront donc :</p><pre>const medium = await axios.get(process.env.medium)</pre><p>De retour chez Netlify, vous pouvez finalement charger ces valeurs dans les options de la manière suivante :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*CocAhfU73kGu4hvgV5zMfA.png" /></figure><h4>Formulaires de contact</h4><p>Voilà une autre fonctionnalité bienvenue : Netlify prend en compte <strong>automatiquement les formulaires trouvés dans votre site</strong>. J’avais prévu d’utiliser le service de formulaire <a href="https://formspree.io/">FormSpree</a> mais j’ai donc pu m’en passer. La <a href="https://www.netlify.com/docs/form-handling/">documentation</a> est très simple et vous pouvez simplement créer un formulaire classique en prenant soin d’ajouter les éléments en gras :</p><pre>&lt;form <strong>name=&quot;contact&quot;</strong> method=&quot;POST&quot; <strong>netlify</strong>&gt;<br>  &lt;fieldset&gt;<br>    &lt;label for=&quot;name&quot;&gt;Nom&lt;/label&gt;<br>    &lt;input type=&quot;text&quot; id=&quot;name&quot; name=&quot;name&quot; required&gt;<br>  &lt;/fieldset&gt;</pre><pre>&lt;fieldset&gt;<br>    &lt;label for=&quot;email&quot;&gt;Email&lt;/label&gt;<br>    &lt;input type=&quot;email&quot; id=&quot;email&quot; name=&quot;email&quot; required&gt;<br>  &lt;/fieldset&gt;</pre><pre>&lt;fieldset&gt;<br>    &lt;label for=&quot;message&quot;&gt;Message&lt;/label&gt;<br>    &lt;textarea name=&quot;message&quot; id=&quot;message&quot; rows=&quot;5&quot; required&gt;&lt;/textarea&gt;<br>  &lt;/fieldset&gt;</pre><pre>&lt;fieldset&gt;<br>    <strong>&lt;input type=&quot;hidden&quot; name=&quot;form-name&quot; value=&quot;contact&quot; /&gt;</strong><br>    &lt;button type=&quot;submit&quot;&gt;Envoyer&lt;/button&gt;<br>  &lt;/fieldset&gt;<br>&lt;/form&gt;</pre><p>Les messages sont stockés dans l’interface de Netlify et il est bien sûr possible de les <strong>transmettre à une adresse mail</strong>. Il est aussi possible de gérer un message de confirmation personnalisée, ou encore d’envoyer le formulaire en AJAX, mais je n’ai pas jugé nécessaire de modifier la page par défaut.</p><h4>Domaines et HTTPS</h4><p>On se rapproche de la fin et il est temps de mettre en ligne tout ça. Encore une fois Netlify est là pour nous faciliter la tâche. Une fois votre nom de domaine acheté, le plus simple est de <strong>modifier les entrées DNS pour transférer leur gestion à Netlify</strong>. Par exemple, chez Gandi :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*7fpvtXmxnt9Y-hxt7x5Dyw.png" /></figure><p>Après un peu d’attente (temps de propagation des DNS), vous devriez arriver à ce genre de résultat :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/899/1*pJY-TfMVZG7GmLzGCTjjrQ.png" /></figure><p>Vous pourrez enfin activer un certificat SSL gratuit de chez Let’s Encrypt, et forcer la redirection vers la version HTTPS de votre site :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*M17qRKOby7dvX2047xNqGw.png" /></figure><p>Quand on se rappelle le prix, le temps et la complexité nécessaire pour sécuriser son site il y a encore quelques années, on ne peut que remercier Let’s Encrypt et Netlify pour ce genre de services ! Je ne l’ai pas précisé, mais tout ça est <strong>gratuit</strong>. Amazing !</p><h3>Conclusion</h3><p>Nous voilà donc avec un site qui allie les <strong>bénéfices du dynamique et du statique</strong>, avec en prime les <strong>avantages de l’écosystème de Vue</strong>, le tout avec un <strong>minimum d’infrastructure et de maintenance</strong>. Cependant, parmi la liste de points à améliorer que j’ai en tête, on pourrait citer :</p><ul><li>dans notre cas d’un site à page unique, <strong>ne pas charger tous les fichiers JS</strong> puisqu’on pourrait se contenter de la version prérendue par Nuxt</li><li><strong>mieux gérer les mises à jour</strong> pour éviter de faire tourner des serveurs chez Apify et Netlify tous les jours, potentiellement sans changement</li><li>avoir un <strong>système d’alerte</strong> en cas de changement de la structure HTML des pages scannées par Apify</li></ul><p>Le (très loin d’être parfait) <a href="https://github.com/nicooprat/nicooprat">code source de mon site</a> est disponible sur Github. Des remarques, des idées d’améliorations ? N’hésitez pas 🤘</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd2c6446a494" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/making-of-un-site-ni-statique-ni-dynamique-bien-au-contraire-dd2c6446a494">Making-of : un site ni statique, ni dynamique, bien au contraire</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Déploiement continu facile avec Buddy.works]]></title>
            <link>https://medium.com/nicooprat/d%C3%A9ploiement-continu-facile-avec-buddy-works-90af7d85ef75?source=rss-1f3e932b4cc------2</link>
            <guid isPermaLink="false">https://medium.com/p/90af7d85ef75</guid>
            <category><![CDATA[wordpress]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Nico Prat]]></dc:creator>
            <pubDate>Wed, 28 Mar 2018 14:24:39 GMT</pubDate>
            <atom:updated>2018-03-28T14:24:39.588Z</atom:updated>
            <content:encoded><![CDATA[<h4>Exemple de déploiement d’un site sous WordPress avec le thème <a href="https://github.com/roots/sage/">Sage</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XB33CrzgV-ITlb3UA7GyPA.png" /></figure><p>Le but de la manœuvre est <strong>d’automatiser la mise en ligne</strong> de votre site à chaque modification. Ainsi, à chaque nouveau commit, <a href="https://buddy.works/">Buddy</a> <strong>répétera les tâches</strong> (uniquement si nécessaire) et <strong>déploiera les nouveautés</strong> directement sur le serveur.</p><h3>Trigger</h3><p>Sans surprise, Buddy se base sur Git pour surveiller votre code. Sur ce critère, difficile de faire plus exhaustif en terme de prise en charge :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*uyUPzfC6xYPb3PgmM04oGA.jpeg" /><figcaption>Peu importe votre infrastructure, il y a de fortes chances que Buddy la supporte.</figcaption></figure><p>Dans mon cas, j’ai simplement lié mon compte Github pour pouvoir sélectionner le projet en question. Il ne reste plus qu’à choisir la branche Git que l’on souhaite surveiller, et on peut commencer à configurer notre première pipeline…</p><h3>Build</h3><p>Buddy utilise un système de <strong>pipelines</strong> pour chaque projet. Il s’agit d’une suite d’actions à paramétrer qui réagissent à un évènement ; généralement lors d’un nouveau push , mais il est aussi possible de ne les déclencher que <strong>manuellement</strong> (ex. vider le cache) ou bien de manière <strong>récurrente</strong> (ex. faire une sauvegarde). Vous pouvez bien sûr avoir plusieurs pipelines pour le même projet, et ainsi gérer <strong>plusieurs environnements différents</strong> (ex. staging et production).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*KjBidrjlBJm0t7JFtarf6A.png" /><figcaption>Les différents mode de déclenchement et la sélection de la branche à surveiller.</figcaption></figure><p>Dans notre cas nous allons gérer la mise en ligne d’un environnement de staging à chaque push. Je ne m’attarde pas sur les options avancées que vous n’aurez certainement pas à modifier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*kEnedw25_txhRM_kWe8EQA.png" /></figure><p>Une fois votre pipeline créée, vous aurez plusieurs options à votre disposition :</p><ul><li><strong>Executions</strong> : liste les dernières exécutions de la pipeline, avec le statut (success/fail)</li><li><strong>Actions</strong> : les différentes étapes de la pipeline, vous permet de choisir parmi 95 (!) types d’actions différentes</li><li><strong>Filesystem</strong> : l’état actuel de votre projet (Buddy conserve une version en cache), pratique pour le debug</li><li><strong>Variables</strong> : variables d’environnements, clés SSH, et tout ce que vous ne souhaitez pas indexer dans Git</li><li><strong>Analytics</strong> : graphique des dernières exécutions sur les 30 derniers jours</li><li><strong>Settings</strong> : paramètres de la pipeline, en gros l’écran précédent</li></ul><p>Concentrons-nous sur la partie Actions et voyons quelles étapes nous seront nécessaires :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*IA8V4Yq6U-M4GXW7UOTCjg.png" /></figure><p>Chaque étape dispose de son propre environnement, et l’état du projet est conservé entre chacune. On aura donc une image Docker PHP pour la première étape Composer, puis une image Docker Node pour compiler les assets, et enfin une action préconfigurée rsync pour transférer les modifications sur le serveur. En bonus, on pourra notifier un channel Slack à la fin de l’exécution selon l’état de la pipeline.</p><h4>Composer</h4><p>Ajouter une nouvelle action de type PHP et la configurer de cette manière (le nom “Composer” de l’action se personnalise dans “more options”) :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/695/1*WzM9BpoKKPJK3GyYsMXVTw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*ueq3OSkYO075EMBUjygwQA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*EkX955eeDwydLX27fsEImQ.png" /></figure><p>Simplement modifier la commande et remplacer le nom du dossier de votre thème bien sûr (fig. 1). Pour avoir accès à Composer, il vous suffira d’ajouter cet environnement (fig. 3) :</p><pre>apt-get update &amp;&amp; apt-get install -y git zip<br>curl -sS <a href="https://getcomposer.org/installer">https://getcomposer.org/installer</a> | php — — install-dir=/usr/local/bin — filename=composer</pre><p>Ces commandes ne seront exécutés uniquement lorsque nécessaire (la première fois par exemple, ou si vous supprimez manuellement le cache), et ne ralentirons donc pas votre pipeline. Dans un souci d’optimisation, vous pouvez aussi, dans la partie “more options”, configurer l’option “Trigger condition” de cette manière :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*yFqqzN-42eVhX-uIinehVg.png" /></figure><h4>Webpack</h4><p>Passons à la deuxième étape qui nous permettra de compiler les assets (styles, scripts, images, etc.) avec Webpack. Le principe reste le même :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*Lz09o0WvHYAMr0RMS8PxLQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*FintNZ6PSg4j14wWwNV6Sg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*z-1oFd74fenAhbGBT5DCbw.png" /></figure><p>Dans notre cas nous utilisons yarn donc il suffit de l’installer dans la personnalisation de l’environnement (fig. 3) au même titre que composer. À nouveau, on peut limiter cette action à l’éventualité où le dossier qui la concerne est modifié :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*9lE9wY_dP-QJe3OL8Q4Gcw.png" /></figure><h4>Deploy</h4><p>Votre dépôt est à jour sur Buddy, les dépendances PHP sont à jour grâce à Composer et vos assets compilés avec Webpack. Ne reste plus qu’à envoyer tout ça sur notre serveur.</p><p>La solution la plus simple et rapide reste SFTP. Pour autoriser Buddy à se connecter en SSH à votre serveur, vous pouvez ajouter leur clé RSA public dans votre fichier .ssh/authorized_keys que vous trouverez dans l’onglet “Variables”. Si vous n’avez pas cette possibilité, vous pouvez ajouter votre propre clé privée à Buddy, toujours dans le même onglet, pour qu’il se connecte en votre nom ; cela dit, en terme de sécurité, mieux vaut privilégier la première option ;)</p><p>Dans mon cas j’utilise une simple commande rsync, et chez Buddy ils ont poussé l’efficacité jusqu’à proposer une action pré-configurée pour ce cas de figure ; on peut même choisir le chemin de source et de destination via leur interface graphique pour être sûr de ne pas se tromper :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/708/1*ZXvJxO_XXTGkGLtJshIgJw.png" /></figure><p>Cette fois-ci il faudra obligatoirement choisir certains fichiers et dossiers à ignorer pour, par exemple, ne pas envoyer tout l’index Git sur votre serveur. Pour notre cas, nous avons bêtement repris le contenu de notre .gitignore , puis ajouté .git et supprimé les dossiers dist et vendor générés par nos deux actions précédentes bien sûr :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/685/1*JCnt4EqbyBGzs_9ovKPZ1Q.png" /></figure><h4>Notification</h4><p>La dernière étape consiste à créer une notification envoyée dans un channel Slack de votre choix. Pratique si vous travaillez à plusieurs, seul vous pourrez privilégier un simple email par exemple. À savoir que vous pouvez choisir de notifier qu’en cas de succès ou d’échec, ou les deux (cf le premier screenshot de l’article). Voici les différents choix de notification :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/689/1*OkppqTSutLilR2SUrnioow.png" /></figure><p>Restons sur la première option. Une fois que vous avez suivi la procédure d’autorisation de Slack, vous pouvez configurer la tâche de succès de cette façon ; pour personnaliser le contenu du message, vous avez accès à <a href="https://buddy.works/knowledge/deployments/what-parameters-buddy-use#list-of-buddy-parameters">ces différents paramètres</a> en respectant la <a href="https://velocity.apache.org/engine/1.7/user-guide.html#what-can-velocity-do-for-me">syntaxe “Velocity Template Engine</a>” :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/693/1*wBmjn9Al2Qtbi4bCjR_ycw.png" /></figure><pre>✅ *&lt;${execution.html_url}|${execution.pipeline.name} (${execution.branch.name}) #${execution.id}&gt;*</pre><pre>#foreach( $commit in $execution.changelog.commits)<br>`${commit.revision.substring(0,8)}` ${commit.message}<br>#end</pre><p>Pour ma part j’ai supprimé le contenu “attachment” dans les options (ça me paraissait trop peu utile pour la place utilisée dans le channel). La configuration ci-dessus aura pour résultat quelque chose comme :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/298/1*8i36x4HlKQsj-gAYtzyuIw.png" /></figure><p>Pour l’instant, le nom de l’auteur du commit n’est pas disponible dans le changelog mais l’équipe de Buddy l’a ajouté à sa wishlist. Enfin, vous pouvez aussi ajouter une notification différente en cas d’échec, dans notre cas le changelog est remplacé par les logs d’erreur, et l’emoji modifié :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*9jU71vI7SRbG5eL4dBN0yw.png" /></figure><pre>⚠️ *&lt;${execution.html_url}|${execution.pipeline.name} (${execution.branch.name}) #${execution.id}&gt;*</pre><pre>#foreach( $action in $execution.action_executions)<br> #if( $action.status == “FAILED” )<br> #foreach( $line in $action.log)<br> ${line}<br> #end<br> #end<br>#end</pre><h3>Fichiers d’import</h3><p>Si vous souhaitez rapidement récupérer la configuration décrite ici, vous pouvez simplement importer <a href="https://gist.github.com/nicooprat/b274970908fd2e5b676e2c1e8a12da61">ce fichier de configuration</a> dans Buddy. D’ailleurs, si vous êtes allergiques aux interfaces graphiques, vous pouvez, comme avec la plupart des outils de déploiement continu, enregistrer ce fichier à la racine de votre projet en tant que buddy.yml, et Buddy l’utilisera automatiquement.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/578a3000aae721731a5dcea40d4844fa/href">https://medium.com/media/578a3000aae721731a5dcea40d4844fa/href</a></iframe><h3>Conclusion</h3><p>Performant, complet et extrêmement simple d’utilisation, Buddy m’a réconcilié avec les outils d’automatisation ; après avoir testé Bitbucket Pipelines et Travis, l’espoir renait :) Et pourtant je n’ai fait qu’effleurer l’étendue des possibilités offertes par cet outil, sans mentionner sa gratuité !</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qu1MJ07BEH6-EFaNJ8jQgw.png" /></figure><p>Je ne saurais que vous conseiller de l’essayer puis de partager les différents cas d’usages pour lesquels vous l’utilisez (ou comptez l’utiliser) !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90af7d85ef75" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nicooprat/d%C3%A9ploiement-continu-facile-avec-buddy-works-90af7d85ef75">Déploiement continu facile avec Buddy.works</a> was originally published in <a href="https://medium.com/nicooprat">nicooprat</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>