Nagyrészt így vagyok vele én is. Gyakorlatilag a szintaktikájának az alapjait leszámítva nem lenne szükségem semmire a Smarty-ból. Nem érdekel, hogy korlátozni lehet a sablon íróját, hogy a PHP eszköztár csak egy részét használhassa (minek is korlátoznám magam...). Nem érdekel, hogy könnyen és gyorsan lehet hozzá plugineket írni (ha az egész PHP használható lenne, erre nincs is túl nagy szükség). Nincs szükségem semmi ilyesmire.
Sokkal inkább vonz az, ha a nyelvet gyorsan lehet gépelni (pl. mert rövid, minimális speciális karaktert használ és logikus a szerkezete). Az se egy hátrány, ha az elkészült sablon valamilyen szinten olvasható lesz. Nem lenne rossz még, ha egy elfogadható minőségű PHP kódot generálna az én sablonomból, ami aztán elfogadható (a lehető leggyorsabb) sebességgel futna. Az első kettőt még csak-csak teljesíti, de az utolsóval eléggé hadilábon áll a Smarty. Így itt az idő valami más után nézni...

A legkézenfekvőbb dolog a PHP használata lenne erre a célra, ami az első két ponton totálisan megbukik. Kiindulási alapnak viszont jó lesz:

<h1>Valami sablon</h1>

<?php if (5 > 6): ?>
	<p><?php print('5 nagyobb mint 6'); ?></p>
<?php else: ?>
	<p><?php print('5 nem nagyobb, mint 6'); ?></p>
<?php endif; ?>

Mi lenne, ha első körbe a <?php és a ?> helyett a jól megszokott { és } lenne használva?

<h1>Valami sablon</h1>

{ if (5 > 6): }
	<p>{ print('5 nagyobb mint 6'); }</p>
{ else: }
	<p>{ print('5 nem nagyobb, mint 6'); }</p>
{ endif; }

Haladunk, esetleg még a print() helyett bevezethetnénk a PHP rövid tag <?= szerkezetéhez hasonlóan egy {= szerkezetet:

<h1>Valami sablon</h1>

{ if (5 > 6): }
	<p>{= '5 nagyobb mint 6' }</p>
{ else: }
	<p>{= '5 nem nagyobb, mint 6' }</p>
{ endif; }

Pár kényelmességet elősegítő lépés múlva (szóközök, kettőspontok, felesleges zárójelek, pontosvesszők eltűntetése) sikerült eljutnom a végleges formáig:

<h1>Valami sablon</h1>

{if 5 > 6}
	<p>{='5 nagyobb mint 6'}</p>
{else}
	<p>{='5 nem nagyobb, mint 6'}</p>
{if}

Rémisztően hasonlít a Smarty-ra (ez valamilyen szinten cél is volt :)), viszont az ebből fordított PHP kód gyakorlatilag egy az egyben megegyezik az általunk írt sablon kód szerkezetével. Most, hogy megvan az alapvető szintaxis, jöhet a sablonkezelő osztály, ami a fentebb említett több ezer sorhoz képest megvalósult úgy 170 sorból (milyen csodákra képes, ha kihagyunk minden "szemetet", amire nincs szükségünk :)), ami már tartalmaz pár extra funkciót is (mint például a lefordított sablonok újrafordítási szükségességének ellenőrzését). A bemenete egy ilyen template, amiből ezt a PHP kódot generálja, valami ilyesmi kóddal:

<?php
	include('lighty.php');
	
	$l = new Lighty();
	
	$l->assign('list', array('a', 'b', 'c', 'd'));
	$l->display('teszt.tpl');
?>

Amit érdemes ezzel kapcsolatban megemlíteni, hogy a lefordított forrás első sorának elején ott van egy kommentben a fordítás ideje, ami az újrafordítás-ellenőrző számára fontos. Valamint az egész fájl egyetlen egy PHP kódblokkot tartalmaz (ami emlékeim szerint optimálisabb, mint sok-sok kis PHP kódblokk egy sablonon belül). Emiatt vannak felesleges, csak whitespace karaktereket kiíró print() hívások, de ezek megszüntethetőek. És végül, de nem utolsó sorban, a Lighty névre keresztelt sablonrendszer első publikus verziója letölthető innen. A csomagban megtalálható egy teszt.php is, ami a fentebb felvázolt példakódot tartalmazza, valamint az általa használt template fájlok és szükséges könyvtárak is.

És hogy így a végén még a címben említett kérdést is megválaszoljam: szerintem szükség van a sablonnyelvekre, mert nagyban meg tudják könnyíteni az ember életét az által, hogy meggyorsítják a sablonírás folyamatát.

Vannak esetek, amikor egy külön sablonnyelv célravezetőbb lehet, a sablont írók lekorlátozása, az átláthatóság vagy egyéb okok folytán. De milyen eszközök állnak a rendelkezésünkre, ha a PHP-t szeretnénk használni erre a feladatra? A dolgot rendkívül egyszerűen is elintézhetjük, és írhatunk ehhez hasonló sablonokat is:

<?php
	echo "<h1>".$data['title']."</h1>
		<p>".$data['text']."</p>";
?>

Azon kívül, hogy az így kapott sablonok baromi rondák és átláthatatlanok (főleg ha már elágazásokkal és ciklusokkal is tele vannak tűzdelve), böngészőben sem tudjuk rögtön megnézni őket. Nézzük tehát az első módosítást, amit eszközölhetünk a kódon:

<h1><?php echo $data['title']; ?></h1>
<p><?php echo $data['text']; ?></p>

Így már böngészőben is meg tudjuk nézni a készülő sablont, viszont nem lett sokkal szebb és átláthatóbb. Ha engedélyezve vana php.ini-ben a short_open_tag direktíva, akkor van lehetőségünk használni a következő formát:

<h1><?=$data['title'] ?></h1>
<p><?=$data['text'] ?></p>

Amennyiben erre nincs lehetőségünk, érdemes bevezetni egy függvényt, ami az adott indexű tagot elküldi a kimenetre. Legyen egy ilyen data($key, $return=false) függvény, ami $return=true esetén nem a kimenetre küldi az adatot hanem visszaadja. Ez esetben így módosul a kód:

<h1><?php data('title'); ?></h1>
<p><?php data('text'); ?></p>

A következő dolog a vezérlési szerkezetek. Az ember hamar bele tud bonyolódni a sablon végén gyülekező <?php } ?> stringekbe, hogy az akkor most melyik if vagy éppen while végét jelzi. Ilyen esetekben egész jól használhatók a PHP alternatív vezérlési szerkezetei, melyek annyiban térnek el a jól megszokott szintaxistól, hogy a soruk végén nem nyitó kapcsos zárójel van, hanem kettőspont és nem záró kapcsos zárójellel végződnek hanem a nevüknek megfelelő endif;, endwhile;, endfor;, endforeach;, vagy endswitch; szavakkal. Nézzünk példát is:

<? while ($post = data('post_object', true)->get_next_post()): ?>
<div class="post" id="post-<?=$post['id'] ?>">
	<? if ($post['id'] === 1): ?>
		<h1><?=$post['title'] ?></h1>
	<? else: ?>
		<h2><?=$post['title'] ?></h2>
	<? endif; ?>
	<div class="post-text"><?=$post['text'] ?></div>
</div>
<? endwhile; ?>

Persze a while-ban használt szerkezet csak PHP 5-ben működőképes, legalábbis az általam legutóbb használt PHP 4-es verzió még nem szerette, ha egy függvény által visszaadott objektumra ilyen módon hivatkozok. Nézzük meg, hogy egy hasonló dolgora használt kód hogyan nézne ki Smarty-ban:

{section name="post" loop=$posts}
<div class="post" id="post-{$posts[post].id}">
	{if $posts[post].id == 1}
		<h1>{$posts[post].title}</h1>
	{else}
		<h2>{$posts[post].title}</h2>
	{/if}
	<div class="post-text">{$posts[post].text}</div>
</div>
{/section}

Tény, hogy ez azért egy sokkal átláthatóbb sablonkód (és ha még azt is számításba vesszük, hogy a PHP-nél a legjobb esetet vettem figyelembe, mivel az olvashatóságot még ronthatná a teljes <?php nyitótag és a <?= helyett az echo-s változat), viszont arról sem szabad megfeledkezni, hogy ez is csak egy alternatíva, mondjuk egy olyan alternatíva, amikor a sablonkódot csak mi, vagy csak olyan emberek írják, akik értenek a PHP-hez. Nézzünk még a végére egy kis WordPress template kódot is, ami hasonló célt szolgál mint a fenti két kód:

<div class="post" id="post-<? the_ID(); ?>">
	<? if ($post->ID === 1): ?>
		<h1><? the_title(); ?></h1>
	<? else: ?>
		<h2><? the_title(); ?></h2>
	<? endif; ?>
	<div class="post-text"><? the_content('Tovább...'); ?></div>
</div>

Mint az látszik, olyan projektekben is használható a PHP alapú sablonnyelv-rendszer, mint a WordPress, amit nem hiszem, hogy csak (PHP) programozók használnának és nem hiszem, hogy csak ők írnának rá sablonokat, vagy piszkálnának bele a már meglévő sablonjaikba. Vagy egy másik jó példa a Drupal lehetne, ami szintén egy elég menő tartalomkezelő rendszer (bár ott, amennyire tudom több féle megoldás is létezik a template írására). Lényeg, hogy egyik módszert sem akarom lehordani, csak néha érdemes elgondolkozni, hogy az éppen aktuális munka készítése során mikor szükséges külön eszközt használni arra, amit a PHP-vel is könnyen megoldhatunk.

Ilyen megközelítésben természetesen eléggé használhatatlannak bizonyul a kódunk, mert csak arra az egy típusra működik megfelelően. Még szerencse, hogy itt vannak a sablonok, amikkel ez a probléma relatíve egyszerűen áthidalható.

Bevezetésnek kezdjünk valami egyszerű függvénnyel, mondjuk amivel össze tudunk adni mindenféle objektumot, aminek meg van adva a + operátora (tény, hogy a példa cseppet értelmetlen, de mondjuk gondoljunk akkor egy sort() függvényre, aminek végülis mindegy, hogy milyen adatokat hasonlít össze, amíg annak az adatszerkezetnek megvan a < vagy > operátora).

#include <string>
#include <iostream>

template<class T> T Add(const T& o1, const T& o2)
{
    return o1 + o2;
}

int main()
{
    int i1 = 1;
    int i2 = 2;
    int i3 = Add(i1, i2);
    std::cout << i3 << std::endl;

    std::string s1 = "abc";
    std::string s2 = "xyz";
    std::string s3 = Add(s1, s2);
    std::cout << s3 << std::endl;
}

Ennyi az egész, tulajdonképpen csak a választott függvényünk elé tesszük, hogy template<class T> és mindenhol, ahol egyébként mondjuk int-et írtunk volna, ott T-t használunk. Hasonló a helyzet az osztályok esetében is, nézzük először a már megírt cList.h fájlunk sablonosított változatát.

#ifndef __CLIST_H__
#define __CLIST_H__

template<class T> struct listNode
{
    listNode<T> *prev;
    listNode<T> *next;
    T data;

    listNode()
    {
        next = prev = this;
    }
    listNode(const T& num)
    {
        next = prev = this;
        data = num;
    }
};

template<class T> class cList
{
    private:
        listNode<T>* list;

        void Create(void);
        void Destroy(void);

        void Remove(listNode<T>* target);
        listNode<T>* Get(listNode<T>* target);
    public:
        cList(void);
        cList(const cList<T> &other);
        ~cList(void);

        class E_OUTOFMEMORY {};
        class E_INVALIDITEM {};

        void left_insert(listNode<T>* target, listNode<T>* data);
        void right_insert(listNode<T>* target, listNode<T>* data);
        listNode<T>* get_first(void);
        listNode<T>* get_last(void);
        listNode<T>* Search(const T& number);

        cList<T>& operator+(const cList<T>& other);
        cList<T>& operator=(const cList<T>& other);
        cList<T>& operator>>(T& number);
        cList<T>& operator>>(listNode<T>* pointer);
        cList<T>& operator<<(const T& number);
        cList<T>& operator<<(listNode<T>* pointer);
};

Pár <T>-től talán még megszabadulhatnánk, ha a listNode osztályt a cList osztályon belül adnánk meg, de most már mindegy (egy kis gyakorlás gyanánt mindenki megcsinálhatja magának). Most, hogy volt egy kis szünet, mindenki kifújta magát, visszatérhetünk az osztály metódusainak kibontogatására (maradunk a cList.h-ban):

template<class T> void cList<T>::Create(void)
{
    list = new listNode<T>();
    if (!list) throw E_OUTOFMEMORY();
 
    list->next = list;
    list->prev = list;
    return;
}

template<class T> void cList<T>::Destroy(void)
{
    while (list->prev != list) {
        Remove(list->prev);
    }
    return;
}

template<class T> void cList<T>::Remove(listNode<T>* target)
{
    listNode<T>* tmp = Get(target);
    delete tmp;
    return;
}

template<class T> listNode<T>* cList<T>::Get(listNode<T>* target)
{
    target->prev->next = target->next;
    target->next->prev = target->prev;
    target->prev = target;
    target->next = target;
    return target;
}

template<class T> cList<T>::cList(void)
{
    Create();
}

template<class T> cList<T>::cList(const cList<T>& other)
{
    Create();
 
    listNode<T>* tmp = other.list->next;
    while (tmp != other.list) {
        listNode<T>* node = new listNode<T>(tmp->data);
        if (!node) throw E_OUTOFMEMORY();
 
        this->left_insert(this->list, node);
        tmp = tmp->next;
    }
}

template<class T> cList<T>::~cList(void)
{
    Destroy();
    delete list;
}

template<class T> void cList<T>::left_insert(listNode<T>* target, listNode<T>* data)
{
    data->prev = target->prev;
    data->next = target;
    target->prev->next = data;
    target->prev = data;
    return;
}
template<class T> void cList<T>::right_insert(listNode<T>* target, listNode<T>* data)
{
    data->prev = target;
    data->next = target->next;
    target->next->prev = data;
    target->next = data;
    return;
}

template<class T> listNode<T>* cList<T>::get_first(void)
{
    if (list->next == list) throw E_INVALIDITEM();
    return Get(list->next);
}
template<class T> listNode<T>* cList<T>::get_last(void)
{
    if (list->prev == list) throw E_INVALIDITEM();
    return Get(list->prev);
}

template<class T> listNode<T>* cList<T>::Search(const T& number)
{
    listNode<T>* tmp = list->next;
    while (number != tmp->data && tmp != list) {
        tmp = tmp->next;
    }
    if (tmp == list) throw E_INVALIDITEM();
    return tmp;
}

template<class T> cList<T>& cList<T>::operator+(const cList<T>& other)
{
    listNode<T>* tmp = other.list->next;
    while (tmp != other.list) {
        listNode<T>* node = new listNode<T>(tmp->data);
        if (!node) throw E_OUTOFMEMORY();
 
        this->left_insert(this->list, node);
        tmp = tmp->next;
    }
}
template<class T> cList<T>& cList<T>::operator=(const cList<T>& other)
{
    if (this == &other) return *this;
    this->Destroy();
 
    listNode<T>* tmp = other.list->next;
    while (tmp != other.list) {
        listNode<T>* node = new listNode<T>(tmp->data);
        if (!node) throw E_OUTOFMEMORY();
 
        this->left_insert(this->list, node);
        tmp = tmp->next;
    }
    return *this;
}

template<class T> cList<T>& cList<T>::operator>>(T& number)
{
    number = get_last()->data;
    return *this;
}
template<class T> cList<T>& cList<T>::operator>>(listNode<T>* pointer)
{
    pointer = get_last();
    return *this;
}
 
template<class T> cList<T>& cList<T>::operator<<(const T& number)
{
    listNode<T>* tmp = new listNode<T>(number);
    if (!tmp) throw E_OUTOFMEMORY();
 
    left_insert(list, tmp);
    return *this;
}
template<class T> cList<T>& cList<T>::operator<<(listNode<T>* pointer)
{
    left_insert(list, pointer);
    return *this;
}

#endif

Nincs más hátra, mint egy megfelelő main.cpp-vel tesztelni ezt a rengeteg kódot, hogy egyáltalán működik-e ez az egész:

#include <string>
#include <iostream>

#include "cList.h"

int main()
{
        cList<int> list1;
        list1 << 1 << 2 << 3 << 4 << 5;
        int num;
        list1 >> num;
        std::cout << num << std::endl;

        cList<char> list2;
        list2 << 'a' << 'b' << 'c' << 'd' << 'e';
        char chr;
        list2 >> chr;
        std::cout << chr << std::endl;

        cList<std::string> list3;
        list3 << "alma" << "barack" << "citrom" << "dinnye" << "eper";
        std::string str;
        list3 >> str;
        std::cout << str << std::endl;
}

A fenti kód lefordítása majd futtatása után keletkezett kimenet legjobb esetben az, hogy 5, e, eper (mindegyik új sorban). Ezzel a sablonizációs bejegyzés végére is értünk, a legközelebbi alkalommal származtatni fogunk, ha a C++ istenei is így akarják.

A dolog esetünkben úgy néz ki, hogy létezik egy template.xml és egy template.xsl. A template.xml-ben találhatóak az alapértelmezett adatok (vagy csak az alapértelmezett adatszerkezet üresen), a template.xsl pedig maga a sablon, amire ráhúzzuk a template.xml segítségével az adatokat. Ennek a megoldásnak az előnye, hogy így az adatokat egyszerűen XPath segítségével (ami szintén beépített támogatást élvez PHP-ben) pofonegyszerűen tudjuk majd átadni az XSLT feldolgozónak. Nézzük a példafájlokat:

template.xml

<?xml version="1.0" encoding="utf-8"?>
<content>
	<title value=""/>
	<url value=""/>
	<content><![CDATA[]]></content>
</content>

template.xsl

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" encoding="utf-8" indent="no"/>
	<xsl:template match="/">
		<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="hu">
			<head>
				<title><xsl:value-of select="content/title/@value"/></title>
			</head>
			<body>
				<h1><a href="{content/url/@value}"><xsl:value-of select="content/title/@value"/></a></h1>
				<p><xsl:value-of select="content/text" disable-output-escaping="yes"/></p>
			</body>
		</html>
	</xsl:template>
</xsl:stylesheet>

Igazából innentől már csak egy minimális PHP kód következik, ami előre definiált adatok alapján (a $transformation tömb, amit a feldolgozó modul elég sok módon megkaphat) feltölti a betöltött template.xml-t adatokkal és a template.xsl segítségével elkészíti a kívánt formátumot:

/*
	'Tartalom' betöltése
*/
$content_xsl   = &DOMDocument::load('template.xsl');
$content       = &DOMDocument::load('template.xml');
$content_xpath = &new DOMXPath($content);

$transformation['/content/title/@value'] = 'Valami cím';
$transformation['/content/url/@value'] = 'http://www.something.com/';
$transformation['/content/content/text()'] = 'Valami szöveg...';

/*
	Transzformációk végrehajtása
*/
foreach ($transformation as $path => $value) {
	if (!is_array($value)) {
		$content_xpath->query($path)->item(0)->nodeValue = $value;
	}
	else {
		foreach ($value as $key => $node) {
			$content_node = $content->importNode($node, true);
			$content_xpath->query($path)->item(0)->appendChild($content_node);
		}
	}
}

$proc = &new XSLTProcessor();
$proc->importStylesheet($content_xsl);

print $proc->transformToDoc($content)->saveXML();

A lényeg a $transformation tömb megadása, ami a feljebb betöltött XML fájlt alakítja át. Ahogy az a foreach ciklusban látszik, két fajta értéket adhatunk az XPath szerű asszociatív hozzárendelésnek. Sima stringet, vagy egy tömböt. Tömb esetén a tömbelemek értékei DOMDocument típusúak kell, hogy legyenek.
A dolog legnagyobb szépsége viszont az, hogy ha a template.xsl-t lecseréljük, de minden mást változatlanul hagyunk, akkor például HTML helyett generálhatunk akár RSS-t is:

template.xsl

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" encoding="utf-8" indent="no"/>
	<xsl:template match="/">
	<rss version="2.0">
		<channel>
			<title>Teszt RSS</title>
			<link>http://www.something.com/</link>
			<description>Ez egy teszt fájl a teszt RSS-nek...</description>

			<item>
				<title><xsl:value-of select="content/title/@value"/></title>
				<link><xsl:value-of select="content/url/@value"/></link>
				<description><xsl:value-of select="content/content/text()"/></description>
			</item>
		</channel>
	</rss>
	</xsl:template>
</xsl:stylesheet>

De szép az élet így, ha van valami, ami eléggé megkönnyíti (persze a header-rel még egy csepp gond van így ebben az esetben, de az most lényegtelen). Nosza, lehet nekiállni a régi és megunt rendszeredet XSLT alapokra helyezni, mert az - ahogy a fenti példa is mutatja - jó. De természetesen ízlés kérdése. Ha az ember csak egy saját kis oldalt fejlesztget, és tudja, hogy más nem fog belenyúlni a sablonokba, akkor igazából a PHP, mint sablon-nyelv is tökéletesen megfelel a célra. Tehát: használja, aki úgy érzi, hogy szüksége van rá.