Twig est un moteur de création de modèles incontournable pour le rendu HTML lors du développement d'applications Web avec Symfony.
Cependant, la flexibilité de Twig va au-delà de la simple génération de pages HTML. Il peut s'agir d'un outil puissant pour diffuser du contenu sur plusieurs canaux, tels que la génération de fichiers Markdown, des sorties JSON et même du texte brut, le tout à partir du même ensemble de contenu.

Cette adaptabilité vous permet de créer du contenu pour différents canaux.

Vous pouvez utiliser Twig pour générer du HTML, du Markdown, du JSON, du texte, etc.

Cas d'utilisation : récupérer et rendre une recette au format Markdown avec Symfony

Dans cet exemple, nous utilisons le client HTTP de Symfony pour récupérer une recette à partir d'une API externe (https://dummyjson.com/recipes/1) et la restituer sous forme de document Markdown à l'aide de Twig.
Cette approche montre comment vous pouvez combiner les puissants packages de Symfony, comme le client HTTP Symfony pour la récupération de données externes et Twig pour le rendu des vues, pour diffuser du contenu sur plusieurs canaux, tels que les rapports Markdown dans un outil de ligne de commande.

La commande/script que nous allons créer récupère les données de la recette (titre, description, ingrédients et instructions) de l'API, les traite, puis utilise Twig pour afficher le contenu dans un format Markdown structuré. Ce cas d'utilisation pratique illustre comment utiliser Twig au-delà des modèles Web, le rendant polyvalent pour générer du contenu dans différents formats.

Nous allons donc utiliser :

• Symfony Console Composant https://symfony.com/doc/current/components/console.html pour créer un outil de ligne de commande
• Client HTTP Symfony https://symfony.com/doc/current/http_client.html pour récupérer et consommer l'API HTTP
• Symfony Twig https://twig.symfony.com/doc/3.x/intro.html#installation pour le rendu des données
• Les recettes API : nous choisirons une recette "factice" https://dummyjson.com/recipes/1 pour montrer et démontrer le processus de récupération d'un JSON structuré et de sa conversion en fichier markdown .

Installation des composants Symfony nécessaires

Assurez-vous que les composants requis sont installés pour les requêtes HTTP et la création de commandes :

composer require symfony/http-client symfony/console twig/twig

Créer une commande Symfony

Tout d'abord, créons une nouvelle commande Symfony.

Si vous souhaitez en savoir plus sur la façon de créer un outil de ligne de commande à l'aide du composant Symfony Command, j'ai écrit un article spécifique à ce sujet : https://dev.to/robertobutti/building-a-command-line-tool -avec-php-et-symfony-console-4n6g

Les classes de commandes vont généralement dans le répertoire src/Commands.

# create a new empty directory
mkdir -p src/Commands
# create a new empty file
touch src/Commands/FetchRecipeCommand.php

Classe de commande (par exemple, src/Commands/FetchRecipeCommand.php) :

setName('recipe')
            ->setDescription('Prints a recipe in Markdown')
            ->setHelp('This command prints a simple recipe in Markdown.');
        // Step 1: loading the Twig environment
        $loader = new \Twig\Loader\FilesystemLoader(__DIR__ . '/../resources/views');
        $twig = new \Twig\Environment(
            $loader,
            // Optional: Enable caching for better performance
            /*[
                'cache' => __DIR__ . '/../../cache',
            ]*/
        );

        $this->twig = $twig;
        parent::__construct();
    }

    protected function configure()
    {
        $this->setDescription('Fetches a recipe from an API and renders it as Markdown');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        // Step 2: Initialize the HTTP client and fetch the recipe
        $client = HttpClient::create();
        $response = $client->request('GET', 'https://dummyjson.com/recipes/1');

        // Step 3: obtain the array of info
        $recipeData = $response->toArray();

        // Step 4: Render the template using Twig, returning a string
        $markdownOutput = $this->twig->render('recipe.md.twig', $recipeData);

        // Step 5: Output the generated Markdown
        $output->writeln($markdownOutput);

        return Command::SUCCESS;
    }
}

Voici une explication détaillée de chaque étape dans l'exemple FetchRecipeCommand.

Déroulement étape par étape

Étape 1 : Chargement de l'environnement Twig

Pour utiliser Twig en dehors de son contexte Web typique, comme dans un outil de ligne de commande PHP, vous devez d'abord l'initialiser manuellement via la classe Twig\Environment. Voici un exemple de configuration pour Twig dans une commande de console :

$loader = new \Twig\Loader\FilesystemLoader(__DIR__ . '/../resources/views');
$twig = new \Twig\Environment(
    $loader,
    // Optional: Enable caching for better performance
    /*[
        'cache' => __DIR__ . '/../../cache',
    ]*/
);
$this->twig = $twig;

Explication:

• L'environnement twig est initialisé en créant un FilesystemLoader qui indique à Twig où trouver les modèles. Ce cas pointe vers le dossier src/resources/views où sont stockés vos modèles Twig.
• Ensuite, l'environnement $twig est instancié et responsable du rendu des modèles. La mise en cache facultative peut être activée pour améliorer les performances en stockant des modèles précompilés.
• Enfin, l'environnement $twig initialisé est affecté à $this->twig pour une utilisation ultérieure (dans la méthodeexecute()).

Étape 2 : initialiser le client HTTP et récupérer la recette

$client = HttpClient::create();
$response = $client->request('GET', 'https://dummyjson.com/recipes/1');

Explication:

• Le client HTTP Symfony est créé à l'aide de la méthode HttpClient::create(), qui permet à la commande d'effectuer des requêtes HTTP.
• Pour récupérer une recette, la méthode request() effectue une requête GET à l'URL spécifiée (https://dummyjson.com/recipes/1).
• L'API renvoie une réponse JSON stockée dans la variable $response.

Étape 3 : obtenir l’ensemble des informations

$recipeData = $response->toArray();

Explication:

• La méthode toArray() convertit la réponse JSON de l'API en un tableau PHP. Ce tableau contient les données de la recette (par exemple, le nom, les ingrédients, les instructions), qui seront utilisées pour remplir le modèle Twig à l'étape suivante.

Étape 4 : rendu du modèle à l'aide de Twig

$markdownOutput = $this->twig->render('recipe.md.twig', $recipeData);

Explication:

• La méthode render() de l'environnement Twig génère la sortie Markdown. Il charge le modèle (recipe.md.twig) à partir du dossier src/resources/views.
• Les données de recette extraites de l'API ($recipeData) sont transmises au modèle, où elles remplaceront les espaces réservés tels que le nom de la recette, les ingrédients et les instructions, créant ainsi un fichier Markdown entièrement formaté.
• Le contenu Markdown rendu (la chaîne renvoyée par la méthode render()) est stocké dans la variable $markdownOutput.

Étape 5 : générer une sortie pour le Markdown généré

$output->writeln($markdownOutput);

Explication:

• Le contenu final Markdown est imprimé sur la console à l'aide de la méthode $output->writeln(). Cette méthode génère la chaîne sur la console, permettant aux utilisateurs de voir la recette formatée au format Markdown (éventuellement, vous pouvez rediriger la sortie vers un fichier dans le shell).

Création du fichier de démarrage

Vous devez créer un fichier de démarrage pour permettre à l'utilisateur de lancer votre commande Symfony directement depuis le shell. (Dans cet article, nous ne créons pas d'application Symfony ; nous construisons un script PHP en utilisant les packages Symfony.)
Dans le répertoire du projet, où se trouve le fichier composer.json et où se trouve le répertoire src, vous pouvez créer un fichier my-app.

#!/usr/bin/env php
setDefaultCommand("recipe");

$app->add(new FetchRecipeCommand());


$app->run();

Pour utiliser correctement les espaces de noms et les classes, assurez-vous de définir la section de chargement automatique dans le fichier composer.json :

{
    "require": {
        "symfony/http-client": "^7.1",
        "symfony/console": "^7.1",
        "twig/twig": "^3.14"
    },
    "autoload": {
        "psr-4": {
            "MyExample\\": "src/"
        }
    }
}

Si vous modifiez la section de chargement automatique, je suggère de vider le fichier de chargement automatique :

composer dump-autoload

Maintenant, vous devez créer le modèle/vue Twig pour restituer les données récupérées par l'API.

Créer un modèle/vue Twig pour la recette

Ensuite, créez un modèle/une vue Twig pour afficher la recette au format Markdown.
Ce modèle doit être placé dans le répertoire des vues (par exemple, src/resources/view/recipe.md.twig).

# Recipe: {{ name }}

- Preparation time: {{ prepTimeMinutes }} minutes
- Cooking time {{ cookTimeMinutes }} minutes
- Difficulty level: {{ difficulty }}
- Cuisine: {{ cuisine }}
- Servings {{ servings }} people, with {{ caloriesPerServing }} calories per person

## Ingredients:

{% for ingredient in ingredients %}
- {{ ingredient }}
{% endfor %}

## Instructions:

{% for instruction in instructions %}
- {{ instruction }}
{% endfor %}

Enjoy!

Ce fichier d'affichage Twig affichera la recette au format Markdown, avec des sections pour le nom de la recette, les ingrédients et les instructions.

Exécuter la commande

Pour exécuter la commande, exécutez ce qui suit dans le terminal :

php my-app

Dans le cas où vous disposez de plusieurs commandes, vous pouvez lancer :

php m-app recipe

Pour voir toutes les commandes disponibles :

php my-app list

Conclusion

Avec cette approche, vous pouvez facilement récupérer des données à partir d'une API externe à l'aide du client HTTP de Symfony, traiter la réponse et restituer la sortie dans un format structuré à l'aide de Twig. Dans ce cas, la commande génère une recette au format Markdown, mais cette technique peut être adaptée à tout autre contenu ou type de données que vous devez traiter.
Bonne recette !