Usando Latte com Slim 4

Este artigo escrito por Daniel Opitz descreve como usar o Latte com a estrutura Slim.

Primeiro, instalar o Slim Framework e depois o Latte usando o Composer:

composer require latte/latte

Configuração

Crie um novo diretório templates no diretório raiz de seu projeto. Todos os modelos serão colocados lá mais tarde.

Adicione uma nova chave de configuração template em seu arquivo config/defaults.php:

$settings['template'] = __DIR__ . '/../templates';

O Latte compila os modelos em código PHP nativo e os armazena em um cache no disco. Portanto, eles são tão rápidos como se tivessem sido escritos em PHP nativo.

Adicione uma nova chave de configuração template_temp em seu arquivo config/defaults.php: Certifique-se de que o diretório {project}/tmp/templates existe e tem permissões de acesso de leitura e escrita.

$settings['template_temp'] = __DIR__ . '/../tmp/templates';

O Latte regenera automaticamente o cache cada vez que você muda o modelo, que pode ser desligado no ambiente de produção para economizar um pouco de desempenho:

// mudança para falso no ambiente de produção
$settings['template_auto_refresh'] = true;

Em seguida, acrescente uma definição de recipiente DI para a classe Latte\Engine.

<?php

use Latte\Engine;
use Latte\Loaders\FileLoader;
use Psr\Container\ContainerInterface;
// ...

return [

	// ...

	Engine::class => function (ContainerInterface $container) {
		$latte = new Engine();
		$settings = $container->get('settings');
		$latte->setLoader(new FileLoader($settings['template']));
		$latte->setTempDirectory($settings['template_temp']);
		$latte->setAutoRefresh($settings['template_auto_refresh']);

		return $latte;
	},
];

Só isso, tecnicamente, funcionaria para renderizar um modelo Latte, mas também precisamos fazê-lo funcionar com o objeto de resposta PSR-7.

Para este fim, criamos uma classe especial TemplateRenderer que faz este trabalho para nós.

Então, em seguida crie um arquivo em src/Renderer/TemplateRenderer.php e copie/colar este código:

<?php

namespace App\Renderer;

use Latte\Engine;
use Psr\Http\Message\ResponseInterface;

final class TemplateRenderer
{
	public function __construct(
		private Engine $engine,
	) {
	}

	public function template(
		ResponseInterface $response,
		string $template,
		array $data = [],
	): ResponseInterface
	{
		$string = $this->engine->renderToString($template, $data);
		$response->getBody()->write($string);

		return $response;
	}
}

Utilização

Em vez de usar o objeto Latte Engine diretamente, usamos o objeto TemplateRenderer para tornar o modelo em um objeto compatível com PSR-7.

Uma classe de Action handler típica pode parecer-se com esta para renderizar um modelo com o nome home.latte:

<?php

namespace App\Action\Home;

use App\Renderer\TemplateRenderer;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

final class HomeAction
{
	public function __construct(
		private TemplateRenderer $renderer,
	) {
	}

	public function __invoke(
		ServerRequestInterface $request,
		ResponseInterface $response,
	): ResponseInterface
	{
		$viewData = [
			'items' => ['one', 'two', 'three'],
		];

		return $this->renderer->template($response, 'home.latte', $viewData);
	}
}

Para que funcione, crie um arquivo modelo em templates/home.latte com este conteúdo:

<ul n:if="$items">
	{foreach $items as $item}
		<li id="item-{$iterator->counter}">{$item|capitalize}</li>
	{/foreach}
</ul>

Se tudo estiver configurado corretamente, você deve ver a seguinte saída:

One
Two
Three