Introduction

Tout Temma en 3 minutes

Temma est un environnement de développement Modèle-Vue-Contrôleur (MVC en abrégé), pensé pour faciliter et accélérer les développements de sites web.

Le framework prend en charge les requêtes entrantes, vous évitant de redévelopper encore et encore les couches les plus basses de vos applications, vous laissant vous concentrer sur le «code métier», la partie la plus importante.

Sa philosophie : des conventions simples plutôt que de la configuration.

Aucune route à déclarer : par défaut, l'URL /articles/voir/2 appelle la méthode voir(2) du contrôleur Articles.
Aucune requête SQL à écrire pour les cas simples : le framework crée lui-même l'objet d'accès à la table correspondante.
Aucune vue à brancher : le template associé à l'action est interprété automatiquement ; pour les API, la vue JSON s'active en une ligne.

La suite de cette page le démontre sur un exemple complet.

0Avec un agent IA

Si vous développez avec un agent de codage (Claude Code, Codex, Copilot…), vous n'avez rien à installer à la main. Donnez-lui cette phrase :

Crée un site en utilisant Temma (temma.net/go)

L'agent lit temma.net/go, un guide d'installation exécutable : il vérifie les prérequis, crée le projet, configure la base de données et le serveur web, puis démarre le site. Il dispose ensuite des skills IA de Temma, installés dans le projet, pour écrire du code conforme aux conventions du framework.

La suite de cette page reste utile : elle explique comment Temma fonctionne, et donc ce que l'agent aura produit.

1Principes de base

Temma facilite le développement de sites constitués d'URL du type :

http://www.site.com/controller/action/p1/p2/p3

Les URL sont découpées en 3 parties :

Le nom du contrôleur, un objet qui va être instancié à la réception de la requête.
Le nom de l'action, une méthode de cet objet qui va être appelée.
Un nombre variable de paramètres, que cette méthode va pouvoir utiliser.

Le code suivant sera alors exécuté :

Controller::action(p1, p2, p3)

Par défaut, le framework générera une page en interprétant le fichier de template templates/controller/action.tpl

Côté modèle, Temma peut créer automatiquement une DAO (Data Access Object, objet d'accès aux données) : un objet qui lit et écrit dans la table portant le nom du contrôleur, sans SQL à écrire. Pour les requêtes complexes, vous reprenez la main en écrivant votre propre DAO.

Evidemment, il est possible de modifier les comportements par défaut. Un contrôleur peut choisir de lire des données reçues en POST au lieu − ou en plus − de celles reçues sur l'URL ou en paramètre GET. Une action peut définir un template spécifique à utiliser, voire même définir un type de vue complètement différent (qui génèrera du JSON ou du XML au lieu du HTML, par exemple).

La page du flux d'exécution détaille tout ce que fait Temma entre le moment où il reçoit la requête et celui où il envoie la réponse.

2Exemple de développement

Pour cet exemple, nous allons créer un site web très simple, avec deux pages :

/articles/liste : affiche la liste des articles.
/articles/voir/2 : affiche l'article dont l'identifiant est 2.

Cet exemple se lit sans rien installer.

Quatre fichiers sont concernés, indiqués en gras ci-dessous. Le fichier de configuration existe déjà après l'installation, et nous allons le remplir ; les trois autres sont ceux que nous allons écrire :

mon_projet/
    controllers/
        Articles.php
    etc/
        temma.php
    templates/
        articles/
            liste.tpl
            voir.tpl

Remarquez le répertoire templates/articles/ : son nom est celui du contrôleur, et le nom de chaque template qu'il contient est celui d'une action. C'est la convention de nommage évoquée plus haut.

2.1Configuration

La première chose à faire est de créer le fichier de configuration du projet. Il s'agit du fichier etc/temma.php.

Référez-vous à la documentation de la configuration pour connaître les différentes options.

L'installation de Temma fournit des exemples de fichiers, mais voici le contenu de celui que nous allons utiliser :

<?php

return [
    'application' => [
        'dataSources' => [
            // configuration de la base de données
            'db' => 'mysql://user:passwd@localhost/mybase'
        ],
        // configuration du contrôleur racine
        'rootController' => 'Articles'
    ],
    // seuil d'écriture des logs
    'loglevels' => 'WARN',
    // variables de template importées automatiquement
    'autoimport' => [
        'siteName' => 'Site de démo'
    ]
];

Ligne 7 : Configuration de la connexion à la base de données. La source est nommée db, qui est le nom recherché par défaut par la DAO.
Ligne 10 : La directive rootController sert à définir le contrôleur racine du site, c'est-à-dire celui qui répondra quand on se connectera à l'adresse http://www.mon-site.com/.
Ligne 13 : On définit le niveau minimal des erreurs qui seront enregistrées dans le fichier log/temma.log.
Ligne 16 : On définit une variable de template contenant le nom du site. Les variables importées automatiquement sont regroupées sous la variable conf ; celle-ci se lira donc dans les templates en écrivant {$conf.siteName}.

2.2Base de données

Avant tout, nous allons créer une table dans la base de données. Vous devez exécuter la requête suivante sur votre base :

CREATE TABLE articles (
    id     INT UNSIGNED AUTO_INCREMENT,
    title  TINYTEXT,
    text   MEDIUMTEXT,
    author TINYTEXT,
    PRIMARY KEY (id)
);

Deux détails de nommage ont ici leur importance, car c'est sur eux que Temma s'appuiera pour créer automatiquement la DAO qui fera la liaison avec cette table (nous le verrons dans la section suivante) :

La table s'appelle articles, comme le contrôleur que nous allons écrire.
Sa clé primaire s'appelle id.

Ce sont les deux conventions par défaut de Temma. Elles peuvent être changées (voir la documentation de la DAO générique), mais les respecter permet de n'avoir rien à configurer.

Et nous pouvons y ajouter des données :

INSERT INTO articles (title, text, author)
VALUES ('Premier article',   'Texte du premier article',   'John'),
       ('Second article',    'Texte du second article',    'Bob'),
       ('Troisième article', 'Texte du troisième article', 'John');

2.3Contrôleur

Nous allons écrire notre premier contrôleur. Un contrôleur est un objet qui reçoit les connexions et les gère pour envoyer des données en retour.
Les contrôleurs ont des actions, et chaque action peut recevoir des paramètres.

Notre contrôleur se nommera Articles. Plutôt que de l'écrire d'un seul coup, commençons par le strict nécessaire : de quoi afficher la liste des articles.

Dans le répertoire controllers/ de votre projet, créez un fichier nommé Articles.php.

Une ligne mérite l'attention avant de lire le code : $_temmaAutoDao. En déclarant cet attribut, on demande à Temma de créer automatiquement la DAO qui servira à accéder aux données. Elle sera configurée pour utiliser la table articles, en se basant sur le nom du contrôleur. Elle sera disponible dans l'attribut $this->_dao du contrôleur, qui pourra s'en servir pour interroger la base sans écrire de SQL.

<?php

/** Contrôleur de gestion des articles. */
class Articles extends \Temma\Web\Controller {
    /** Indique que le framework doit créer automatiquement la DAO. */
    protected $_temmaAutoDao = true;

    /** Action qui affiche la liste des articles. */
    public function liste() {
        // récupération de la liste d'articles depuis la base de données
        $articles = $this->_dao->search();

        // la liste est rendue disponible pour le template
        $this['articles'] = $articles;
    }
}

Ligne 4 : Les contrôleurs doivent hériter de l'objet \Temma\Web\Controller.
Ligne 6 : La DAO est demandée. Temma la crée avant que l'action ne soit exécutée.
Ligne 9 : L'action liste, qui répond à l'URL http://www.mon-site.com/articles/liste

Ligne 11 : La méthode search() de la DAO retourne toutes les lignes de la table, sous la forme d'une liste de tableaux associatifs dont les clés sont les noms des colonnes :

[
    ['id' => 1, 'title' => 'Premier article',   'text' => '...', 'author' => 'John'],
    ['id' => 2, 'title' => 'Second article',    'text' => '...', 'author' => 'Bob'],
    ['id' => 3, 'title' => 'Troisième article', 'text' => '...', 'author' => 'John'],
]

C'est cette structure que nous retrouverons dans le template.

Ligne 14 : On copie la valeur de la variable $articles dans la variable de template articles. Le template utilisé sera (implicitement) le fichier templates/articles/liste.tpl.

Cela suffit à faire fonctionner la page de liste. Voici maintenant le contrôleur complet : on y a ajouté l'action voir(), qui affiche un article seul, et l'action racine __invoke(), dont le seul rôle est de recevoir les connexions sur la racine du site et de les rediriger vers la liste des articles.

<?php

/** Contrôleur de gestion des articles. */
class Articles extends \Temma\Web\Controller {
    /** Indique que le framework doit créer automatiquement la DAO. */
    protected $_temmaAutoDao = true;

    /** Action racine (aucune action explicite). */
    public function __invoke() {
        // redirection vers la liste des articles
        $this->_redirect('/articles/liste');
    }

    /** Action qui affiche la liste des articles. */
    public function liste() {
        // récupération de la liste d'articles depuis la base de données
        $articles = $this->_dao->search();

        // la liste est rendue disponible pour le template
        $this['articles'] = $articles;
    }

    /**
     * Action qui affiche le contenu complet d'un article.
     * @param  int  $id  L'identifiant de l'article.
     */
    public function voir(int $id) {
        // récupération du contenu de l'article depuis la base de données
        $article = $this->_dao->get($id);

        // on vérifie si l'article demandé existe ou non
        if (!$article) {
            // il n'existe pas, on redirige vers la liste
            $this->_redirect('/articles/liste');
        } else {
            // il existe, on transmet les données au template
            $this['article'] = $article;
        }
    }
}

Ligne 9 : L'action racine est exécutée lorsqu'aucune action n'est spécifiquement demandée. Comme ce contrôleur a été défini comme étant le contrôleur racine (rootController dans le fichier etc/temma.php), il s'agit donc de l'action qui sera appelée lorsqu'on accède à la racine du site.
- Cette action répond aux deux URLs suivantes :
  http://www.mon-site.com/
  http://www.mon-site.com/articles
- Ligne 11 : L'internaute est redirigé vers la page qui affiche la liste des articles.
Ligne 27 : Action voir, qui affiche le contenu d'un article dont l'identifiant est fourni en paramètre sur l'URL. Le paramètre $id de la méthode reçoit la valeur lue sur l'URL, convertie en entier.
- Cette action répond à l'URL : http://www.mon-site.com/articles/voir/2
- Ligne 29 : La méthode get() de la DAO récupère une seule ligne à partir de son identifiant, et la retourne sous forme de tableau associatif (ou une valeur vide si elle n'existe pas).
- Ligne 34 : Si l'article n'existe pas, on redirige vers la liste des articles.
- Ligne 37 : Si l'article existe, on l'enregistre en variable de template. Le template utilisé sera (implicitement) le fichier templates/articles/voir.tpl.

2.4Templates

Temma utilise le moteur de templates Smarty, qui est très répandu et dont la syntaxe est très facile à comprendre.

Pour la page qui affiche la liste des articles, on va créer le fichier templates/articles/liste.tpl :

<html>
<head>
    <title>{$conf.siteName}</title>
</head>
<body>
    <ul>
        {* boucle sur la liste des articles *}
        {foreach $articles as $article}

            {* ajout d'un lien vers l'article *}
            <li>
                <a href="/articles/voir/{$article.id}">
                    {$article.title}
                </a>
            </li>

        {/foreach}
    </ul>
</body>
</html>

Ligne 3 : Le nom du site est placé dans la balise <title>. Il provient de la directive autoimport du fichier de configuration. Il est échappé, pour convertir les événtuels caractères spéciaux en entités HTML.
Ligne 8 : Boucle sur les éléments de la liste d'articles, celle que le contrôleur a stockée dans la variable de template articles.
Lignes 11 à 15 : Création du lien vers la page d'un article. Chaque $article est l'un des tableaux associatifs retournés par la DAO ; ses colonnes se lisent donc en écrivant {$article.id} et {$article.title}. Le titre de l'article est échappé automatiquement (les caractères spéciaux sont convertis en entités HTML).

Pour la page qui affiche un article, on créera le fichier templates/articles/voir.tpl :

<html>
<head>
    <title>{$conf.siteName}</title>
</head>
<body>
    {* affichage du titre de l'article *}
    <h1>{$article.title}</h1>

    {* affichage de l'auteur de l'article *}
    <h2>par {$article.author}</h2>

    <p>
        {* affichage du texte de l'article *}
        {$article.text|raw}
    </p>
</body>
</html>

Ligne 3 : Le nom du site est placé dans la balise <title>, et ses caractères spéciaux sont échappés automatiquement.
Ligne 7 : Le titre de l'article est placé dans une balise H1, et ses caractères spéciaux sont échappés automatiquement.
Ligne 10 : Le nom de l'auteur est placé dans une balise H2, et ses caractères spéciaux sont échappés automatiquement.
Ligne 14 : Le texte de l'article est placé dans un paragraphe (balise P), et on demande explicitement que son contenu ne soit pas échappé (c'est déjà du HTML).

2.5Récapitulatif

Voici ce que le navigateur affiche :

●●● www.mon-site.com/articles/liste

Premier article
Second article
Troisième article

●●● www.mon-site.com/articles/voir/1

Premier article

par John

Texte du premier article

Et voici l'enchaînement que Temma a suivi pour produire la page d'un article :

L'internaute demande /articles/voir/2.
Temma instancie le contrôleur Articles et crée sa DAO, configurée pour la table articles.
Temma appelle l'action voir(2), qui interroge la table via $this->_dao et dépose le résultat dans une variable de template.
Temma interprète le template templates/articles/voir.tpl avec cette variable, et renvoie le HTML obtenu.

Vous n'avez écrit ni requête SQL, ni code de routage, ni glue entre les couches : seulement les trois fichiers de l'exemple.

Dernier point : il suffit d'une ligne pour que ce contrôleur devienne une API renvoyant du JSON, grâce aux vues. Temma sait même faire de la négociation de contenu : le même contrôleur peut alors envoyer du HTML ou du JSON, en fonction de ce que le client demande.

3Pour aller plus loin

Installer Temma : créer un projet et le mettre en route.
Documentation complète de Temma
DAO générique : tout ce que sait faire l'objet $this->_dao (critères de recherche, tris, création, modification, suppression).
Contrôleurs : toutes les méthodes et tous les attributs disponibles dans vos contrôleurs.
Flux d'exécution : ce que fait Temma entre la requête et la réponse.
Tutoriels : des exemples complets, de l'API REST au chat temps réel.