Uso de Latte con Slim 4

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

Primero, instala el Slim Framework y luego Latte usando Composer:

composer require latte/latte

Configuración

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

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 almacena en una caché en el disco. Así son tan rápidas como si hubieran sido escritas en PHP nativo.

Añade una nueva clave de configuración template_temp en tu archivo config/defaults.php: Asegúrate de que el directorio {project}/tmp/templates existe y tiene permisos de acceso de lectura y escritura.

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

Latte regenera automáticamente la caché cada vez que cambia la plantilla, lo que puede desactivarse en el entorno de producción para ahorrar un poco de rendimiento:

// change to false in the production environment
$settings['template_auto_refresh'] = true;

A continuación, añada una definición de 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;
	},
];

Esto por sí solo funcionaría técnicamente para renderizar una plantilla Latte, pero también tenemos que hacer que funcione con el objeto de respuesta PSR-7.

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

Así que a continuación crea un archivo en src/Renderer/TemplateRenderer.php y copia/pega 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 utilizar directamente el objeto Latte Engine utilizamos el objeto TemplateRenderer para renderizar la plantilla en un objeto compatible con PSR-7.

Una clase manejadora de acción típica podría tener este aspecto para renderizar una plantilla con el nombre 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á configurado correctamente deberías ver la siguiente salida:

One
Two
Three