Construire un microblog en utilisant Node.js, Git et Markdown

Construisez un microblog basé sur Node.js, Git et Markdown

Cet article explore comment construire un microblog à l'aide de Node.js, Git et quelques dépendances. Cette application est conçue pour servir le contenu statique à partir de fichiers soumis au référentiel. Vous apprendrez à créer et à tester votre application et à comprendre le processus de livraison de votre solution. En fin de compte, vous aurez une application de blog minimaliste et exécutable sur laquelle vous pouvez construire.

Points clés:

• Node.js fournit un ensemble équilibré d'API qui sont idéaux pour construire des plateformes de microblog qui ne nécessitent pas de complexité inutile.
• git est utilisé pour stocker les articles de blog sous forme de documents texte versés sans utiliser de bases de données traditionnelles.
• Markdown est utilisé pour le formatage des articles de blog, permettant un contenu léger et peut être progressivement amélioré.
• rôti.Il est utilisé pour les tests unitaires car il est simple et n'a pas de dépendances, permettant une rétroaction rapide et une confiance améliorée des développeurs.
• L'architecture de microblog est conçue autour de la simplicité, avec le routage et les dépendances minimales pour fournir du contenu de blog, garantissant des performances rapides.
• L'application utilise un analyseur de marque personnalisé et des fonctions de modèle simple pour convertir Markdown en HTML, garantissant que le blog est léger et réactif.

Composants principaux des microblogs

Pour construire un excellent blog, tout d'abord, vous avez besoin de certains composants:

• bibliothèque pour envoyer des messages http
• Référentiel pour stocker les articles de blog
• Runner de test unitaire ou bibliothèque
• Parser de marquage

Pour envoyer des messages HTTP, j'ai choisi Node.js car il fournit tout ce dont vous avez besoin pour envoyer un message hypertexte du serveur. Les deux modules d'intérêt particulier sont http et fs. Le module http créera un serveur HTTP de nœud. Le module fs lira le fichier. Node a une bibliothèque pour construire des microblogs à l'aide de HTTP.

Pour stocker un référentiel d'articles de blog, je choisirai Git au lieu d'une base de données entièrement fonctionnelle. La raison en est que Git lui-même est un référentiel de documents texte contrôlé par version. C'est exactement tout ce dont j'ai besoin pour stocker les données des articles de blog. Se débarrasser de l'ajout de bases de données car les dépendances m'ont empêché d'avoir à écrire du code pour de nombreux problèmes.

J'ai choisi de stocker des articles de blog au format Markdown et de les analyser en utilisant marked. Si je décide de le faire plus tard, cela me permettra d'être libre d'améliorer progressivement le contenu original. Markdown est une bonne alternative légère au HTML ordinaire.

Pour les tests unitaires, j'ai choisi l'excellent rôti à coureur de test. J'ai choisi cette alternative car elle n'a pas de dépendances et qu'elle satisfait mes besoins de test unitaires. Vous pouvez choisir un autre runner de test comme une bande, mais il a environ huit dépendances. La raison pour laquelle j'aime le rôti, c'est qu'il n'a pas de dépendances.

Avec cette liste de composants, j'ai toutes les dépendances dont j'ai besoin pour construire un microblog.

La sélection des dépendances n'est pas facile. Je pense que la clé est que tout ce qui est au-delà de la portée du problème actuel peut devenir une dépendance. Par exemple, je ne créez pas de coureur de test ou de référentiel de données, donc je l'ajoute à la liste. Aucune dépendance donnée ne peut avaler la solution et détourner le code. Par conséquent, il est logique de sélectionner uniquement des composants légers.

Cet article suppose que vous connaissez déjà Node, NPM et GIT, ainsi que diverses méthodes de test. Je ne passe pas par chaque étape de la construction d'un microblog étape par étape, mais me concentre sur des zones spécifiques du code. Si vous souhaitez suivre l'action à la maison et que le code a été téléchargé sur GitHub, vous pouvez essayer chaque extrait de code.

Tester

Le test vous donne confiance dans votre code et renforce la boucle de rétroaction. Une boucle de rétroaction dans la programmation fait référence au temps nécessaire entre la rédaction de tout nouveau code et l'exécuter. Dans toute solution Web, cela signifie sauter de nombreuses couches pour obtenir des commentaires. Par exemple, les navigateurs, les serveurs Web et même les bases de données. À mesure que la complexité augmente, cela peut signifier qu'il faut plusieurs minutes ou même une heure pour obtenir des commentaires. À l'aide de tests unitaires, nous pouvons réduire ces couches et obtenir des commentaires rapides. Cela met l'accent sur le problème actuel.

J'aime démarrer une solution en écrivant des tests unitaires rapides. Cela m'a permis d'écrire des tests pour tout nouveau code. C'est ainsi que vous commencez à courir en utilisant Roast.it.

Ajouter au fichier package.json:

<code class="language-json">"scripts": {
  "test": "node test/test.js"
},
"devDependencies": {
  "roast.it": "1.0.4"
}</code>

Les fichiers

test.js sont l'endroit où vous introduisez tous les tests unitaires et les exécutez. Par exemple, vous pouvez effectuer ce qui suit:

<code class="language-javascript">var roast = require('roast.it');

roast.it('Is array empty', function isArrayEmpty() {
  var mock = [];

  return mock.length === 0;
});

roast.run();
roast.exit();</code>

Pour exécuter le test, exécutez npm install && npm test. À mon plaisir, je n'ai plus à travailler dur pour tester un nouveau code. C'est à cela que servent les tests: les programmeurs heureux gagnent en confiance et se concentrent sur les solutions.

Squelette

Le microblog utilisera le nœud pour répondre aux demandes du client. Un moyen efficace consiste à via l'API du nœud http.CreateServer(). Cela peut être vu dans les extraits suivants dans app.js:

<code class="language-javascript">/* app.js */
var http = require('http');
var port = process.env.port || 1337;

var app = http.createServer(function requestListener(req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8'});
  res.end('A simple micro blog website with no frills nor nonsense.');
});

app.listen(port);

console.log('Listening on http://localhost:' + port);</code>

Exécutez ce script via le script NPM dans package.json:

<code class="language-json">"scripts": {
  "start": "node app.js"
}</code>

Maintenant, http://localhost:1337/ devient l'itinéraire par défaut et renvoie un message au client. L'idée est d'ajouter plus d'itinéraires pour retourner d'autres réponses, telles que répondre avec le contenu des articles de blog.

Structure du dossier

Pour construire la structure de l'application, j'ai décidé d'utiliser les principales parties suivantes:

J'utiliserai ces dossiers pour organiser le code. Voici un aperçu du but de chaque dossier:

• blog: Stockez les articles de blog originaux au format de marquage pur
• message: Module réutilisable pour créer des messages de réponse aux clients
• route: routes autres que les routes par défaut
• test: où écrire des tests unitaires
• view: où placer les modèles HTML

Plus de routage et de test

Pour le premier cas d'utilisation, je présenterai un autre itinéraire au billet de blog. J'ai choisi de le mettre dans un composant testable appelé BlogRoute. Ce que j'aime, c'est que vous pouvez y injecter des dépendances. Cette séparation des préoccupations entre les unités et leurs dépendances rend possible les tests unitaires. Chaque dépendance obtient une simulation dans le test isolé. Cela vous permet d'écrire des tests immuables, reproductibles et rapides.

Par exemple, le constructeur ressemble à ceci:

<code class="language-json">"scripts": {
  "test": "node test/test.js"
},
"devDependencies": {
  "roast.it": "1.0.4"
}</code>

Les tests unitaires efficaces sont:

<code class="language-javascript">var roast = require('roast.it');

roast.it('Is array empty', function isArrayEmpty() {
  var mock = [];

  return mock.length === 0;
});

roast.run();
roast.exit();</code>

Actuellement, BlogRoute attend un objet req qui provient de l'API du nœud. Pour passer le test, faites simplement ce qui suit:

<code class="language-javascript">/* app.js */
var http = require('http');
var port = process.env.port || 1337;

var app = http.createServer(function requestListener(req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8'});
  res.end('A simple micro blog website with no frills nor nonsense.');
});

app.listen(port);

console.log('Listening on http://localhost:' + port);</code>

Avec cela, nous pouvons le connecter au pipeline de demande. Vous pouvez effectuer ce qui suit dans app.js:

<code class="language-json">"scripts": {
  "start": "node app.js"
}</code>

L'avantage d'avoir des tests est que je n'ai pas à me soucier des détails de l'implémentation à l'avance. Je vais bientôt définir message. Les objets res et req proviennent de l'API du nœud http.createServer().

Référentiel

Le problème suivant à résoudre est de lire les données de blog originales dans BlogRoute.route(). Node fournit un module fs que vous pouvez utiliser pour lire à partir du système de fichiers.

Exemple:

<code class="language-javascript">/* route/blogRoute.js */
var BlogRoute = function BlogRoute(context) {
  this.req = context.req;
};</code>

Cet extrait de code est situé dans message/readTextFile.js. Au cœur de la solution, vous lisez des fichiers texte dans le référentiel. Veuillez noter que fs.readFile() est une opération asynchrone. C'est pourquoi il faut le rappel fn et l'appelle avec des données de fichier. Cette solution asynchrone utilise des rappels simples.

Cela fournit l'exigence de fichier IO. Ce que j'aime, c'est que cela ne résout qu'un seul problème. Puisqu'il s'agit d'un problème inter-domaine, comme la lecture des fichiers, il n'est pas nécessaire de faire des tests unitaires. Les tests unitaires ne doivent tester que l'isolement de votre propre code, pas le code des autres.

En théorie, vous pouvez simuler un système de fichiers en mémoire et écrire des tests unitaires de cette manière, mais la solution commencera alors à fuir les préoccupations partout et se transformera en confusion.

Les problèmes de domaine croisé tels que la lecture des fichiers dépassent le champ d'application du code. Par exemple, la lecture des fichiers dépend d'un sous-système que vous ne pouvez pas contrôler directement. Cela rend les tests fragiles et augmente le temps et la complexité de la boucle de rétroaction. C'est un problème qui doit être séparé de votre solution.

Parser de marquage

Le problème suivant consiste à convertir les données d'origine de Markdown du référentiel en HTML. Ce processus est divisé en deux étapes:

• Obtenez le modèle HTML du dossier view
• Analyser la marque à HTML et remplir les modèles

Dans la programmation sonore, l'idée est de décomposer un gros problème en petites pièces faciles à manipuler. Résolvons la première question: comment obtenir des modèles HTML en fonction de ce que je suis BlogRoute?

Une méthode peut être:

<code class="language-javascript">/* test/blogRouteTest.js */
roast.it('Is valid blog route', function isValidBlogRoute() {
  var req = {
    method: 'GET',
    url: 'http://localhost/blog/a-simple-test'
  };

  var route = new BlogRoute({ req: req });

  return route.isValidRoute();
});</code>

N'oubliez pas que cela remplacera le rappel virtuel utilisé dans la section précédente, appelée dummyTest.

pour remplacer le rappel dummyTest, procédez comme suit:

<code class="language-json">"scripts": {
  "test": "node test/test.js"
},
"devDependencies": {
  "roast.it": "1.0.4"
}</code>

(Le contenu ultérieur est omis en raison des limitations de l'espace, veuillez l'ajouter vous-même selon les besoins)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!