Twig é um mecanismo de modelagem ideal para renderizar HTML ao desenvolver aplicativos da web com Symfony.
No entanto, a flexibilidade do Twig vai além da geração apenas de páginas HTML. Pode ser uma ferramenta poderosa para fornecer conteúdo em vários canais, como geração de arquivos Markdown, saídas JSON e até mesmo texto simples, tudo a partir do mesmo conjunto de conteúdo.

Essa adaptabilidade permite criar conteúdo para diferentes canais.

Você pode usar o Twig para gerar HTML, Markdown, JSON, Texto etc

Caso de uso: buscando e renderizando uma receita como Markdown com Symfony

Neste exemplo, usamos o cliente HTTP do Symfony para buscar uma receita de uma API externa (https://dummyjson.com/recipes/1) e renderizá-la como um documento Markdown usando Twig.
Esta abordagem mostra como você pode combinar os pacotes poderosos do Symfony, como o cliente Symfony HTTP para recuperação de dados externos e o Twig para renderização de visualizações, para entregar conteúdo em vários canais, como relatórios Markdown em uma ferramenta de linha de comando.

O comando/script que vamos construir busca os dados da receita (título, descrição, ingredientes e instruções) da API, processa-os e então usa o Twig para gerar o conteúdo em um formato Markdown estruturado. Este caso de uso prático ilustra como usar o Twig além dos modelos web, tornando-o versátil para gerar conteúdo em vários formatos.

Então, vamos usar:

• Console Symfony Componente https://symfony.com/doc/current/components/console.html para construir uma ferramenta de linha de comando
• Cliente HTTP Symfony https://symfony.com/doc/current/http_client.html para buscar e consumir API HTTP
• Symfony Twig https://twig.symfony.com/doc/3.x/intro.html#installation para renderização de dados
• As receitas API: escolheremos uma receita "fictícia" https://dummyjson.com/recipes/1 para mostrar e demonstrar o processo de recuperação de um JSON estruturado e convertê-lo em um arquivo markdown .

Instalando os componentes necessários do Symfony

Certifique-se de ter os componentes necessários instalados para solicitações HTTP e criação de comandos:

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

Crie um comando Symfony

Primeiro, vamos criar um novo comando Symfony.

Se você quiser ler mais sobre como criar uma ferramenta de linha de comando usando o componente Symfony Command, escrevi um artigo específico sobre isso: https://dev.to/robertobutti/building-a-command-line-tool -com-php-e-symfony-console-4n6g

As classes de comandos geralmente vão para o diretório src/Commands.

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

Classe de comando (por exemplo, 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;
    }
}

Aqui está uma explicação detalhada de cada etapa no exemplo FetchRecipeCommand.

Análise passo a passo

Etapa 1: Carregando o ambiente twig

Para usar o Twig fora de seu contexto web típico, como em uma ferramenta de linha de comando PHP, primeiro você precisa inicializá-lo manualmente por meio da classe Twig\Environment. Aqui está um exemplo de configuração para Twig em um comando 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;

Explicação:

• O ambiente twig é inicializado criando um FilesystemLoader que informa ao Twig onde encontrar os modelos. Este caso aponta para a pasta src/resources/views onde seus modelos Twig estão armazenados.
• Em seguida, o ambiente $twig é instanciado e responsável por renderizar os templates. O cache opcional pode ser ativado para melhorar o desempenho armazenando modelos pré-compilados.
• Finalmente, o ambiente $twig inicializado é atribuído a $this->twig para uso posterior (no método execute()).

Etapa 2: inicializar o cliente HTTP e buscar a receita

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

Explicação:

• O cliente HTTP Symfony é criado usando o método HttpClient::create(), que permite que o comando execute solicitações HTTP.
• Para buscar uma receita, o método request() executa uma solicitação GET para o URL especificado (https://dummyjson.com/recipes/1).
• A API retorna uma resposta JSON armazenada na variável $response.

Etapa 3: obter o conjunto de informações

$recipeData = $response->toArray();

Explicação:

• O método toArray() converte a resposta JSON da API em um array PHP. Este array contém os dados da receita (por exemplo, nome, ingredientes, instruções), que serão usados ​​para preencher o modelo Twig na próxima etapa.

Etapa 4: renderizar o modelo usando Twig

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

Explicação:

• O método render() do ambiente Twig gera a saída Markdown. Ele carrega o modelo (recipe.md.twig) da pasta src/resources/views.
• Os dados da receita obtidos da API ($recipeData) são passados ​​​​para o modelo, onde substituirão marcadores como nome da receita, ingredientes e instruções, criando um arquivo Markdown totalmente formatado.
• O conteúdo Markdown renderizado (a string retornada pelo método render()) é armazenado na variável $markdownOutput.

Etapa 5: gerando saída para o Markdown gerado

$output->writeln($markdownOutput);

Explicação:

• O conteúdo final do Markdown é impresso no console usando o método $output->writeln(). Este método envia a string para o console, permitindo que os usuários vejam a receita formatada no formato Markdown (eventualmente, você pode redirecionar a saída para um arquivo no shell).

Criando o arquivo inicial

Você deve criar um arquivo inicial para permitir que o usuário inicie seu comando Symfony diretamente do shell. (Neste artigo, não estamos criando um aplicativo Symfony; estamos construindo um script PHP usando os pacotes Symfony.)
No diretório do projeto, onde você tem o arquivo compositor.json e onde você tem o diretório src, você pode criar um arquivo my-app.

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

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


$app->run();

Para usar corretamente os namespaces e as classes, certifique-se de definir a seção autoload no arquivo compositor.json:

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

Se você alterar a seção de carregamento automático, sugiro despejar o arquivo de carregamento automático:

composer dump-autoload

Agora, você deve criar o modelo/visualização Twig para renderizar os dados recuperados pela API.

Crie um modelo/visualização Twig para a receita

Em seguida, crie um modelo/visualização Twig para renderizar a receita no formato Markdown.
Este modelo deve estar no diretório de visualizações (por exemplo, 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 arquivo de visualização Twig renderizará a receita no formato Markdown, com seções para o nome da receita, ingredientes e instruções.

Executando o comando

Para executar o comando, execute o seguinte no terminal:

php my-app

Caso você tenha mais de um comando, você pode lançar:

php m-app recipe

Para ver todos os comandos disponíveis:

php my-app list

Conclusão

Com essa abordagem, você pode facilmente recuperar dados de uma API externa usando o cliente HTTP do Symfony, processar a resposta e renderizar a saída em um formato estruturado usando Twig. Neste caso, o comando gera uma receita como Markdown, mas esta técnica pode ser adaptada a qualquer outro conteúdo ou tipo de dados que você precise processar.
Aproveite sua receita!