Twig es un motor de plantillas de referencia para renderizar HTML al desarrollar aplicaciones web con Symfony.
Sin embargo, la flexibilidad de Twig va más allá de generar sólo páginas HTML. Puede ser una herramienta poderosa para entregar contenido a través de múltiples canales, como generar archivos Markdown, salidas JSON e incluso texto sin formato, todo desde el mismo conjunto de contenido.

Esta adaptabilidad te permite crear contenido para diferentes canales.

Puedes usar Twig para generar HTML, Markdown, JSON, texto, etc.

Caso de uso: buscar y renderizar una receta como Markdown con Symfony

En este ejemplo, utilizamos el cliente HTTP de Symfony para obtener una receta de una API externa (https://dummyjson.com/recipes/1) y representarla como un documento Markdown usando Twig.
Este enfoque muestra cómo puedes combinar los potentes paquetes de Symfony, como el cliente HTTP de Symfony para recuperación de datos externos y Twig para renderizar vistas, para entregar contenido a través de múltiples canales, como informes Markdown en una herramienta de línea de comandos.

El comando/script que vamos a crear obtiene los datos de la receta (título, descripción, ingredientes e instrucciones) de la API, los procesa y luego usa Twig para generar el contenido en un formato Markdown estructurado. Este caso de uso práctico ilustra cómo utilizar Twig más allá de las plantillas web, haciéndolo versátil para generar contenido en varios formatos.

Entonces, vamos a usar:

• Consola Symfony Componente https://symfony.com/doc/current/components/console.html para crear una herramienta de línea de comandos
• Cliente HTTP Symfony https://symfony.com/doc/current/http_client.html para recuperar y consumir API HTTP
• Symfony Twig https://twig.symfony.com/doc/3.x/intro.html#instalación para renderizar datos
• Las recetas API: elegiremos una receta "ficticia" https://dummyjson.com/recipes/1 para mostrar y demostrar el proceso para recuperar un JSON estructurado y convertirlo en un archivo de rebajas. .

Instalación de los componentes necesarios de Symfony

Asegúrese de tener instalados los componentes necesarios para las solicitudes HTTP y la creación de comandos:

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

Crear un comando Symfony

Primero, creemos un nuevo comando de Symfony.

Si quieres leer más sobre cómo crear una herramienta de línea de comandos usando el componente Symfony Command, escribí un artículo específico sobre esto: https://dev.to/robertobutti/building-a-command-line-tool -con-php-y-symfony-console-4n6g

Las clases de comandos, normalmente van al directorio src/Commands.

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

Clase de comando (por ejemplo, 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;
    }
}

Aquí hay una explicación detallada de cada paso en el ejemplo de FetchRecipeCommand.

Desglose paso a paso

Paso 1: cargar el entorno twig

Para usar Twig fuera de su contexto web típico, como en una herramienta de línea de comandos PHP, primero debe inicializarlo manualmente a través de la clase Twig\Environment. Aquí hay un ejemplo de configuración para Twig en un comando de consola:

$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;

Explicación:

• El entorno de twig se inicializa creando un FilesystemLoader que le indica a Twig dónde encontrar las plantillas. Este caso apunta a la carpeta src/resources/views donde se almacenan sus plantillas de Twig.
• Luego, se crea una instancia del entorno $twig y es responsable de representar las plantillas. Se puede habilitar el almacenamiento en caché opcional para mejorar el rendimiento almacenando plantillas precompiladas.
• Finalmente, el entorno $twig inicializado se asigna a $this->twig para su uso posterior (en el método ejecutar()).

Paso 2: inicializar el cliente HTTP y buscar la receta

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

Explicación:

• El cliente HTTP de Symfony se crea utilizando el método HttpClient::create(), que permite al comando realizar solicitudes HTTP.
• Para recuperar una receta, el método request() realiza una solicitud GET a la URL especificada (https://dummyjson.com/recipes/1).
• La API devuelve una respuesta JSON almacenada en la variable $response.

Paso 3: obtención del conjunto de información

$recipeData = $response->toArray();

Explicación:

• El método toArray() convierte la respuesta JSON de la API en una matriz PHP. Esta matriz contiene los datos de la receta (p. ej., nombre, ingredientes, instrucciones), que se utilizarán para completar la plantilla Twig en el siguiente paso.

Paso 4: renderizar la plantilla usando Twig

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

Explicación:

• El método render() del entorno Twig genera la salida de Markdown. Carga la plantilla (recipe.md.twig) desde la carpeta src/resources/views.
• Los datos de la receta obtenidos de la API ($recipeData) se pasan a la plantilla, donde reemplazarán los marcadores de posición como el nombre de la receta, los ingredientes y las instrucciones, creando un archivo Markdown completamente formateado.
• El contenido de Markdown renderizado (la cadena devuelta por el método render()) se almacena en la variable $markdownOutput.

Paso 5: generar resultados para el Markdown generado

$output->writeln($markdownOutput);

Explicación:

• El contenido final de Markdown se imprime en la consola usando el método $output->writeln(). Este método envía la cadena a la consola, lo que permite a los usuarios ver la receta formateada en formato Markdown (eventualmente, puede redirigir la salida a un archivo en el shell).

Creando el archivo de inicio

Tienes que crear un archivo de inicio para permitir al usuario ejecutar tu comando Symfony directamente desde el shell. (En este artículo, no estamos creando una aplicación Symfony; estamos construyendo un script PHP usando los paquetes Symfony).
En el directorio del proyecto, donde tiene el archivo compositor.json y donde tiene el directorio src, puede crear un archivo my-app.

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

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


$app->run();

Para usar correctamente los espacios de nombres y las clases, asegúrese de configurar la sección de carga automática en el archivo compositor.json:

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

Si cambia la sección de carga automática, le sugiero que descargue el archivo de carga automática:

composer dump-autoload

Ahora, debe crear la plantilla/vista de Twig para representar los datos recuperados por la API.

Crea una plantilla/vista de Twig para la receta.

A continuación, cree una plantilla/vista de Twig para representar la receta en formato Markdown.
Esta plantilla debe ir en el directorio de vistas (por ejemplo, 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!

Este archivo de vista de Twig representará la receta en formato Markdown, con secciones para el nombre, los ingredientes y las instrucciones de la receta.

Ejecutando el comando

Para ejecutar el comando, ejecute lo siguiente en la terminal:

php my-app

En caso de que tengas más de un comando, puedes ejecutar:

php m-app recipe

Para ver todos los comandos disponibles:

php my-app list

Conclusión

Con este enfoque, puedes recuperar fácilmente datos de una API externa usando el cliente HTTP de Symfony, procesar la respuesta y representar la salida en un formato estructurado usando Twig. En este caso, el comando genera una receta como Markdown, pero esta técnica se puede adaptar a cualquier otro contenido o tipo de datos que necesite procesar.
¡Disfruta tu receta!