08 — Le service App\Renderer : Rendu des vues

Définition

Le Renderer est le service responsable de transformer un fichier de vue PHP en HTML complet, en l’injectant dans un layout (mise en page globale). C’est le moteur de template de notre application.

🔗 Comparaison Laravel

Notre blog	Laravel (Blade)
Renderer::render('blog/index', $data, 'blog-layout')	return view('blog.index', $data)
Layout défini par le 3ème paramètre	Layout défini avec @extends('layouts.app')
Variables passées via $data	Variables passées via view()->with($data)
HTML pur dans les vues	Directives Blade (@if, @foreach, etc.)

Notre Renderer est l’équivalent basique du système de templates Blade de Laravel.

📄 Notre classe App\Renderer

<?php

declare(strict_types=1);

namespace App;

class Renderer
{
    public static function render(
        string $path,
        array $variables = [],
        string $layout = 'blog-layout'
    ): void {
        // Extraction des variables
        extract($variables);

        // Capture du contenu de la vue
        ob_start();
        require_once __DIR__ . '/../resources/views/' . $path . '_html.php';
        $pageContent = ob_get_clean();

        // Rendu dans le layout
        require_once __DIR__ . '/../resources/views/layouts/' . $layout . '/' . $layout . '_html.php';
    }
}

Analyse pas à pas

1. extract($variables)

extract($variables);

La fonction extract() prend un tableau associatif et crée une variable PHP pour chaque paire clé/valeur.

$variables = ['pageTitle' => 'Mon Blog', 'articles' => [...]];
extract($variables);
// Équivaut à :
$pageTitle = 'Mon Blog';
$articles = [...];

Ces variables seront ensuite disponibles dans les fichiers de vue.

2. Capture avec ob_start() / ob_get_clean()

ob_start();
require_once __DIR__ . '/../resources/views/' . $path . '_html.php';
$pageContent = ob_get_clean();

Le tampon de sortie (Output Buffer) est une technique PHP fondamentale :

• ob_start() : active la capture. Tout ce qui serait normalement affiché est mis en mémoire.
• require_once ... : charge la vue. Elle génère du HTML qui va dans le tampon.
• ob_get_clean() : récupère le HTML du tampon et le vide. Le HTML est stocké dans $pageContent.

Résultat : La vue est exécutée mais son HTML n’est pas encore affiché. Il est stocké dans $pageContent.

En Laravel, Blade compile les templates .blade.php en PHP pur et utilise le même mécanisme de tampon en interne.

3. Rendu dans le layout

require_once __DIR__ . '/../resources/views/layouts/' . $layout . '/' . $layout . '_html.php';

Le layout est simplement inclus. À l’intérieur du fichier de layout (blog-layout_html.php), la variable $pageContent est affichée :

<main>
    <?= $pageContent ?>
</main>

4. Résolution du chemin

Pour Renderer::render('blog/index', [], 'blog-layout') :

• Vue chargée : resources/views/blog/index_html.php
• Layout chargé : resources/views/layouts/blog-layout/blog-layout_html.php

Utilisation dans les contrôleurs

// Syntaxe complète
Renderer::render('blog/index', [
    'pageTitle' => 'Accueil',
    'articles'  => $articles,
], 'blog-layout');

// Avec la fonction globale définie dans helpers.php
render('blog/index', [
    'pageTitle' => 'Accueil',
    'articles'  => $articles,
]);

🔮 Vers Blade (Laravel)

En Laravel, view() est encore plus puissant :

// Laravel
return view('blog.index', compact('articles'))
    ->with('pageTitle', 'Accueil');

Et dans la vue Blade, on utilise des directives :

@extends('layouts.blog') @section('content') @foreach($articles as $article)
<h2>{{ $article->title }}</h2>
@endforeach @endsection

Notre Renderer est l’étape de compréhension avant Blade. Les concepts (layout, extraction de variables, tampon de sortie) sont exactement les mêmes, juste avec une syntaxe plus moderne dans Laravel.