Templeet est un moteur de templates. Les templates se trouvent dans le répertoire "template" à la racine de l'installation de Templeet. Les URL accédées ont leur contrepartie dans le repertoire "template".

Si Temnpleet est installé à la racine de http://example.com/ en accédant à cette même URL c'est le fichier "template/index.html" qui sera utilisé pour construire la page. Si l'URL appelée est http://example.com/test/mapage.html alors le fichier utilisé sera "template/test/mapage.html".

Dans un template les fonctions écrites en Templeet seront évaluées, le reste ne sera pas modifié. Une fonction Templeet est précédée du caractère tilde : ~ et les paramètres sont passés entre parenthèse séparés par des virgules.

bla bla     <-- ce texte sera renvoyé tel quel
~time()	    <-- ceci est une fonction Templeet 
~cuthtml('"Bonjour, <b><u>Le Monde!</u></b>", hurla l\'écho.',15)	  <-- ceci est une fonction Templeet avec deux paramètres

Les fonctions Templeet placées en paramètre d'une autre fonction Templeet n'ont pas besoin d'être précédées du tilde:

~rem(                              <-- ceci est une fonction Templeet dans le corps du template. 
                                       Le tilde est nécessaire
  now=time(),                      <-- now=time() est un paramètre de la fonction rem
                                       Le tilde n'est pas nécessaire

  t="now est égal à ~string(now)"  <-- la fonction string est à l'intérieur d'une chaîne
                                       Le tilde est nécessaire
)

La plupart des fonctions PHP qui ne prennent pas de paramètre par référence, peuvent être appelées directement dans Templeet:

~md5("Les sanglots longs des violons de l'automne")    =>	  bd5a0565059a60f304f93926daecef06

Les variables sont identifiées par des chaînes de caractères commençant par une lettre ou un "underscore" _ et suivi éventuellement de caractères alphanumériques.

~rem(
  a=5;                               <- a est un nom de variable valide
  8xx=9;                             <- 8xx n'est PAS un nom de variable valide
)

La portée des variables est globale par défaut. On peut limiter la portée des variables soit à une fonction soit à un fichier include.

• les variables locales à une fonction sont précédées du caractère '#'
• les variables locales à un fichier include sont précédées du caractère '$'

 Exemple de variable locale à une fonction:

~rem(
   function factorielle(#n)
     {
       if(#n==1,
           1,
          #n*factorielle(#n-1)
         )  
     }
)

la factorielle de 5 est : ~factorielle(5)

Exemple de variable locale à in fichier inclus:

Le fichier à inclure  "fichierinclus.tmpl" :

~rem(
  $x="dans le fichier inclus";
)
Dans fichierinclus.tmpl: 
x: ~string(x)
$x: ~string($x)

Le template:

~rem(
   x="variable globale";
   $x="variable locale au template principal";
)

Avant include:
x: ~string(x)
$x: ~string($x)

~include("fichierinclus.tmpl") 

Après include:
x: ~string(x)
$x: ~string($x)

Le résultat est:

Avant include:
x: variable globale
$x: variable locale au template principal

Dans fichierinclus.tmpl: 
x: variable globale
$x: dans le fichier inclus 

Après include:
x: variable globale
$x: variable locale au template principal

Les opérateurs unaires disponibles dans Templeet sont:

-	moins unaire
!	non booléen

Les opérateurs binaires sont par ordre de précédence:

.	concaténation de chaînes
*	multiplication
/	division
%	modulo
-	soustraction
+	addition
<<	décalage binaire à gauche
>>	décalage binaire à droite
<=	inférieur ou égal
>=	supérieur ou égal
<	inférieur
>	supérieur
===	égalité stricte de contenu et de type
==	égalité
!==	différence stricte
!=	différence
&&	et logique
||	ou logique
&	& binaire
^	ou exclusif binaire
|	ou binaire
.=	concaténation/affectation
*=	multiplication/affectation
/=	division/affectation
%=	modulo/affectation
-=	soustraction/affectation
+=	addition/affectation
&=	et bianire/affectation
^=	ou exclusif binaire/affectation
|=	ou binaire/affectation
=	affectation

Apostrophes et guillemets :

Dans le langage Templeet les apostrophes ' ou les guillemets " délimitent des chaînes de caractères. Les instructions Templeet étant interprétées dans les chaînes, celles-ci peuvent contenir aussi bien du texte que des instructions. Par exemple :

~if(10>1,
    'Voici le premier bloc délimité par des apostrophes
      ~if(empty(foo), 
           foo=10,
           "Un autre bloc délimité par des guillemets"
         )
    ',
    'Voici un second bloc délimité par des apostrophes'
    )

Au cas où la chaîne devrait contenir le délimiteur, celui-ci doit être échappé avec le caractère \ :

'Vous qui ne savez pas combien l\'enfance est belle,' <- la chaîne est délimitée par des apostrophes,
                                                         l'apostrophe dans la chaîne doit être échappée

"Enfant ! n'enviez point notre âge de douleurs,"      <- la chaîne est délimitée par des guillemets
                                                         l'apostrophe n'a pas besoin d'être échappée

Chaînes <![nomdelachaine[ ... ]nomdelachaine]> :

Toutefois, lorsque vous avez à implémenter des algorithmes plus complexes qui nécessitent des conditions imbriquées ou que vous avez besoinde manipuler des chaînes qui contiennent des apostrophes et des guillemets, il devient difficile de repérer le début et la fin d'une chaîne.
Pour faire face à ce problème vous pouvez utiliser une autre syntaxe pour délimiter les chaînes: <![nomdelachaine[ ... ]nomdelachaine]>. Ces chaînes de caractères sont des chaînes au même titre que celles délimitées par des apostrophes et des guillemets. Seule la délimitation de ces chaînes changent. On notera que dans ces chaînes, ni les guillemets ni les apostrophes n'ont besoin d'être échappés.

Exemple :

~if(10>1,
     <![bloc1[
        Voici le premier bloc nommé "bloc1"
        ~if(empty(foo),
             foo=10,
             <![foo[ Un autre bloc nommé "foo" ]foo]>
           )
     ]bloc1]>,
 <![foo[ Encore un autre bloc nommé "foo" ]foo]>
)

Accolades { et } :

Les blocs définis par des accolades ont un fonctionnement particulier.

Les instructions sont séparées par des virgules "," ou des points-virgules ";". Comme dans l'exemple ci-dessous :

~string(
    {
      i=2,
      j=3;
      j;
      i+j
    }
)

Le rendu de ce script sera :

5

Comme vous pouvez le remarquer la valeur 3 renvoyée par j n'est pas affichée. En effet, seule la dernière instruction du bloc est retournée.

Il est possible d'intégrer des commentaires dans vos scripts dont le contenu ne sera pas traité par Templeet (contrairement à la commande ~rem())

Pour cela il faut soit utiliser les caractères // ou le bloc /* ... */ à l'intérieur d'une instruction Templeet.

Exemple :

~string(
        // Ceci est un commentaire d'une seule ligne

       /*
           Ceci est un commentaire 
           sur plusieurs lignes
        */
)

• all_lang: tableau des langues dans lesquelles existe la page vue.

Pour plus de précision voir la gestion des langues

• HTTP_Content_type: définit l'entête HTTP Content-type à retourner
• HTTP_charset: définit l'entête HTTP charset à associer au Content-type
• HTTP_filename: définit une entête HTTP "Content-disposition: attachment;"
• HTTP_nocache: si diifférent de 0 les entêtes de désactivation des caches navigateurs et des proxies sont envoyées.
  

La variable HTTP_nocache est gérée par la fonction dont_cache() . Elle n'est donc normalement pas utilisée directement.

Les objets PHP peuvent être utilisés directement dans Templeet. Toutefois ils ne peuvent être déclarés avec une syntaxe Templeet.

Exemple:

~rem(
   eval_php(
     <![PHP[
       class ma_classe {
         private $var;
         function __construct($x) 
           {
             $this->var=$x;
           }
           
         function plus($y)
           {
             return $this->var+$y;
           }  
       }
     ]PHP]>);

  objet=new ma_classe(3);

)
~string(objet->plus(4))

Le résultat est:

7

Voir également la fonction new

Le cache de page permet de servir une page sans que celle ci soit recalculée à chaque fois. Ce système permet d'avoir des gains en performance importants. Si en plus Templeet est configuré pour gérer l'erreur 404 et que le cache de page se trouve à la racine de Templeet alors la performance est maximale. L'installeur tentera de configurer Templeet de cette manière chaque fois que c'est possible. Si ça ne l'est pas alors il donne des indications pour configurer le serveur de manière à ce que cela soit possible.

Pour la majorité des fonctions la configuration du cache n'a pas d'importance. Les autres mode de fonctionnement ne présentant aucune difficulté particulière, il sera supposé dans la suite de la documentation que le cache de page est configuré de manière optimale (gestion de l'erreur 404 et cache à la racine de Templeet)

Principe général de fonctionnement du cache de page de Templeet: quand une page cachable est demandée, si Apache la trouve elle est retournée immédiatement sans appel à Templeet d'où un gain en performances très important. Si la page demandée n'existe pas alors Templeet calcule la page, la met en cache pour les requêtes suivantes et la retourne au navigateur.

Des fonctions utilisateur peuvent être définies et être appelées de la même manière que les fonctions de bibilothèque. La syntaxe est la suivante:

~rem(
   function mafonction(#parametre1,#parametre2)
     {
       "paramètre 1:".#parametre1." paramètre 2:".#parametre2;
     };
)

~mafonction("un","deux")

Le résultat est:

paramètre 1:un paramètre 2:deux

Les fonctions peuvent également être définie à l'aide de la fonction defunc .

Cette fonction effectue un test et retourne le 2ème argument si le test est vrai, sinon et s'il existe, le 3ème argument est retourné.

~if(1<2,"c'est vrai!","c'est faux!")

L'exemple précédent retournera:

c'est vrai! 

Cette commande prend 2 arguments, elle évalue le 2ème tant que le 1er retourne vrai.

~rem(counter=1)
~while(counter<=3,
         'on compte ... ~string(counter)
~rem(counter=counter+1)'
       ) 

Comme souvent, il est possible d'écrire le même programme de différentes manières:

~string(
  {
    counter=1;
    while(counter<=3,
           'on compte ... '.counter.'\n'.rem(counter+=1)
         ) 
  })      

Dans un souci de concision les exemples donnés à partir d'ici seront des extraits de code. En particulier les exemples pourront être donnés sans la syntaxe complète avec tilde mais seront généralement supposés être des paramètres de fonctions Templeet.

Cette fonction prend 4 arguments, elle évalue le 4ème tant que le 2ème retourne vrai. Le premier argument est le code d'initialisation, le 3ème celui d'incrémentation.

~for(counter=1,counter<=3,counter+=1,
  'on compte ... ~string(counter) '
)

Le résultat est:

on compte ... 1 on compte ... 2 on compte ... 3 

La fonction foreach permet de faire une itération sur un tableau ou un objet. Elle peut prendre 3 ou 4 arguments.

• 3 arguments: foreach(objet,variable_de_valeur,expression)
• 4 arguments: foreach(objet,variable_de_valeur,variable_de_clef,expression)

Exemple avec 3 arguments:

~foreach(array(
                "clef1" => "valeur1",
                "clef2" => "valeur2",
                "clef3" => "valeur3"),
                valeur,
                "la valeur est ~string(valeur) <br />"
)

Le résultat est:

la valeur est valeur1 
la valeur est valeur2 
la valeur est valeur3

Exemple avec 4 arguments:

~foreach(array(
                "clef1" => "valeur1",
                "clef2" => "valeur2",
                "clef3" => "valeur3"),
                valeur,clef,
                "la clef est ~string(clef) la valeur est ~string(valeur) <br />"
)

Le résultat est:

la clef est clef1 la valeur est valeur1 
la clef est clef2 la valeur est valeur2 
la clef est clef3 la valeur est valeur3

Exemple avec un objet:

~rem(      
      doc=new('DOMDocument');
      doc->loadXML(<![XML[<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE doc>
<doc>
<elt1>contenu 1</elt1>
<elt2>
   <un_element_inclus>
     contenu inclus
   </un_element_inclus>
</elt2>
<elt3></elt3>
<elt1></elt1>
</doc>

]XML]>);
      xpath =new('DOMXPath',doc);
      elements = xpath->query("//doc/*");
)

~foreach(elements,valeur,clef,
            "numéro du nœud: ~string(clef) nom du nœud: ~string(valeur->nodeName)<br />"
)

Le résultat est:

numéro du nœud: 0 nom du nœud: elt1
numéro du nœud: 1 nom du nœud: elt2
numéro du nœud: 2 nom du nœud: elt3
numéro du nœud: 3 nom du nœud: elt1

La fonction break permet de sortir immédiatement d'une boucle while, for ou foreach.

~rem(
  arr = array('un', 'deux', 'trois', 'quatre', 'stop', 'cinq');
)
~foreach(arr,value,
  {
    if(value=='stop',break());
    value."\n";
  }
 )

Le résultat est:

un
deux
trois
quatre

Cette commande effectue une série de tests. Les arguments sont passés deux par deux. Le premier d'une paire est un test, le deuxième est la valeur à renvoyer si le test est vrai. L'évaluation de switch s'arrête au premier test qui retourne vrai. Il est possible de renvoyer une valeur par défaut si tous les tests ont échoué, il suffit de la mettre comme dernier argument.

x=1;
switch(
    x<0,"x est négatif",
    x>0,"x est positif",
    "x est nul"
)

L'exemple précédent retournera "x est positif".

La fonction rem a pour propriété de ne rien retourner. Toutefois tous les paramètres sont évalués. Cette fonction est donc pratique pour mettre du code Templeet sans se soucier de ce qui est retourné.

Cette fonction permet d'inclure un autre template. Par défaut elle utilise le répertoire du template père.

Des arguments peuvent être passés à la commande ~include(), et ils peuvent être utilisés dans le template inclus grâce à la commande ~parseparam().

Exemple :

Contenu du fichier "index.html" :

~include('fichier.tmpl',"1er argument", 10)

Contenu du fichier "fichier.tmpl" :

Le premier argument est : ~parseparam(1)
Le second argument est : ~parseparam(2)

Le résultat est :

Le premier argument est : 1er argument
Le second argument est : 10

Un template pourra récupérer les arguments passés au moment de l'include. Dans l'exemple ci dessus ~parseparam(1) retourne "1er argument" (sans les "), et ~parseparam(2) retourne "10" (sans les ").

Un template inclus peut également retourner un tableau.

Exemple:

Contenu du fichier "index.html":

~rem(
  // initialiser la variable montableau avec le tableau retourné par le fichier inclus.
   montableau=include("fichier.tmpl");
)

Contenu du fichier "fichier.tmpl":

~array(
  "une clef" => "une valeur",
  "une autre clef" => "une autre valeur"
)

Lorsqu'un fichier inclus retourne un tableau il faut être attentif à ne pas laisser de caractères "espace" ou "retour chariot" en fin de fichier sinon le contenu est transformé en chaîne de caractères.

Cette fonction est liée à la fonction include. Elle permet de récupérer les paramètres passé lors du ~include(). Voir ci-dessus.

Cette fonction est identique à la fonction include si ce n'est que l'inclusion effective ne se fait qu'une seule fois si la fonction est appelée plusieurs fois.

Les fonctions set et ~get sont obsolètes en Templeet 4. La syntaxe pour manipuler les variables est maintenant la suivante:

x=1;
y=x;

Voir la fonction set.

La fonction inc est obsolète en Templeet 4. La syntaxe utilisée pour incrémenter est maintenant la suivante:

x+=1
ou
x=x+1

La fonction dec est obsolète en Templeet 4. La syntaxe utilisée pour décrémenter est maintenant la suivante:

x-=1
ou
x=x-1

La fonction isset permet de tester l'existence d'une variable.

Exemple:

isset(x):~isset(x)
~rem(x=1)
isset(x):~isset(x)
~unset(x)
isset(x):~isset(x)

Le résultat est:

isset(x):
isset(x):1
isset(x):

La fonction unset permet de supprimer une variable. Voir l'exemple de la fonction isset.

Cette fonction permet de savoir si une expression est vide. Une expression est dite vide si elle est égale à 0, à une chaîne vide ou à NULL.

Exemple:

empty(1):~empty(1)
empty(0):~empty(0)
empty("abcd"):~empty("abcd")
empty(""):~empty("")
empty(NULL):~empty(NULL)

Le résultat est:

empty(1):
empty(0):1
empty("abcd"):
empty(""):1
empty(NULL):1

Cette fonction permet d'obtenir la valeur des variables de configuration de Templeet définies dans templeet/config.php et templeet/serverconf.php.

Exemple pour connaitre le répertoire où Templeet a été installé:

Le répertoire d'installation de Templeet est: ~getconf('dir_installed')

La fonction string retourne une chaine de caractère correspondant à la concaténation de ses paramètres. Typiquement elle est utilisée pour récupérer la valeur d'une variable au milieu d'un texte.

Exemple:

~rem(
  x=1;
)
La valeur de x est ~string(x)

La fonction noeval est une fonction neutre. Le code contenu dedans n'est pas exécuté. Cette fonction sert essentiellement à des fins de debugage.

Cette fonction permet d'évaluer du code Templeet. Ainsi du code Templeet peut être généré dynamiquement dans une variable, puis évalué plus tard.

~eval('~rem(une_variable=10) ~string(une_variable)')

Cette commande mettra "10" dans la variable "une_variable", puis retournera le contenu de cette même variable.

Voir également les fonctions anonymes.

La fonction evalphp permet d'insérer du code PHP dans un template.

Exemple:

~rem(
   eval_php(
     <![PHP[
       class ma_class {
         private $var;
         function __construct($x) 
           {
             $this->var=$x;
           }
           
         function plus($y)
           {
             return $this->var+$y;
           }  
       }
     ]PHP]>);

  objet=new ma_class(3);

)
~string(objet->plus(4))

La fonction evalphp est obsolète. Elle a été remplacée par eval_php.

La fonction include_php permet de charger un fichier php.

Exemple:

Contenu du fichier include.php:

<?php
       class ma_class {
         private $var;
         function __construct($x) 
           {
             $this->var=$x;
           }
           
         function plus($y)
           {
             return $this->var+$y;
           }  
       }
?>

Contenu du template:

~rem(
  include_php(getconf("templatedir").includedir."/include.php");
  objet=new ma_class(3);
)
~string(objet->plus(4))

Cette fonction permet de créer un tableau de données.

Exemple:

~rem(
  tab=array(
        "foo"=>1,
        "bar"=>2
      )
)

la valeur de tab["foo"] est: ~string(tab["foo"])
la valeur de tab["bar"] est: ~string(tab["bar"])

Le résultat est:

la valeur de tab["foo"] est: 1
la valeur de tab["bar"] est: 2

Cette fonction permet de créer un nouvel objet. Des exemples sont donnés dans la description des fonctions eval_php et include_php

Cette permet de gérer les exceptions. Le premier paramètre de la fonction est le code à essayer. Ensuite les paramètres sont passés deux par deux. Le premier de ces deux est le nom de l'exception et le deuxième, le code à exécuter pour cette exception.

Exemple:

~eval_php(<![PHP[
class MonException1 extends Exception { }
class MonException2 extends Exception { }
class MonException3 extends Exception { }
]PHP]>) 

~try(
     {
       try(
         {
          throw(new MonException2());
           "No exception"
         },
         "MonException1",
         {
           "catch MonException1\n";
         },
         "MonException2",
         {
           "catch MonException2\n";
         }
       )
     },
     "MonException3",
     {
       "catch MonException3\n";
     })

Le résultat est:

catch MonException2

Cette fonction permet de déclencher une exception. Voir l'exemple avec la fonction try.

La fonction cached sert à savoir si la page doit être mise en cache ou pas.

Exemple:

~if(cached(),
    "la page est mise dans le cache de pages",
    "la page n'est pas mise dans le cache de pages")

Cette fonction est identique à la fonction mt_rand excepté que le random retourné est cryptographique.

Cette fonction retourne une chaîne de caractères aléatoires composée de chiffres et de lettres (minuscules et majuscules).

Elle prend un paramètre qui est la longueur de la chaîne à retourner.

La chaîne aléatoire est cryptographiquement sure.

La fonction redirect envoie immédiatement un redirect HTTP.

Elle prend 2 paramètres:

• L'URL de redirection
• le status (optionnel, 302 par défaut)

Exemple:

~redirect("http://www.templeet.org/",303)

Cette fonction permet de connaitre le temps exprimé en secondes passé depuis le début du calcul de la page.

Exemple:

executedtime: ~executedtime()

La fonction dumpvar est une aide au débuggage. Elle permet de connaitre toutes les variables globales au moment de l'appel.

Exemple:

~print_r(dumpvar())

La fonction exit permet d'arrêter l'interprétation du template en cours en affichant un message. Typiquement elle ne sera utilisée que pour débugger.

Exemple:

un message
~exit("message d'erreur")
un autre message

Le résultat est:

message d'erreur

reduce_space est une pseudo-fonction. Sa présence dans un template indique que les espaces en début des chaînes de caractère doivent être supprimés. Cela permet d'indenter des chaînes de caractères sur plusieurs lignes sans que l'indentation interfère avec le code.

La valeur par défaut est indiquée dans templeet/config.php .

Cette pseudo-fonction fait le contraire de la pseudo-fonction reduce_space.

La fonction createdir() sert a créer des répertoires de manière récursive.

Elle peut prendre deux arguments :

• le nom du répertoire à créer (obligatoire)
• le mode de création du répertoire. Par défaut 0777 ce qui correspond au maximum de droits possible. Toutefois le umask est vigueur est appliqué.
  

Note : Cette fonction fait appel à la fonction createdir de templeet.php  qui elle même utilise la fonction mkdir de php avec l'option de recursivité activée

Exemple :

~createdir('plop/pika/test/')

Si les répertoires 'plop', 'pika' n'existent pas, ils sont créés au passage.

Templeet comprend un certain nombre de fonctions qui gèrent des listes. Une liste est une suite d'élements. Une liste peut être le résultat d'une requête SQL ou bien les éléments d'un tableau ou encore les entrées dans un répertoire du système de fichiers.

Toutes les fonctions de listes ont des paramètres qui leurs sont propres parce que un tableau ne se gère pas comme une base de données par exemple. Néanmoins, toutes les fonctions de listes ont en commun le principe de présentation des éléments. Celle-ci se fait à l'aide de sélecteurs.

Les sélecteurs sont des paramètres passés aux fonctions de liste qui permettent de déterminer le rendu de la liste. Un sélecteur se compose de deux éléments:

• Un type sous la forme de deux caractères en majuscule
• Une valeur qui sera interpretée au moment du traitement d'un état particulier de l'avancement dans le traitement de la liste
  

L'appel d'une fonction de liste se compose de la manière suivante:

~fonction_de_liste(les paramètres propres à la fonction, type_selecteur_1, valeur_selecteur_1, type_selecteur_2, valeur_selecteur_2 ...)

Chaque fonction traite un certain nombre de sélecteurs mais pas forcément tous. Le seul sélecteur qui soit obligatoire est le sélecteur LM. Le sélecteur LM est utilisé pour traiter chacun des éléments de la liste.

Exemple dans le cas du traitement d'un tableau:

tab_list["clef_un"]='valeur_un';
tab_list["clef_deux"]='valeur_deux';
tab_list["clef_trois"]='valeur_trois';

~array_list(tab_list,0,,'LM','la clef est ~array_fld('key') et la valeur est ~array_fld('current')<br />')

Le tableau 'tab_list' est créé puis listé. L'appel de cette fonction comporte juste le sélecteur LM qui a pour valeur:

la clef est ~array_fld('key') et la valeur est ~array_fld('current')<br />

La fonction ~array_fld() est une fonction associée à la fonction ~array_list(). Chaque fonction de traitement de liste a une et parfois plusieurs fonctions associées.

Ces fonctions ne peuvent être appelées qu'à l'intérieur d'un sélecteur parce qu'elles permettent d'obtenir des informations sur l'élément qui est en cours de traitement. En l'occurrence, ~array_fld('key') permet de connaitre la clef de l'élément du tableau en cours de traitement et ~array_fld('current') retourne l'élément en cours de traitement.

Le code précédent retourne donc:

la clef est clef_un et la valeur est valeur_un
la clef est clef_deux et la valeur est valeur_deux
la clef est clef_trois et la valeur est valeur_trois

Les autres sélecteurs permettent de gérer des cas particuliers. Ainsi LF et LL sont évalués respectivement avant le premier élément et après le dernier élément.

Exemple:

~array_list(tab_list,0,,
  'LM','la clef est ~array_fld('key') et la valeur est ~array_fld('current')<br />',
  'LF','ce sélecteur est évalué avant le premier élément<br />',
  'LL','ce sélecteur est évalué après le dernier élément<br />'
  )

Le résultat est:

ce sélecteur est évalué avant le premier élément
la clef est clef_un et la valeur est valeur_un
la clef est clef_deux et la valeur est valeur_deux
la clef est clef_trois et la valeur est valeur_trois
ce sélecteur est évalué après le dernier élément

Liste des sélecteurs:

• LM : évalué pour chacun des éléments.
• LF : évalué avant le premier élément.
• LL : évalué après le dernier élément.
• LR : évalué pour le premier élément. Si ce sélecteur est présent le sélecteur LM n'est pas évalué pour le premier élément.
• LN : évalué pour le dernier élément. Si ce sélecteur est présent le sélecteur LM n'est pas évalué pour le dernier élément.
• LS : évalué entre chaque élément.
• LD : évalué dans le cas où la liste ne contient aucun élément.
• L1 : évalué dans le cas où la liste n'est constituée que d'un seul élément. Si ce sélecteur est présent le sélecteur LM n'est pas évalué.
• LE : évalué dans le cas où une erreur survient dans le traitement de la liste. (problème dans une requête SQL par exemple)

Pour les pages qui ne sont pas cachées il n'y a pas de problème spécifique puisque le choix de la langue peut être négocié en dynamique entre le navigateur et Templeet. Il suffit pour cela d'utiliser la fonction bestlang. Le principe général est simple: on a un tableau qui contient langues. Si la langue requise dans l'URL n'est pas disponible (appel de http:// .../mapage.html.de ) ou si aucune langue n'a été requise (appel de http:// .../mapage.html ) alors la fonction best lang est appelée et la variable lang sera positionnée au mieux en fonction de ce qui est disponible et des préférences indiquées dans le navigateur. Une fois la langue positionnée il ne reste plus qu'à afficher la page dans la langue sélectionnée en faisant par exemple un include d'un fichier spécifique à la langue.

~dont_cache()
~rem(
  les_langues_disponibles=array_flip(array('en','fr'));
  if(lang=='' || ~is_null(les_langues_disponibles[lang]),
     lang=bestlang(les_langues_disponibles,'en'))
  
  )
  
langue:~string(lang) 
~include("monfichier.".lang.".tmpl")

Voir le fonctionnement du cache de pages.

Pour les pages cachées le problèmes est plus complexe. Apache sait gérer de manière efficace un contenu en plusieurs langues à l'aide de Multiviews. Lors d'une requête où la langue n'est pas spécifiée ( appel de http:// .../mapage.html par opposition à l'appel de http:// .../mapage.html.fr par exemple), Apache cherche parmi les fichiers qui sont disponibles et retourne la page la plus appropriée en fonction des préférences du navigateur. Si dans la requête la langue est spécifiée, le processus est sensiblement le même si ce n'est que Apache retournera en priorité la page dans la langue demandée si elle est disponible. Si elle ne l'est pas, comme précédemment, Apache recherche la page la plus appropriée en fonction des préférences du navigateur.

La difficulté commence avec l'interaction avec Templeet. Dans le cas des pages multilingues, il y a une difficulté supplémentaire dans la mesure où pour Apache, toutes les pages d'une langue donnée doivent exister ou bien aucune. Si la page n'existe que dans une seule langue, Templeet ne sera jamais appelé puisque Multiviews prendra le pas systématiquement sur Templeet et retournera la seule page existante quelle que soit la langue demandée dans la requête.

Pour cette raison, quand Templeet reçoit une requête pour une page qui existe en plusieurs langues, non seulement la page requise est mise en cache mais des fichiers correspondant aux autres langues sont également mis en cache afin de permettre à Multiviews de faire son choix en fonction de ce qui existe réellement.

Cette méthode consiste à utiliser un template par langue. Pour créer une page en français et en anglais il suffit de créer un template mapage.fr.html et un autre mapage.en.html. Templeet se charge de gérer le cache de page.

La seconde méthode consiste à gérer les langues disponibles dans le template lui même. On considérera que la langue doit toujours être fournie dans l'URL et si ce n'est pas le cas alors il doit y avoir une redirection vers la page la plus appropriée. La variable all_lang est alors utilisée par Templeet pour gérer le cache de page.

~rem(
  all_lang=array_flip(array('en','fr'));
  if(lang=='' || ~is_null(all_lang[lang]),
      redirect(relative_templeet().path.".".bestlang(all_lang,'en'))
    )
  
  )
  
langue:~string(lang)
~include("monfichier.".lang.".tmpl")

La troisième méthode utilise la fonction ~includelang(). Cette seule fonction permet de gérer tout le mécanisme de gestion des langues. Il suffit d'avoir un répertoire "lang" dans lequel se trouve un fichier par langue qui contient la liste des messages à afficher dans la page. La fonction se charge d'initialiser la variable all_lang en fonction des fichiers trouvés et le cache est géré en conséquence.

Cette méthode est la plus souple lorsque l'on souhaite décliner rapidement un site en plusieurs langues. L'ajout d'une langue est très facile puisque il suffit d'ajouter un fichier de langue par page dans le répertoire lang.