Smarty: A closer look
Intended Audience
Overview
How it works
Extending Smarty with Wrapper Classes
Template Caching with Smarty
Securing Smarty
Template Configuration Files
Data Manipulation within Templates
Summary
About the Author
Intended Audience
This article is intended for PHP programmers and HTML designers wishing to utilize the more advanced features of the Smarty templating engine. A working knowledge of PHP, PHP's OOP structure, and HTML is assumed. This article also assumes the reader has read Cezar Floroiu's introductory article PHP Templating with Smarty and has a working Smarty setup.Overview
At its most basic, Smarty allows programmers to unchain themselves from the design process, a long standing dream of many. However, Smarty also has many advanced features that you may have been missing out on.This article will demonstrate some of the more complex features in Smarty such as security features, template caching, and extending Smarty with wrapper classes. This article will show HTML designers how to extend their templates with configuration files and built-in data manipulation functions.
How it works
Extending Smarty with Wrapper Classes
By default Smarty looks for templates in the directory in which it is called. Often this isn't feasible within your site's directory structure since, for security reasons, templates should not be placed in a web accessible directory. In order to change Smarty's default behavior you need to create a wrapper class (that is actually a child class of the Smarty class).
<?php
// Define our template directories
define('TEMPLATE_DIR','/usr/share/templates');
define('COMPILE_DIR','/usr/share/templates/templates_c');
define('CONFIG_DIR','/usr/share/templates/configs');
define('CACHE_DIR','/usr/share/templates/cache');
// Create a wrapper class extended from Smarty
class Page extends Smarty
{
// $cache and $cache_lifetime are the two main variables
// that control caching within Smarty
function Page($cache = true, $cache_lifetime = 300)
{
// Run Smarty's constructor
$this->Smarty();
// Change the default template directories
$this->template_dir = TEMPLATE_DIR;
$this->compile_dir = COMPILE_DIR;
$this->config_dir = CONFIG_DIR;
$this->cache_dir = CACHE_DIR;
// Change default caching behavior
$this->caching = $cache;
$this->cache_lifetime = $cache_lifetime;
}
}
$page = new Page();
$page->assign('foo','bar');
$page->display('foo.tpl');
?>
Template Caching with Smarty
In the above code you'll noticeSmarty::caching and Smarty::cache_lifetime
are set with default values. Smarty does not enable caching by default, but by
turning it on you increase the speed with which Smarty is able to process requests
for templates.By default our Page class sets the lifetime of our cache to 5 minutes. It is important to note this while doing development on your code. If you tweak the output or your designer makes changes to the template Smarty will not reflect those changes for 5 minutes unless you do one of two things: set
Smarty::cache_lifetime
to 0 or set Smarty::force_compile to TRUE. (Setting
Smarty::force_compile to TRUE makes Smarty regenerate
the template each time the script is called. The Smarty documentation says this
should only be used for development and debugging and should not be used in a
production environment.)
Securing Smarty
By default Smarty allows PHP code to be run within templates using {php}{/php} tags. This may, or may not, be a good idea. In my experience it is better to limit the control given to designers. Random PHP code inserted into your page could interfere with the desired effects of the application or even break the application altogether.To disable the use of PHP within your Smarty templates, set
Smarty::php_handling to
SMARTY_PHP_REMOVE in your wrapper class
constructor. Enabling Smarty's security feature, which by default is set to
FALSE,
makes Smarty run in a sort of safe mode. This is desirable if you have untrusted
parties editing the templates, such as those accessing the templates via FTP.
To enable this feature set Smarty::security to TRUE
in your wrapper class' constructor.
Template Configuration Files
Configuration files are a great way for template designers to set global variables, such as common colors, to be used across many templates.
# Sample configuration file
# Pound signs are used for comments
colorA = #cccccc
colorB = #eeeeee
title = "My Homepage"
[Login]
title = "Login to My Account"
titleColor = #000000
To use your newly created configuration file you will need to use the
{config_load}
function.
{config_load file="config.conf"}
<html>
<title>{#title#}</title>
<body bgcolor="{#colorA#}">
Your template stuff goes here.
</body>
</html>
section parameter.
{config_load file="config.conf" section="Login"}
<html>
<title>{#title#}</title>
<body bgcolor="{#colorA#}">
Your template stuff goes here.
</body>
</html>
{#title#} variable would output "Login to
My Account" while {#colorA} would remain #cccccc.
Data Manipulation within Templates
Smarty includes a decent array of variable modifiers, including various string manipulations and date formatting. For a complete listing of the variable modifiers you will want to check out http://smarty.php.net/manual/en/language.modifiers.php. Developers might be interested in creating their own modifiers, and Smarty supports this. For more information on creating your own modifiers, filters, and plugins, check out http://smarty.php.net/manual/en/plugins.php.Let's first take a look at date formatting. Many programmers store dates in nonreadable formats, such as UNIX timestamps. Smarty's built in date_format function accepts any time format parsable by PHP's
strftime() function.
{$smarty.now|date_format:"%m-%d-%Y"}
{$smarty.now|date_format:"%A %B, %e %Y"}
Other modifiers of note include upper, capitalize, and truncate.
Upper
is equivalent to PHP's strtoupper() function, capitalize
is similar to PHP's ucwords(), while truncate simply
takes the variable and limits it to a given number of characters.
Summary
Smarty has many advanced features that allow programmers to increase the efficiency of their applications. Smarty also has many complex template features to give designers more refined control over the formatting of the template data.Maybe Smarty is the answer to the long running standoff between programmers wanting to keep control of their applications and designers needing refined control over the output of those applications.
Comments