smarty-php/smarty
1
0
Fork 0
mirror of https://github.com/smarty-php/smarty.git synced 2026-04-29 02:03:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

add frech docs to cvs repository

Browse Source
This commit is contained in:
mohrt
2003-04-30 18:48:44 +00:00
parent 4389d50168
commit cf21e1270e
10 changed files with 10306 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/fr/appendixes.sgml
+408
View File
@@ -0,0 +1,408 @@
<part id="appendixes">
<title>Appendices</title>
<chapter id="troubleshooting">
<title>Diagnostic des erreurs</title>
<para></para>
<sect1 id="smarty.php.errors">
<title>Erreurs Smarty/PHP</title>
<para>
Smarty peut identifier de nombreuses erreurs comme des attributs de
balises manquants ou de noms de variables malformés. Dans ce cas-là,
vous verrez apparaître une erreur semblable à :
</para>
<example>
<title>erreurs Smarty</title>
<programlisting>
Warning: Smarty: [in index.tpl line 4]: syntax error: unknown tag - '%blah'
in /path/to/smarty/Smarty.class.php on line 1041
Fatal error: Smarty: [in index.tpl line 28]: syntax error: missing section name
in /path/to/smarty/Smarty.class.php on line 1041</programlisting>
</example>
<para>
Smarty vous indique le nom du template, le numéro de la ligne et l'erreur.
Après cela, vous pouvez connaître le numéro de ligne où il y a eu erreur dans
la définition de la classe Smarty.
</para>
<para>
Il y a certaines erreurs que Smarty ne peut pas détecter, comme les
balises fermantes manquantes. Ce type d'erreurs est la plupart du temps
repéré dans la phase de compilation PHP du template compilé.
</para>
<example>
<title>erreur d'analyse PHP</title>
<programlisting>
Parse error: parse error in /path/to/smarty/templates_c/index.tpl.php on line 75</programlisting>
</example>
<para>
Quand vous rencontrez une erreur d'analyse PHP, le numéro de la ligne
indiqué est celui du fichier PHP compilé et non du template. Vous pouvez alors
regarder le template et détecter l'erreur. Voici quelques erreurs fréquentes :
balises fermantes pour {if}{/if} ou {section}{/section} manquantes, ou
syntaxe logique incorrecte dans une instruction {if}. Si vous ne trouvez pas l'erreur,
vous devrez alors ouvrir le fichier PHP compilé et aller à la ligne correspondante pour
trouver d'où vient l'erreur.
</para>
</sect1>
</chapter>
<chapter id="tips">
<title>Trucs et astuces</title>
<para>
</para>
<sect1 id="tips.blank.var.handling">
<title>Gestion des variables non-assignées</title>
<para>
Peut-être voudrez-vous des fois afficher une valeur par défaut pour
une variable qui n'a pas été assignée, comme pour afficher "&amp;nbsp;"
afin que les couleurs de fond des tableaux fonctionnent. Beaucoup utiliseraient
une instruction {if} pour gérer cela, mais il existe un moyen plus facile dans
Smarty, l'utilisation du modificateur de variable <emphasis>default</emphasis>.
</para>
<example>
<title>afficher &amp;nbsp; quand une variable est vide</title>
<programlisting>
{* la méthode pas adaptée *}
{if $title eq ""}
&amp;nbsp;
{else}
{$title}
{/if}
{* la bonne méthode *}
{$title|default:"&amp;nbsp;"}</programlisting>
</example>
</sect1>
<sect1 id="tips.default.var.handling">
<title>Gestion des variables par défaut</title>
<para>
Si une variable est utilisée fréquemment dans vos templates,
lui appliquer le modificateur par défaut peut être un peu fastidieux.
Vous pouvez remédier à cela en lui assignant une valeur par défaut
avec la fonction <link linkend="language.function.assign">assign</link>.
</para>
<example>
<title>assigner une valeur par défaut à une variable de template</title>
<programlisting>
{* faites cela qq part en haut de votre template *}
{assign var="title" value=$title|default:"no title"}
{* si $title est vide, il contiendra alors no "no title" *}
{$title}</programlisting>
</example>
</sect1>
<sect1 id="tips.passing.vars">
<title>Passage du titre à un template d'en-tête</title>
<para>
Quand la majorité de vos templates utilisent les mêmes en-tête et pied-de-page,
il est d'usage de les mettre dans leurs propres templates et de les inclure.
Mais comment faire si l'en-tête doit avoir un titre différent, selon la page
d'où on vient ? Vous pouvez passer le titre à l'en-tête quand il est inclus.
</para>
<example>
<title>passer le titre au template d'en-tête</title>
<programlisting>
mainpage.tpl
------------
{include file="header.tpl" title="Main Page"}
{* le corps du template va ici *}
{include file="footer.tpl"}
archives.tpl
------------
{config_load file="archive_page.conf"}
{include file="header.tpl" title=#archivePageTitle#}
{* le corps du template va ici *}
{include file="footer.tpl"}
header.tpl
----------
&lt;HTML&gt;
&lt;HEAD&gt;
&lt;TITLE&gt;{$title|default:"BC News"}&lt;/TITLE&gt;
&lt;/HEAD&gt;
&lt;BODY&gt;
footer.tpl
----------
&lt;/BODY&gt;
&lt;/HTML&gt;</programlisting>
</example>
<para>
Quand la page principale est conçue, le titre "Main page" est passé à header.tpl
et sera donc utilisé pour le titre. Quand la page d'archive est conçue,
le titre sera "Archives". Notez que dans l'exemple des archives, on utilise
le fichier archives_page.conf plutôt que des variables codées en dur.
Remarquez aussi que "BC News" est affichée si la variable $title
n'est pas définie, grâce au modificateur de variable <emphasis>default</emphasis>.
</para>
</sect1>
<sect1 id="tips.dates">
<title>Dates</title>
<para>
De façon générale, essayez de toujours passer les dates à Smarty
sous forme de timestamp. Cela permet aux designers de templates d'utiliser
<link linkend="language.modifier.date.format">date_format</link>
pour avoir un contrôle total sur le formatage des dates et de comparer
facilement les dates entre elles.
</para>
<para>
NOTE : à partir Smarty 1.4.0, vous pouvez passer les dates à Smarty
sous la forme de timestamps Unix ou MySQL, ou tout autre format de dates
que comprend strtotime().
</para>
<example>
<title>utilisation de date_format</title>
<programlisting>
{$startDate|date_format}
OUTPUT:
Jan 4, 2001
{$startDate|date_format:"%Y/%m/%d"}
OUTPUT:
2001/01/04
{if $date1 < $date2}
...
{/if}</programlisting>
</example>
<para>
En utilisant la fonction {html_select_date} dans un template, le programmeur
veut en général convertir le résultat d'un formulaire en un timestamp.
Voici une fonction qui devrait vous être utile.
</para>
<example>
<title>conversion des éléments date d'un formulaire en timestamp</title>
<programlisting>
// cela suppose que vos éléments de formulaire soient nommés
// startDate_Day, startDate_Month, startDate_Year
$startDate = makeTimeStamp($startDate_Year,$startDate_Month,$startDate_Day);
function makeTimeStamp($year="",$month="",$day="")
{
if(empty($year))
$year = strftime("%Y");
if(empty($month))
$month = strftime("%m");
if(empty($day))
$day = strftime("%d");
return mktime(0,0,0,$month,$day,$year);
}</programlisting>
</example>
</sect1>
<sect1 id="tips.wap">
<title>WAP/WML</title>
<para>
Les templates WAP/WML nécessitent un en-tête "Content-Type" qui doit être
passé avec le template. Le moyen le plus facile de faire cela est d'écrire
une fonction utilisateur qui écrit l'en-tête. Si vous utilisez le cache,
cela ne fonctionnera pas. Nous utiliserons donc une balise d'insertion
(rappelez-vous que les balises d'insertion ne sont pas mises en cache !).
Assurez-vous qu'aucune sortie
rien n'est transmise au navigateur avant l'appel du template, sans quoi
la modification de l'en-tête échouera.
</para>
<example>
<title>utilisation d'insert pour écrire un en-tête Content-Type WML</title>
<programlisting>
// assurez-vous que Apache est configuré pour les extensions .wml !
// mettez cette fonction qq part dans votre applications
// ou dans Smarty.addons.php
function insert_header() {
// cette fonction attend un argument $content
extract(func_get_arg(0));
if(empty($content))
return;
header($content);
return;
}
// votre template Smarty DOIT commencer avec la balise d'insertion
&lt;?xml version="1.0"?&gt;
&lt;!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml"&gt;
&lt;!-- begin new wml deck --&gt;
&lt;wml&gt;
&lt;!-- begin first card --&gt;
&lt;card&gt;
&lt;do type="accept"&gt;
&lt;go href="#two"/&gt;
&lt;/do&gt;
&lt;p&gt;
Welcome to WAP with Smarty!
Press OK to continue...
&lt;/p&gt;
&lt;/card&gt;
&lt;!-- begin second card --&gt;
&lt;card id="two"&gt;
&lt;p&gt;
Pretty easy isn't it?
&lt;/p&gt;
&lt;/card&gt;
&lt;/wml&gt;</programlisting>
</example>
</sect1>
<sect1 id="tips.componentized.templates">
<title>Templates composants</title>
<para>
Cette astuce tient plus du hack qu'autre chose mais n'en demeure pas
moins une idée plutôt chouette. Utilisez-la à vos propres risques. ;-)
</para>
<para>
Traditionnellemnt, la programmation avec des templates dans les applications
se déroule de la façon suivante : d'abord vous récupérez vos variables
dans l'application PHP (peut-être avec des requêtes en base de données), puis
vous instanciez votre objet Smarty, assignez les variables et affichez le
template. Disons par exemple que nous avons un téléscripteur dans
notre template. Nous récupérerions les données dans notre application,
puis les assignerions ensuite pour les afficher. Mais ne serait-ce pas
mieux de pouvoir ajouter ce téléscripteur à n'importe quelle application
en incluant directement le template sans avoir à se soucier de la récupération
des données.
</para>
<para>
Vous pouvez intégrer du PHP dans vos templates avec les balises
{php}{/php}. Avec cette méthode, vous pouvez inclure des templates complets,
dans la mesure où ils récupèrent leurs propres données pour les assigner
à leurs propres variables. Avec le traitement intégré
de cette façon, vous pouvez garder le template et le traitement ensemble.
Ainsi, on ne se soucie plus d'où vient le contenu du template,
tout vient comme un seul et unique composant.
</para>
<example>
<title>template composant</title>
<programlisting>
{* Smarty *}
{php}
// notre fonction pour récupérer les données
function fetch_ticker($symbol,&$ticker_name,&$ticker_price) {
// du traitement qui récupère $ticker_name
// $ticker_price
}
// appelle la fonction
fetch_ticker("YHOO",$ticker_name,$ticker_price);
// assigne les variables
$this->assign("ticker_name",$ticker_name);
$this->assign("ticker_price",$ticker_price);
{/php}
Stock Name: {$ticker_name} Stock Price: {$ticker_price}</programlisting>
</example>
<para>
A partir de Smarty 1.5.0, il y a même un moyen plus propre. Vous
pouvez inclure du PHP dans votre template avec la balise {include_php ...}.
De cette façon, vous pouvez garder séparée la logique applicative
de la logique de présentation. Reportez-vous à la fonction <link
linkend="language.function.include.php">include_php</link> pour plus
d'informations.
</para>
<example>
<title>template composant avec include_php</title>
<programlisting>
load_ticker.php
---------------
&lt;?php
// notre fonction pour récupérer les données
function fetch_ticker($symbol,&$ticker_name,&$ticker_price) {
// put logic here that fetches $ticker_name
// and $ticker_price from some resource
}
// appelle la fonction
fetch_ticker("YHOO",$ticker_name,$ticker_price);
// assigne les variables
$this->assign("ticker_name",$ticker_name);
$this->assign("ticker_price",$ticker_price);
?&gt;
index.tpl
---------
{* Smarty *}
{include_php file="load_ticker.php"}
Stock Name: {$ticker_name} Stock Price: {$ticker_price}</programlisting>
</example>
</sect1>
<sect1 id="tips.obfuscating.email">
<title>Dissimuler les adresses email</title>
<para>
Vous-êtes vous déjà demandé pourquoi vos adresses emails sont sur autant
de mailing listes de spam ? Une façon pour les spammers de récupérer les
adresses est de parcourir les pages Web. Voici une façon de remédier
à ce problème : mettre votre adresse email dans du Javascript brouillé
au milieu de votre source HTML, sans que cela ne gêne l'affichage sur le
navigateur Web. Cela est fait grâce au plugin mailto.
</para>
<example>
<title>exemple de dissimulation d'une adresse email</title>
<programlisting>
index.tpl
---------
Send inquiries to
{mailto address=$EmailAddress encode="javascript" subject="Hello"}
</programlisting>
</example>
<note>
<title>Note technique</title>
<para>
Cette méthode n'est pas infaillible. Un spammer peut programmer son
collecteur d'email pour passer outre cette astuce, mais c'est cependant
peu probable.
</para>
</note>
</sect1>
</chapter>
<chapter id="resources">
<title>Ressources</title>
<para>
La page Web de Smarty se trouve à l'adresse suivante : http://smarty.php.net/.
Vous pouvez souscrire à la mailing liste en envoyant un email à
smarty-general-subscribe@lists.php.net.
Les archives de la mailing list se trouvent à l'adresse suivante :
http://marc.theaimsgroup.com/?l=smarty&amp;r=1&amp;w=2
</para>
</chapter>
<chapter id="bugs">
<title>BUGS</title>
<para>
Vérifiez le fichier de BUGS fourni avec la dernière version de Smarty ou
consultez le site Web.
</para>
</chapter>
</part>
docs/fr/common.dsl
+46
View File
@@ -0,0 +1,46 @@
;; -*- Scheme -*-
;;
;; $Id$
;;
;; This file contains stylesheet customization common to the HTML
;; and print versions.
;;
;; Stylesheets Localization
(define %default-language% "en")
(define %use-id-as-filename% #t)
(define %gentext-nav-tblwidth% "100%")
(define %refentry-function% #t)
(define %refentry-generate-name% #f)
(define %funcsynopsis-style% 'ansi)
(define ($legalnotice-link-file$ legalnotice)
(string-append "copyright" %html-ext%))
(define %generate-legalnotice-link% #t)
(define %footnotes-at-end% #t)
(define %force-chapter-toc% #t)
(define newline "\U-000D")
(define %number-programlisting-lines% #f)
(define %linenumber-mod% 1)
(define %shade-verbatim% #t)
(define ($generate-book-lot-list$)
;; REFENTRY generate-book-lot-list
;; PURP Which Lists of Titles should be produced for Books?
;; DESC
;; This parameter should be a list (possibly empty) of the elements
;; for which Lists of Titles should be produced for each 'Book'.
;;
;; It is meaningless to put elements that do not have titles in this
;; list. If elements with optional titles are placed in this list, only
;; the instances of those elements that do have titles will appear in
;; the LOT.
;;
;; /DESC
;; AUTHOR N/A
;; /REFENTRY
(list (normalize "table")))
(define (php-code code)
(make processing-instruction
data: (string-append "php " code "?")))
docs/fr/designers.sgml
+5790
View File
File diff suppressed because it is too large Load Diff
docs/fr/getting-started.sgml
+427
View File
@@ -0,0 +1,427 @@
<part id="getting.started">
<title>Pour commencer</title>
<chapter id="what.is.smarty">
<title>Qu'est-ce que Smarty ?</title>
<para>
Smarty est un moteur de template pour PHP. Plus précisément, il facilite
la séparation entre la logique applicative et la présentation.
Cela s'explique plus facilement dans une situation où le
programmeur et le designer de templates jouent des rôles différents, ou,
comme la plupart du temps, sont deux personnes distinctes.
Supposons par exemple que vous concevez une page Web qui affiche un
article de newsletter. Le titre, le sous-titre, l'auteur et le corps
sont des éléments de contenu, ils ne contiennent aucune information
concernant la présentation. Ils sont transmis à Smarty par l'application,
puis le designer de templates éditent les templates et utilisent une
combinaison de balises HTML et de balises de templates pour formater
la présentation de ces éléments (tableaux HTML, couleurs d'arrière-plan,
tailles des polices, feuilles de styles, etc.). Un beau jour le programmeur
a besoin de changer la façon dont le contenu de l'article
est récupéré (un changement dans la logique applicative). Ce
changement n'affecte pas le designer de templates, le contenu
arrivera toujours au template de la même façon. De même, si le
le designer de templates veut changer complétement l'apparence
du template, aucun changement dans la logique de l'application
n'est nécessaire. Ainsi le programmeur peut changer la logique
de l'application sans restructurer les templates, et le designer
de templates peut changer les templates sans briser la logique
applicative.
</para>
<para>
Et maintenant un mot rapide sur ce que Smarty NE fait PAS. Smarty n'a
pas pour prétention de supprimer complétement les traitements au sein des
templates.
Il est tout à fait envisageable de recontrer un traitement dans un template,
à condition que ce dernier ne désserve que des besoins de présentation.
Un conseil : laissez la logique applicative en dehors des templates et
la logique de présentation en dehors de l'application. A l'avenir, cela permet
une meilleure gestion des évènements.
</para>
<para>
L'un des aspects unique de Smarty est la compilation des templates.
Cela signifie que Smarty lit les templates et crée des scripts PHP à partir
de ces derniers. Une fois créés, ils sont exécutés.
Il n'y a donc pas d'analyse coûteuse de template à chaque requête,
et les templates peuvent bénéficier des solutions de cache PHP
comme Zend Accelerator (http://www.zend.com) ou PHP Accelerator
(http://www.php-accelerator.co.uk).
</para>
<para>
Quelques caractéristiques de Smarty :
</para>
<itemizedlist>
<listitem><para>Il est très rapide.</para></listitem>
<listitem><para>Il est efficace, le parser PHP s'occupe
du sale travail.</para></listitem>
<listitem><para>Pas d'analyse de template coûteuse, une seule compilation.
</para></listitem>
<listitem><para>Il sait ne recompiler que les fichiers de templates
qui ont été modifiés.</para></listitem>
<listitem><para>Vous pouvez créer des <link linkend="language.custom.functions">
fonctions utilisateurs</link> et des <link linkend="language.modifiers">
modificateurs de variables</link> personnalisés, le langage de
template est donc extrémement extensible.</para></listitem>
<listitem><para>Syntaxe des templates configurable, vous
pouvez utiliser {}, {{}}, &lt;!--{}--&gt;, etc comme délimiteurs.
</para></listitem>
<listitem><para>Les instructions if/elseif/else/endif
sont passées au parser PHP, la syntaxe de l'expression {if...}
peut être aussi simple ou aussi complexe que vous
le désirez.</para></listitem>
<listitem><para>Imbrication illimitée de sections,
de 'if', etc. autorisée.</para></listitem>
<listitem><para>Il est possible d'inclure du code PHP
directement dans vos templates, bien que cela ne soit pas obligatoire
(ni conseillé), vu que le moteur est extensible.</para></listitem>
<listitem><para>Support de cache intégré.</para></listitem>
<listitem><para>Sources de templates arbitraires.</para></listitem>
<listitem><para>Fonctions de gestion de cache personnalisables.</para></listitem>
<listitem><para>Architecture de plugins</para></listitem>
</itemizedlist>
</chapter>
<chapter id="installation">
<title>Installation</title>
<sect1 id="installation.requirements">
<title>Ce dont vous avez besoin</title>
<para>
Smarty nécessite un serveur Web utilisant PHP 4.0.6 ou supérieur.
</para>
</sect1>
<sect1 id="installing.smarty.basic">
<title>Installation de base</title>
<para>
Copiez les fichiers bibliothèques de Smarty du répertoire
/libs/ de la distribution à un emplacement accessible à PHP.
Ce sont des fichiers PHP que vous NE DEVEZ PAS
modifier. Ils sont partagés par toutes les applications et ne seront
mis à jour que lorsque vous installerez une nouvelle version de
Smarty.
</para>
<example>
<title>fichiers de la bibliothèque SMARTY</title>
<screen>
Smarty.class.php
Smarty_Compiler.class.php
Config_File.class.php
debug.tpl
/plugins/*.php (tous !)</screen>
</example>
<para>
Smarty utilise une constante PHP appelée <link
linkend="constant.smarty.dir">SMARTY_DIR</link> qui
représente le chemin complet de la bibliothèque Smarty. En fait,
si votre application trouve le fichier
<emphasis>Smarty.class.php</emphasis>, vous n'aurez pas
besoin de définir la variable SMARTY_DIR, Smarty s'en chargera pour vous.
En revanche, si <emphasis>Smarty.class.php</emphasis>
n'est pas dans votre répertoire d'inclusion ou que vous ne
donnez pas un chemin absolu à votre application, vous
devez définir SMARTY_DIR explicitement. SMARTY_DIR
<emphasis>doit</emphasis> avoir être terminé par un slash.
</para>
<para>
Voici comment créer une instance de Smarty dans vos scripts PHP :
</para>
<example>
<title>créer une instance de Smarty</title>
<screen>
require('Smarty.class.php');
$smarty = new Smarty;</screen>
</example>
<para>
Essayez de lancer le script ci-dessus. Si vous obtenez une erreur indiquant
que le fichier <emphasis>Smarty.class.php</emphasis> n'est pas trouvé,
tentez l'une des choses suivantes :
</para>
<example>
<title>fournir un chemin absolu vers la bibliothèque Smarty</title>
<screen>
require('/usr/local/lib/php/Smarty/Smarty.class.php');
$smarty = new Smarty;</screen>
</example>
<example>
<title>Ajouter le répertoire de la bibliothèque au chemin de php_include</title>
<screen>
// Editez le fichier php.ini, ajoutez le répertoire de la
// bibliothèque Smarty au include_path et redémarrez le serveur Web.
// Cela devrait ensuite fonctionner :
require('Smarty.class.php');
$smarty = new Smarty;</screen>
</example>
<example>
<title>Définir explicitement la constante SMARTY_DIR</title>
<screen>
define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
require(SMARTY_DIR.'Smarty.class.php');
$smarty = new Smarty;</screen>
</example>
<para>
Maintenant que les fichiers de la librairie sont en place,
il est temps de définir les répertoires de Smarty, pour votre application.
Smarty a besoin de quatre répertoires qui sont (par défaut)
<emphasis>templates</emphasis>,
<emphasis>templates_c</emphasis>, <emphasis>configs</emphasis> et
<emphasis>cache</emphasis>. Chacun d'entre eux peut être défini
via les attributs <emphasis>$template_dir</emphasis>,
<emphasis>$compile_dir</emphasis>, <emphasis>$config_dir</emphasis> et
<emphasis>$cache_dir</emphasis> respectivement. Il est vivement
conseillé que vous régliez ces répertoires séparément pour chaque
application qui utilise Smarty.
</para>
<para>
Assurez-vous de bien connaître chemin de la racine
de votre arborescence Web. Dans notre exemple, la racine
est "/web/www.mydomain.com/docs". Seul Smarty
accède aux répertoires en question, et jamais le serveur Web.
Pour des raisons de sécurité, il est donc conseillé de
sortir ces répertoires dans un répertoire
<emphasis>en dehors</emphasis> de l'arborescence
Web.
</para>
<para>
Dans notre exemple d'installation, nous allons régler l'environnement
de Smarty pour une application de livre d'or. Nous avons ici choisi
une application principalement pour mettre en évidence une
convention de nommage des répertoires. Vous pouvez utiliser le même
environnement pour n'importe quelle autre application, il suffit de
remplacer "livredor" avec le nom de votre application. Nous allons
mettre nos répertoires Smarty dans
"/web/www.mydomain.com/smarty/livredor/".
</para>
<para>
Vous allez avoir besoin d'au moins un fichier à la racine de
l'arborescence Web,
il s'agit du script auquel l'internaute a accès. Nous allons l'appeler
"index.php" et le placer dans un sous-répertoire
appelé "/livredor/". Il est pratique de configurer le serveur Web de
sorte que "index.php" soit identifié comme fichier
par défaut de ce répertoire. Aicnsi, si l'on tape
"http://www.mydomain.com/livredor/", le script index.php soit
exécuté sans que "index.php" ne soit spécifié dans l'URL. Avec Apache
vous pouvez régler cela en ajoutant "index.php" à la ligne où se
trouve DirectoryIndex (séparez chaque entrée par un espace).
</para>
<para>
Jetons un coup d'oeil à la structure de fichier obtenue :
</para>
<example>
<title>exemple de structure de fichiers</title>
<screen>
/usr/local/lib/php/Smarty/Smarty.class.php
/usr/local/lib/php/Smarty/Smarty_Compiler.class.php
/usr/local/lib/php/Smarty/Config_File.class.php
/usr/local/lib/php/Smarty/debug.tpl
/usr/local/lib/php/Smarty/plugins/*.php
/web/www.mydomain.com/smarty/livredor/templates/
/web/www.mydomain.com/smarty/livredor/templates_c/
/web/www.mydomain.com/smarty/livredor/configs/
/web/www.mydomain.com/smarty/livredor/cache/
/web/www.mydomain.com/docs/livredor/index.php</screen>
</example>
<para>
Smarty a besoin d'accéder en écriture aux répertoires
<emphasis>$compile_dir</emphasis> et <emphasis>$cache_dir</emphasis>,
assurez-vous donc que le serveur Web dispose de ces droits d'accès.
Il s'agit généralement de l'utilisateur "nobody" et du group
"nobody". Pour les utilisateurs de OS X, l'utilisateur par défaut
est "web" et le group "web". Si vous utilisez Apache, vous pouvez
parcourir le fichier httpd.conf (en général dans
"/usr/local/apache/conf/") pour déterminer quel est l'utilisateur
et le groupe auquel il appartient.
</para>
<example>
<title>régler les permissions d'accès</title>
<screen>
chown nobody:nobody /web/www.mydomain.com/smarty/templates_c/
chmod 770 /web/www.mydomain.com/smarty/templates_c/
chown nobody:nobody /web/www.mydomain.com/smarty/cache/
chmod 770 /web/www.mydomain.com/smarty/cache/</screen>
</example>
<note>
<title>Note technique</title>
<para>
La commande chmod 770 est relativement bien sécurisée, elle donne
à l'utilisateur "nobody" et au groupe "nobody" les accès en
lecture/écriture aux répertoires. Si vous voulez donner le droit d'accès
en lecture à tout le monde (principalement pour pouvoir accéder
vous-même à ces fichiers), vous pouvez lui préférer chmod 775.
</para>
</note>
<para>
Nous devons créer le fichier index.tpl que Smarty va charger.
Il va se trouver dans $template_dir.
</para>
<example>
<title>Edition de /web/www.mydomain.com/smarty/templates/index.tpl</title>
<screen>
{* Smarty *}
Hello, {$name}!</screen>
</example>
<note>
<title>Note technique</title>
<para>
{* Smarty *} est un commentaire de template. Il n'est pas
obligatoire mais il est bon de commencer tous vos templates
avec ce commentaire. Cela rend le fichier facilement
reconnaissable en plus de son extension. Les éditeurs
de texte peuvent par exemple reconnaître le fichier et
adapter la coloration syntaxique.
</para>
</note>
<para>
Maintenant passons à l'édition du fichier index.php. Nous allons
créer une instance de Smarty, assigner une valeur à une variable
de template et afficher le résultat avec index.tpl. Dans notre
exemple d'environnement, "/usr/local/lib/php/Smarty" est dans notre
include_path. Assurez-vous de faire la même chose ou d'utiliser
des chemins absolus.
</para>
<example>
<title>édition de /web/www.mydomain.com/docs/livredor/index.php</title>
<screen>
// charge la bibliothèque Smarty
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->template_dir = '/web/www.mydomain.com/smarty/livredor/templates/';
$smarty->compile_dir = '/web/www.mydomain.com/smarty/livredor/templates_c/';
$smarty->config_dir = '/web/www.mydomain.com/smarty/livredor/configs/';
$smarty->cache_dir = '/web/www.mydomain.com/smarty/livredor/cache/';
$smarty->assign('name','Ned');
$smarty->display('index.tpl');</screen>
</example>
<note>
<title>Note techique</title>
<para>
Dans notre exemple, nous avons configuré les chemins absolus
pour chacun des répertoires Smarty. Si
'/web/www.mydomain.com/smarty/livredor/' est dans votre
include_path PHP alors ces réglages ne sont pas nécessaires.
Quoi qu'il en soit il est plus efficace et (par expérience)
moins générateur d'erreurs de les définir avec des chemins
absolus. Cela nous garantit que Smarty récupèrera les bons fichiers.
</para>
</note>
<para>
Et maintenant appelez le fichier index.php avec navigateur
Web. Vous devriez voir "Hello, Ned!".
</para>
<para>
Vous venez de terminer l'installation de base de Smarty !
</para>
</sect1>
<sect1 id="installing.smarty.extended">
<title>Configuration avancée</title>
<para>
Ceci est la suite de <link
linkend="installing.smarty.basic">l'installation de base</link>, veuillez
lire cette dernière avant de poursuivre.
</para>
<para>
Une manière un peu plus commode de configurer Smarty est de faire votre
propre classe fille et de l'initialiser selon votre environnement.
De la sorte, nous n'aurons plus besoin de configurer à chaques fois les
chemins de notre environnement. Créons un nouveau répertoire
"/php/includes/livredor/" et un nouveau fichier appelé "setup.php".
Dans notre exemple d'environnement, "/php/includes" est notre
include_path PHP. Assurez-vous de faire la même chose ou alors d'utiliser
des chemins absolus.
</para>
<example>
<title>édition de /php/includes/livredor/setup.php</title>
<screen>
// charge la librairie Smarty
require('Smarty.class.php');
// le fichier setup.php est un bon
// endroit pour charger les fichiers
// de librairies de l'application et vous pouvez
// faire cela juste ici. Par exemple :
// require('livredor/livredor.lib.php');
class Smarty_livredor extends Smarty {
function Smarty_livredor() {
// Constructeur de la classe. Appelé automatiquement
// à l'instanciation de la classe.
$this->Smarty();
$this->template_dir = '/web/www.mydomain.com/smarty/livredor/templates/';
$this->compile_dir = '/web/www.mydomain.com/smarty/livredor/templates_c/';
$this->config_dir = '/web/www.mydomain.com/smarty/livredor/configs/';
$this->cache_dir = '/web/www.mydomain.com/smarty/livredor/cache/';
$this->caching = true;
$this->assign('app_name','Guest Book');
}
}</screen>
</example>
<para>
Modifions maintenant le fichier index.php pour qu'il utilise "setup.php"
</para>
<example>
<title>édition de /web/www.mydomain.com/docs/livredor/index.php</title>
<screen>
require('livredor/setup.php');
$smarty = new Smarty_livredor;
$smarty->assign('name','Ned');
$smarty->display('index.tpl');</screen>
</example>
<para>
Vous savez maintenant qu'il est facile de créer une instance de Smarty,
correctement configurée, en utilisant Smarty_livredor qui initialise
automatiquement tout ce qu'il faut pour votre application.
</para>
</sect1>
</chapter>
</part>
docs/fr/html-common.dsl
+382
View File
@@ -0,0 +1,382 @@
;; -*- Scheme -*-
;;
;; $Id$
;;
;; Returns the depth of the auto-generated TOC (table of contents) that
;; should be made at the nd-level
(define (toc-depth nd)
(if (string=? (gi nd) (normalize "book"))
3 ; the depth of the top-level TOC
1 ; the depth of all other TOCs
))
(element (funcdef function)
($bold-seq$
(make sequence
(process-children)
)
)
)
(define (is-true-optional nl)
(and (equal? (gi (parent nl)) (normalize "parameter"))
(equal? 0 (string-length (strip (data (preced nl)))))
(equal? 0 (string-length (strip (data (follow nl)))))
)
)
(define (has-true-optional nl)
(is-true-optional
(node-list-first-element
(select-elements
(descendants nl)
(normalize "optional"))
)
)
)
(define (count-true-optionals nl)
(let loop
((result 0)
(nl (select-elements (descendants nl) (normalize "optional")))
)
(if(node-list-empty? nl)
result
(if(is-true-optional(node-list-first nl))
(loop (+ result 1) (node-list-rest nl))
(loop result (node-list-rest nl))
)
)
)
)
;; there are two different kinds of optionals
;; optional parameters and optional parameter parts
;; an optional parameter is identified by an optional tag
;; with a parameter tag as its parent
;; and only whitespace between them
(element optional
;;check for true optional parameter
(if (is-true-optional (current-node))
;; yes - handle '[...]' in paramdef
(process-children-trim)
;; no - do '[...]' output
(make sequence
(literal %arg-choice-opt-open-str%)
(process-children-trim)
(literal %arg-choice-opt-close-str%)
)
)
)
;; now this is going to be tricky
(element paramdef
(make sequence
;; special treatment for first parameter in funcsynopsis
(if (equal? (child-number (current-node)) 1)
;; is first ?
(make sequence
;; start parameter list
(literal "(")
;; is optional ?
( if (has-true-optional (current-node))
(literal %arg-choice-opt-open-str%)
(empty-sosofo)
)
)
;; not first
(empty-sosofo)
)
;;
(process-children-trim)
;; special treatment for last parameter
(if (equal? (gi (ifollow (current-node))) (normalize "paramdef"))
;; more parameters will follow
(make sequence
;; next is optional ?
( if (has-true-optional (ifollow (current-node)))
;; optional
(make sequence
(literal " ")
(literal %arg-choice-opt-open-str%)
)
;; not optional
(empty-sosofo)
)
(literal ", " )
)
;; last parameter
(make sequence
(literal
(let loop ((result "")(count (count-true-optionals (parent (current-node)))))
(if (<= count 0)
result
(loop (string-append result %arg-choice-opt-close-str%)(- count 1))
)
)
)
( literal ")" )
)
)
)
)
(element function
(let* ((function-name (data (current-node)))
(linkend
(string-append
"function."
(string-replace
(string-replace function-name "_" "-")
"::" ".")))
(target (element-with-id linkend))
(parent-gi (gi (parent))))
(cond
;; function names should be plain in FUNCDEF
((equal? parent-gi "funcdef")
(process-children))
;; if a valid ID for the target function is not found, or if the
;; FUNCTION tag is within the definition of the same function,
;; make it bold, add (), but don't make a link
((or (node-list-empty? target)
(equal? (case-fold-down
(data (node-list-first
(select-elements
(node-list-first
(children
(select-elements
(children
(ancestor-member (parent) (list "refentry")))
"refnamediv")))
"refname"))))
function-name))
($bold-seq$
(make sequence
(process-children)
(literal "()"))))
;; else make a link to the function and add ()
(else
(make element gi: "A"
attributes: (list
(list "HREF" (href-to target)))
($bold-seq$
(make sequence
(process-children)
(literal
)
(literal "()"))))))))
(element command
(let* ((command-name (data (current-node)))
(linkend
(string-append
"language.function."
(string-replace
(string-replace command-name "_" ".")
"::" ".")))
(target (element-with-id linkend))
(parent-gi (gi (parent))))
(cond
;; function names should be plain in FUNCDEF
((equal? parent-gi "funcdef")
(process-children))
;; if a valid ID for the target function is not found, or if the
;; FUNCTION tag is within the definition of the same function,
;; make it bold, add (), but don't make a link
((or (node-list-empty? target)
(equal? (case-fold-down
(data (node-list-first
(select-elements
(node-list-first
(children
(select-elements
(children
(ancestor-member (parent) (list "refentry")))
"refnamediv")))
"refname"))))
command-name))
($bold-seq$
(make sequence
(literal "{")
(process-children)
(literal "}"))))
;; else make a link to the function and add ()
(else
(make element gi: "A"
attributes: (list
(list "HREF" (href-to target)))
($bold-seq$
(make sequence
(literal "{")
(process-children)
(literal "}"))))))))
(element classname
(let* ((class-name (data (current-node)))
(linkend
(string-append
"class."
(string-replace
(case-fold-down class-name) "_" "-")))
(target (element-with-id linkend))
(parent-gi (gi (parent))))
(cond
;; function names should be plain in SYNOPSIS
((equal? parent-gi "synopsis")
(process-children))
;; if a valid ID for the target class is not found, or if the
;; CLASSNAME tag is within the definition of the same class,
;; make it bold, but don't make a link
((or (node-list-empty? target)
(equal? (case-fold-down
(data (node-list-first
(select-elements
(node-list-first
(children
(select-elements
(children
(ancestor-member (parent) (list "refentry")))
"refnamediv")))
"refname"))))
class-name))
($bold-seq$
(process-children)))
;; else make a link to the function and add ()
(else
(make element gi: "A"
attributes: (list
(list "HREF" (href-to target)))
($bold-seq$
(process-children)))))))
(element constant
(let* ((constant-name (data (current-node)))
(linkend
(string-append "constant."
(case-fold-down
(string-replace constant-name "_" "-"))))
(target (element-with-id linkend))
(parent-gi (gi (parent))))
(cond
; ;; constant names should be plain in FUNCDEF
; ((equal? parent-gi "funcdef")
; (process-children))
;; if a valid ID for the target constant is not found, or if the
;; CONSTANT tag is within the definition of the same constant,
;; make it bold, add (), but don't make a link
((or (node-list-empty? target)
(equal? (case-fold-down
(data (node-list-first
(select-elements
(node-list-first
(children
(select-elements
(children
(ancestor-member (parent) (list "refentry")))
"refnamediv")))
"refname"))))
constant-name))
($bold-mono-seq$
(process-children)))
;; else make a link to the function and add ()
(else
(make element gi: "A"
attributes: (list
(list "HREF" (href-to target)))
($bold-mono-seq$
(process-children)))))))
(element example
(make sequence
(make element gi: "TABLE"
attributes: (list
(list "WIDTH" "100%")
(list "BORDER" "0")
(list "CELLPADDING" "0")
(list "CELLSPACING" "0")
(list "CLASS" "EXAMPLE"))
(make element gi: "TR"
(make element gi: "TD"
($formal-object$))))))
(element (paramdef parameter)
(make sequence
font-posture: 'italic
(process-children-trim)
)
)
(mode book-titlepage-recto-mode
(element authorgroup
(process-children))
(element author
(let ((author-name (author-string))
(author-affil (select-elements (children (current-node))
(normalize "affiliation"))))
(make sequence
(make element gi: "DIV"
attributes: (list (list "CLASS" (gi)))
(literal author-name))
(process-node-list author-affil))))
)
(define (chunk-element-list)
(list (normalize "preface")
(normalize "chapter")
(normalize "appendix")
(normalize "article")
(normalize "glossary")
(normalize "bibliography")
(normalize "index")
(normalize "colophon")
(normalize "setindex")
(normalize "reference")
(normalize "refentry")
(normalize "part")
(normalize "sect1")
(normalize "sect2")
(normalize "section")
(normalize "book") ;; just in case nothing else matches...
(normalize "set") ;; sets are definitely chunks...
))
(define ($section-body$)
(make element gi: "DIV"
attributes: (list (list "CLASS" (gi)))
($section-separator$)
($section-title$)
(if (or (not (node-list-empty? (select-elements (children (current-node))
(normalize "sect2"))))
(not (node-list-empty? (select-elements (children (current-node))
(normalize "sect3")))))
(build-toc (current-node) 1)
(empty-sosofo))
(process-children)))
docs/fr/html.dsl
+21
View File
@@ -0,0 +1,21 @@
<!DOCTYPE style-sheet PUBLIC "-//James Clark//DTD DSSSL Style Sheet//EN" [
<!ENTITY docbook.dsl SYSTEM "/usr/share/sgml/docbook/html/docbook.dsl" CDATA DSSSL>
<!ENTITY html-common.dsl SYSTEM "html-common.dsl">
<!ENTITY common.dsl SYSTEM "common.dsl">
]>
<style-sheet>
<style-specification id="docbook-smarty-html" use="docbook">
<style-specification-body>
(define %html-ext% ".html")
&html-common.dsl;
&common.dsl;
</style-specification-body>
</style-specification>
<external-specification id="docbook" document="docbook.dsl">
</style-sheet>
docs/fr/manual.sgml
+44
View File
@@ -0,0 +1,44 @@
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook V3.1//EN" [
<!ENTITY preface SYSTEM "preface.sgml">
<!ENTITY getting.started SYSTEM "getting-started.sgml">
<!ENTITY smarty.for.designers SYSTEM "designers.sgml">
<!ENTITY smarty.for.programmers SYSTEM "programmers.sgml">
<!ENTITY appendixes SYSTEM "appendixes.sgml">
]>
<book id="index" lang="fr">
<bookinfo id="bookinfo">
<title>Smarty - le moteur et compilateur de template PHP</title>
<authorgroup id="authors">
<author>
<firstname>Monte</firstname><surname>Ohrt &lt;monte@ispi.net&gt;</surname>
</author>
<author>
<firstname>Andrei</firstname><surname>Zmievski &lt;andrei@php.net&gt;</surname>
</author>
</authorgroup>
<authorgroup id="translators">
<author>
<firstname>Arnaud</firstname><surname>Cogoluègnes &lt;arnaud.cogoluegnes@free.fr&gt;</surname>
</author>
<author>
<firstname>Gérald</firstname><surname>Croës &lt;gcroes@aston.fr&gt;</surname>
</author>
</authorgroup>
<edition>Version 2.0</edition>
<copyright>
<year>2001</year>
<year>2002</year>
<holder>ispi of Lincoln, Inc.</holder>
</copyright>
</bookinfo>
&preface;
&getting.started;
&smarty.for.designers;
&smarty.for.programmers;
&appendixes;
</book>
docs/fr/php.dsl
+21
View File
@@ -0,0 +1,21 @@
<!DOCTYPE style-sheet PUBLIC "-//James Clark//DTD DSSSL Style Sheet//EN" [
<!ENTITY docbook.dsl SYSTEM "/usr/share/sgml/docbook/html/docbook.dsl" CDATA DSSSL>
<!ENTITY html-common.dsl SYSTEM "html-common.dsl">
<!ENTITY common.dsl SYSTEM "common.dsl">
]>
<style-sheet>
<style-specification id="docbook-smarty-html" use="docbook">
<style-specification-body>
(define %html-ext% ".php")
&html-common.dsl;
&common.dsl;
</style-specification-body>
</style-specification>
<external-specification id="docbook" document="docbook.dsl">
</style-sheet>
docs/fr/preface.sgml
+77
View File
@@ -0,0 +1,77 @@
<preface id="preface">
<title>Préface</title>
<para>
"Comment rendre mes scripts PHP indépendants de la présentation ?".
Voici sans doute la question la plus posée sur la mailing list
PHP. Alors que PHP est étiqueté "langage de script
pour HTML", on se rend vite compte, après quelques projets qui mélangent
sans complexe HTML et PHP, que la séparation entre la forme et
le contenu est important. De plus, dans de nombreuses entreprises
les rôles du designer et du programmeur sont distincts. La solution template
coule donc de source.
</para>
<para>
Dans notre entreprise par exemple, le développement d'une application
se fait de la manière suivante : une fois le cahier des charges écrit,
le designer réalise une maquette, et donne ses interfaces
au programmeur. Le programmeur implémente les fonctionnalités applicatives
et utilise les maquettes pour faire des squelettes de templates. Le projet
est alors passé au designer HTML/responsable de la mise en page qui amène les
templates jusqu'au faîte de leur gloire. Il est possible que le projet fasse
une fois ou deux des allers/retours entre la programmation et la présentation.
En conséquence, il est important de disposer d'un bon système de template. Les
programmeurs ne veulent pas avoir à faire au HTML, et ne veulent pas non plus
que les designers HTML bidouillent le code PHP. Les designers ont besoin d'outils
comme des fichiers de configuration, des blocs dynamiques et d'autres solutions
pour répondre à des problématiques d'interface, mais ne veulent pas
nécessairement avoir à faire à toutes les subtilités de la programmation PHP.
</para>
<para>
Un rapide tour d'horizon des solutions type template aujourd'hui et
l'on s'aperçoit que la plupart d'entre elles n'offrent que des moyens
rudimentaires pour substituer des variables dans des templates, ainsi que des
fonctionnalités limitées de blocs dynamiques. Cependant nous avons
besoin d'un peu plus. Nous ne voulons pas que les programmeurs
s'occupent de la présentation HTML du TOUT, mais cela est pratiquement
inévitable. Par exemple, si un designer veut des couleurs d'arrière plan
différentes pour alterner entre différents blocs dynamiques, il est nécessaire
que ce dernier travaille avec le programmeur. Nous avons aussi besoin que les
designers soient capables de travailler avec leurs propres fichiers
de configuration pour y récupérer des variables, exploitables dans leurs
templates. Et la liste est longue.
</para>
<para>
Fin 1999, nous avons commencé à écrire une spécification pour un moteur de
template. Une fois la spécification terminée,
nous avons commencé à travailler sur un moteur de template écrit
en C qui pourrait, avec un peu de chance, être inclus à PHP.
Non seulement nous avons rencontré des problèmes techniques complexes,
mais nous avons participés à de nombreux débats sur ce que devait
et ce que ne devait pas faire un moteur de template. De cette expérience nous avons
décidé qu'un moteur de template se devait d'être écrit sous la forme d'une
classe PHP, afin que quiconque puisse l'utiliser à sa convenance. Nous
avons donc réalisé un moteur de template qui se contentait de faire cela,
et <productname>SmartTemplate</productname> a vu le jour (note : cette
classe n'a jamais été soumise au public). C'était une classe qui
faisait pratiquement tout ce que nous voulions : substitution de variables,
inclusion d'autres templates, intégration avec des fichiers de configuration,
intégration de code PHP, instruction 'if' basique et une gestion plus robuste
des blocks dynamiques imbriqués. Elle faisait tout cela avec des expressions
rationnelles et le code se révéla, comment dire, impénétrable. De plus, elle était
relativement lente pour les grosses applications à cause de l'analyse
et du travail sur les expressions rationnelles qu'elle devait faire à chaque
exécution. Le plus gros problème du point de vue du programmeur était
tout le travail nécessaire en amont, dans le script PHP, pour configurer
et exécuter les templates, et les blocs dynamiques. Comment rendre tout ceci
plus simple ?
</para>
<para>
Puis vint la vision de ce que devait devenir Smarty. Nous
savons combien le code PHP peut être rapide sans le coût
d'analyse des templates. Nous savons aussi combien fastidieux
et décourageant peut paraître le langage pour le designer moyen, et que
cela peut être remplacé par une syntaxe spécifique, beaucoup
plus simple. Et si nous combinions les deux forces ? Ainsi, Smarty
était né...
</para>
</preface>
docs/fr/programmers.sgml
+3090
View File
File diff suppressed because it is too large Load Diff