smarty-php/smarty
1
0
Fork 0
mirror of https://github.com/smarty-php/smarty.git synced 2025-08-04 10:24:26 +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

408
docs/fr/appendixes.sgml Normal file
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<72>s. Dans ce cas-l<>,
vous verrez appara<72>tre une erreur semblable <20> :
</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<75>ro de la ligne et l'erreur.
Apr<70>s cela, vous pouvez conna<6E>tre le num<75>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<65>r<EFBFBD> dans la phase de compilation PHP du template compil<69>.
</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<75>ro de la ligne
indiqu<71> est celui du fichier PHP compil<69> et non du template. Vous pouvez alors
regarder le template et d<>tecter l'erreur. Voici quelques erreurs fr<66>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<69> et aller <20> 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<67>es</title>
<para>
Peut-<2D>tre voudrez-vous des fois afficher une valeur par d<>faut pour
une variable qui n'a pas <20>t<EFBFBD> assign<67>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<70>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<69>e fr<66>quemment dans vos templates,
lui appliquer le modificateur par d<>faut peut <20>tre un peu fastidieux.
Vous pouvez rem<65>dier <20> 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 <20> 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 <20> un template d'en-t<>te</title>
<para>
Quand la majorit<69> 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<66>rent, selon la page
d'o<> on vient ? Vous pouvez passer le titre <20> 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<6F>ue, le titre "Main page" est pass<73> <20> header.tpl
et sera donc utilis<69> pour le titre. Quand la page d'archive est con<6F>ue,
le titre sera "Archives". Notez que dans l'exemple des archives, on utilise
le fichier archives_page.conf plut<75>t que des variables cod<6F>es en dur.
Remarquez aussi que "BC News" est affich<63>e si la variable $title
n'est pas d<>finie, gr<67>ce au modificateur de variable <emphasis>default</emphasis>.
</para>
</sect1>
<sect1 id="tips.dates">
<title>Dates</title>
<para>
De fa<66>on g<>n<EFBFBD>rale, essayez de toujours passer les dates <20> 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<74>le total sur le formatage des dates et de comparer
facilement les dates entre elles.
</para>
<para>
NOTE : <20> partir Smarty 1.4.0, vous pouvez passer les dates <20> 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<EFBFBD>ral convertir le r<>sultat d'un formulaire en un timestamp.
Voici une fonction qui devrait vous <20>tre utile.
</para>
<example>
<title>conversion des <20>l<EFBFBD>ments date d'un formulaire en timestamp</title>
<programlisting>
// cela suppose que vos <20>l<EFBFBD>ments de formulaire soient nomm<6D>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 <20>tre
pass<73> avec le template. Le moyen le plus facile de faire cela est d'<27>crire
une fonction utilisateur qui <20>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 <20>chouera.
</para>
<example>
<title>utilisation d'insert pour <20>crire un en-t<>te Content-Type WML</title>
<programlisting>
// assurez-vous que Apache est configur<75> 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<69>e plut<75>t chouette. Utilisez-la <20> vos propres risques. ;-)
</para>
<para>
Traditionnellemnt, la programmation avec des templates dans les applications
se d<>roule de la fa<66>on suivante : d'abord vous r<>cup<75>rez vos variables
dans l'application PHP (peut-<2D>tre avec des requ<71>tes en base de donn<6E>es), puis
vous instanciez votre objet Smarty, assignez les variables et affichez le
template. Disons par exemple que nous avons un t<>l<EFBFBD>scripteur dans
notre template. Nous r<>cup<75>rerions les donn<6E>es dans notre application,
puis les assignerions ensuite pour les afficher. Mais ne serait-ce pas
mieux de pouvoir ajouter ce t<>l<EFBFBD>scripteur <20> n'importe quelle application
en incluant directement le template sans avoir <20> se soucier de la r<>cup<75>ration
des donn<6E>es.
</para>
<para>
Vous pouvez int<6E>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<75>rent leurs propres donn<6E>es pour les assigner
<20> leurs propres variables. Avec le traitement int<6E>gr<67>
de cette fa<66>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<75>rer les donn<6E>es
function fetch_ticker($symbol,&$ticker_name,&$ticker_price) {
// du traitement qui r<>cup<75>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<66>on, vous pouvez garder s<>par<61>e la logique applicative
de la logique de pr<70>sentation. Reportez-vous <20> 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<75>rer les donn<6E>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-<2D>tes vous d<>j<EFBFBD> demand<6E> pourquoi vos adresses emails sont sur autant
de mailing listes de spam ? Une fa<66>on pour les spammers de r<>cup<75>rer les
adresses est de parcourir les pages Web. Voici une fa<66>on de rem<65>dier
<09> ce probl<62>me : mettre votre adresse email dans du Javascript brouill<6C>
au milieu de votre source HTML, sans que cela ne g<>ne l'affichage sur le
navigateur Web. Cela est fait gr<67>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 <20> l'adresse suivante : http://smarty.php.net/.
Vous pouvez souscrire <20> la mailing liste en envoyant un email <20>
smarty-general-subscribe@lists.php.net.
Les archives de la mailing list se trouvent <20> 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<6E>re version de Smarty ou
consultez le site Web.
</para>
</chapter>
</part>

46
docs/fr/common.dsl Normal file
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 "?")))

5790
docs/fr/designers.sgml Normal file
View File

File diff suppressed because it is too large Load Diff

427
docs/fr/getting-started.sgml Normal file
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<70>cis<69>ment, il facilite
la s<>paration entre la logique applicative et la pr<70>sentation.
Cela s'explique plus facilement dans une situation o<> le
programmeur et le designer de templates jouent des r<>les diff<66>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 <20>l<EFBFBD>ments de contenu, ils ne contiennent aucune information
concernant la pr<70>sentation. Ils sont transmis <20> Smarty par l'application,
puis le designer de templates <20>ditent les templates et utilisent une
combinaison de balises HTML et de balises de templates pour formater
la pr<70>sentation de ces <20>l<EFBFBD>ments (tableaux HTML, couleurs d'arri<72>re-plan,
tailles des polices, feuilles de styles, etc.). Un beau jour le programmeur
a besoin de changer la fa<66>on dont le contenu de l'article
est r<>cup<75>r<EFBFBD> (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<66>on. De m<>me, si le
le designer de templates veut changer compl<70>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<70>tention de supprimer compl<70>tement les traitements au sein des
templates.
Il est tout <20> fait envisageable de recontrer un traitement dans un template,
<20> condition que ce dernier ne d<>sserve que des besoins de pr<70>sentation.
Un conseil : laissez la logique applicative en dehors des templates et
la logique de pr<70>sentation en dehors de l'application. A l'avenir, cela permet
une meilleure gestion des <20>v<EFBFBD>nements.
</para>
<para>
L'un des aspects unique de Smarty est la compilation des templates.
Cela signifie que Smarty lit les templates et cr<63>e des scripts PHP <20> partir
de ces derniers. Une fois cr<63><72>s, ils sont ex<65>cut<75>s.
Il n'y a donc pas d'analyse co<63>teuse de template <20> chaque requ<71>te,
et les templates peuvent b<>n<EFBFBD>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<63>ristiques de Smarty :
</para>
<itemizedlist>
<listitem><para>Il est tr<74>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<63>teuse, une seule compilation.
</para></listitem>
<listitem><para>Il sait ne recompiler que les fichiers de templates
qui ont <20>t<EFBFBD> modifi<66>s.</para></listitem>
<listitem><para>Vous pouvez cr<63>er des <link linkend="language.custom.functions">
fonctions utilisateurs</link> et des <link linkend="language.modifiers">
modificateurs de variables</link> personnalis<69>s, le langage de
template est donc extr<74>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<73>es au parser PHP, la syntaxe de l'expression {if...}
peut <20>tre aussi simple ou aussi complexe que vous
le d<>sirez.</para></listitem>
<listitem><para>Imbrication illimit<69>e de sections,
de 'if', etc. autoris<69>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<6C>), vu que le moteur est extensible.</para></listitem>
<listitem><para>Support de cache int<6E>gr<67>.</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<75>rieur.
</para>
</sect1>
<sect1 id="installing.smarty.basic">
<title>Installation de base</title>
<para>
Copiez les fichiers biblioth<74>ques de Smarty du r<>pertoire
/libs/ de la distribution <20> un emplacement accessible <20> PHP.
Ce sont des fichiers PHP que vous NE DEVEZ PAS
modifier. Ils sont partag<61>s par toutes les applications et ne seront
mis <20> jour que lorsque vous installerez une nouvelle version de
Smarty.
</para>
<example>
<title>fichiers de la biblioth<74>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<65>e <link
linkend="constant.smarty.dir">SMARTY_DIR</link> qui
repr<70>sente le chemin complet de la biblioth<74>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 <20> votre application, vous
devez d<>finir SMARTY_DIR explicitement. SMARTY_DIR
<emphasis>doit</emphasis> avoir <20>tre termin<69> par un slash.
</para>
<para>
Voici comment cr<63>er une instance de Smarty dans vos scripts PHP :
</para>
<example>
<title>cr<63>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<75>,
tentez l'une des choses suivantes :
</para>
<example>
<title>fournir un chemin absolu vers la biblioth<74>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<74>que au chemin de php_include</title>
<screen>
// Editez le fichier php.ini, ajoutez le r<>pertoire de la
// biblioth<74>que Smarty au include_path et red<65>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 <20>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<6C> que vous r<>gliez ces r<>pertoires s<>par<61>ment pour chaque
application qui utilise Smarty.
</para>
<para>
Assurez-vous de bien conna<6E>tre chemin de la racine
de votre arborescence Web. Dans notre exemple, la racine
est "/web/www.mydomain.com/docs". Seul Smarty
acc<63>de aux r<>pertoires en question, et jamais le serveur Web.
Pour des raisons de s<>curit<69>, il est donc conseill<6C> 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 <20>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 <20> la racine de
l'arborescence Web,
il s'agit du script auquel l'internaute a acc<63>s. Nous allons l'appeler
"index.php" et le placer dans un sous-r<>pertoire
appel<65> "/livredor/". Il est pratique de configurer le serveur Web de
sorte que "index.php" soit identifi<66> 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<65>cut<75> sans que "index.php" ne soit sp<73>cifi<66> dans l'URL. Avec Apache
vous pouvez r<>gler cela en ajoutant "index.php" <20> la ligne o<> se
trouve DirectoryIndex (s<>parez chaque entr<74>e par un espace).
</para>
<para>
Jetons un coup d'oeil <20> 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<63>der en <20>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<63>s.
Il s'agit g<>n<EFBFBD>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<EFBFBD>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<63>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<69>e, elle donne
<20> l'utilisateur "nobody" et au groupe "nobody" les acc<63>s en
lecture/<2F>criture aux r<>pertoires. Si vous voulez donner le droit d'acc<63>s
en lecture <20> tout le monde (principalement pour pouvoir acc<63>der
vous-m<>me <20> ces fichiers), vous pouvez lui pr<70>f<EFBFBD>rer chmod 775.
</para>
</note>
<para>
Nous devons cr<63>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 <20>diteurs
de texte peuvent par exemple reconna<6E>tre le fichier et
adapter la coloration syntaxique.
</para>
</note>
<para>
Maintenant passons <20> l'<27>dition du fichier index.php. Nous allons
cr<63>er une instance de Smarty, assigner une valeur <20> 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><3E>dition de /web/www.mydomain.com/docs/livredor/index.php</title>
<screen>
// charge la biblioth<74>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<75> 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<78>rience)
moins g<>n<EFBFBD>rateur d'erreurs de les d<>finir avec des chemins
absolus. Cela nous garantit que Smarty r<>cup<75>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<6E>e</title>
<para>
Ceci est la suite de <link
linkend="installing.smarty.basic">l'installation de base</link>, veuillez
lire cette derni<6E>re avant de poursuivre.
</para>
<para>
Une mani<6E>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 <20> chaques fois les
chemins de notre environnement. Cr<43>ons un nouveau r<>pertoire
"/php/includes/livredor/" et un nouveau fichier appel<65> "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><3E>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<65> automatiquement
// <20> 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><3E>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<63>er une instance de Smarty,
correctement configur<75>e, en utilisant Smarty_livredor qui initialise
automatiquement tout ce qu'il faut pour votre application.
</para>
</sect1>
</chapter>
</part>

382
docs/fr/html-common.dsl Normal file
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)))

21
docs/fr/html.dsl Normal file
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>

44
docs/fr/manual.sgml Normal file
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<6C>gnes &lt;arnaud.cogoluegnes@free.fr&gt;</surname>
</author>
<author>
<firstname>G<>rald</firstname><surname>Cro<72>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>

21
docs/fr/php.dsl Normal file
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>

77
docs/fr/preface.sgml Normal file
View File

@@ -0,0 +1,77 @@
<preface id="preface">
<title>Pr<50>face</title>
<para>
"Comment rendre mes scripts PHP ind<6E>pendants de la pr<70>sentation ?".
Voici sans doute la question la plus pos<6F>e sur la mailing list
PHP. Alors que PHP est <20>tiquet<65> "langage de script
pour HTML", on se rend vite compte, apr<70>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<6E>re suivante : une fois le cahier des charges <20>crit,
le designer r<>alise une maquette, et donne ses interfaces
au programmeur. Le programmeur impl<70>mente les fonctionnalit<69>s applicatives
et utilise les maquettes pour faire des squelettes de templates. Le projet
est alors pass<73> au designer HTML/responsable de la mise en page qui am<61>ne les
templates jusqu'au fa<66>te de leur gloire. Il est possible que le projet fasse
une fois ou deux des allers/retours entre la programmation et la pr<70>sentation.
En cons<6E>quence, il est important de disposer d'un bon syst<73>me de template. Les
programmeurs ne veulent pas avoir <20> 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 <20> des probl<62>matiques d'interface, mais ne veulent pas
n<>cessairement avoir <20> faire <20> toutes les subtilit<69>s de la programmation PHP.
</para>
<para>
Un rapide tour d'horizon des solutions type template aujourd'hui et
l'on s'aper<65>oit que la plupart d'entre elles n'offrent que des moyens
rudimentaires pour substituer des variables dans des templates, ainsi que des
fonctionnalit<69>s limit<69>es de blocs dynamiques. Cependant nous avons
besoin d'un peu plus. Nous ne voulons pas que les programmeurs
s'occupent de la pr<70>sentation HTML du TOUT, mais cela est pratiquement
in<69>vitable. Par exemple, si un designer veut des couleurs d'arri<72>re plan
diff<66>rentes pour alterner entre diff<66>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<75>rer des variables, exploitables dans leurs
templates. Et la liste est longue.
</para>
<para>
Fin 1999, nous avons commenc<6E> <20> <20>crire une sp<73>cification pour un moteur de
template. Une fois la sp<73>cification termin<69>e,
nous avons commenc<6E> <20> travailler sur un moteur de template <20>crit
en C qui pourrait, avec un peu de chance, <20>tre inclus <20> PHP.
Non seulement nous avons rencontr<74> des probl<62>mes techniques complexes,
mais nous avons particip<69>s <20> de nombreux d<>bats sur ce que devait
et ce que ne devait pas faire un moteur de template. De cette exp<78>rience nous avons
d<>cid<69> qu'un moteur de template se devait d'<27>tre <20>crit sous la forme d'une
classe PHP, afin que quiconque puisse l'utiliser <20> sa convenance. Nous
avons donc r<>alis<69> un moteur de template qui se contentait de faire cela,
et <productname>SmartTemplate</productname> a vu le jour (note : cette
classe n'a jamais <20>t<EFBFBD> soumise au public). C'<27>tait une classe qui
faisait pratiquement tout ce que nous voulions : substitution de variables,
inclusion d'autres templates, int<6E>gration avec des fichiers de configuration,
int<6E>gration de code PHP, instruction 'if' basique et une gestion plus robuste
des blocks dynamiques imbriqu<71>s. Elle faisait tout cela avec des expressions
rationnelles et le code se r<>v<EFBFBD>la, comment dire, imp<6D>n<EFBFBD>trable. De plus, elle <20>tait
relativement lente pour les grosses applications <20> cause de l'analyse
et du travail sur les expressions rationnelles qu'elle devait faire <20> chaque
ex<65>cution. Le plus gros probl<62>me du point de vue du programmeur <20>tait
tout le travail n<>cessaire en amont, dans le script PHP, pour configurer
et ex<65>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 <20>tre rapide sans le co<63>t
d'analyse des templates. Nous savons aussi combien fastidieux
et d<>courageant peut para<72>tre le langage pour le designer moyen, et que
cela peut <20>tre remplac<61> par une syntaxe sp<73>cifique, beaucoup
plus simple. Et si nous combinions les deux forces ? Ainsi, Smarty
<20>tait n<>...
</para>
</preface>

3090
docs/fr/programmers.sgml Normal file
View File

File diff suppressed because it is too large Load Diff