Uso de Latte con Slim 4

Este artículo, escrito por Daniel Opitz, describe cómo usar Latte con Slim Framework.

Primero, instale Slim Framework y después Latte con Composer:

composer require latte/latte

Configuración

Cree un directorio nuevo templates en el directorio raíz de su proyecto. Todas las plantillas se guardarán allí más adelante.

Añada una nueva clave de configuración template en su archivo config/defaults.php:

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

Latte compila las plantillas a código PHP nativo y las guarda en una caché en disco. Así son tan rápidas como si se hubieran escrito en PHP nativo.

Añada una nueva clave de configuración template_temp en su archivo config/defaults.php: asegúrese de que el directorio {project}/tmp/templates existe y tiene permisos de lectura y escritura.

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

Latte regenera la caché automáticamente cada vez que cambia la plantilla, algo que se puede desactivar en el entorno de producción para ganar un poco de rendimiento:

// cámbielo a false en el entorno de producción
$settings['template_auto_refresh'] = true;

A continuación, añada una definición en el contenedor DI para la clase 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;
	},
];

Técnicamente, esto bastaría para renderizar una plantilla de Latte, pero además necesitamos que funcione con el objeto de respuesta PSR-7.

Para ello creamos una clase especial TemplateRenderer que hace ese trabajo por nosotros.

Cree entonces un archivo en src/Renderer/TemplateRenderer.php y copie y pegue 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;
	}
}

Uso

En lugar de usar directamente el objeto Latte Engine, usamos el objeto TemplateRenderer para renderizar la plantilla en un objeto compatible con PSR-7.

Una clase típica de manejador de acción podría tener este aspecto para renderizar una plantilla llamada 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, cree un archivo de plantilla en templates/home.latte con este contenido:

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

Si todo está bien configurado, debería ver la siguiente salida:

One
Two
Three