Utilisation de Latte avec Slim 4
********************************

.[perex]
Cet article écrit par "Daniel Opitz":https://odan.github.io/2022/04/06/slim4-latte.html décrit comment utiliser Latte avec le Framework Slim.

Tout d'abord, "installez le Slim Framework":https://odan.github.io/2019/11/05/slim4-tutorial.html et ensuite Latte en utilisant Composer :

```shell
composer require latte/latte
```


Configuration .[#toc-configuration]
-----------------------------------

Créez un nouveau répertoire `templates` dans le répertoire racine de votre projet. Tous les modèles y seront placés ultérieurement.

Ajoutez une nouvelle clé de configuration `template` dans votre fichier `config/defaults.php`:

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

Latte compile les modèles en code PHP natif et les stocke dans un cache sur le disque. Ils sont donc aussi rapides que s'ils avaient été écrits en PHP natif.

Ajoutez une nouvelle clé de configuration `template_temp` dans votre fichier `config/defaults.php`: Assurez-vous que le répertoire `{project}/tmp/templates` existe et qu'il dispose des droits d'accès en lecture et en écriture.

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

Latte régénère automatiquement le cache chaque fois que vous modifiez le modèle, ce qui peut être désactivé dans l'environnement de production pour gagner un peu de performance :

```php
// changer en false dans l'environnement de production
$settings['template_auto_refresh'] = true;
```

Ensuite, ajoutez une définition de conteneur DI pour la classe `Latte\Engine`.

```php
<?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;
	},
];
```

Techniquement, cela suffirait à rendre un modèle de Latte, mais nous devons également le faire fonctionner avec l'objet de réponse PSR-7.

À cette fin, nous créons une classe spéciale `TemplateRenderer` qui effectue ce travail pour nous.

Créez ensuite un fichier dans `src/Renderer/TemplateRenderer.php` et copiez/collez ce code :

```php
<?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;
	}
}
```


Utilisation .[#toc-usage]
-------------------------

Au lieu d'utiliser directement l'objet Latte Engine, nous utilisons l'objet `TemplateRenderer` pour rendre le modèle dans un objet compatible PSR-7.

Une classe de gestionnaire d'action typique pourrait ressembler à ceci pour rendre un modèle avec le nom `home.latte`:

```php
<?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);
	}
}
```

Pour que cela fonctionne, créez un fichier modèle dans `templates/home.latte` avec ce contenu :

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

Si tout est configuré correctement, vous devriez voir la sortie suivante :

```latte
One
Two
Three
```

{{priority: -1}}
{{leftbar: /@left-menu}}