[ SourceForge | Download | ViewCVS ]
This class provides an extremely fast, lightweight templating system for HTML and other text-based documents.
Like FastTemplate and its many clones, MTPL supports nested blocks and looping. However, the entire implementation is done without a single regular expression. The PHP interpreter is leveraged for its built-in variable interpolation, and explode() is used to separate block markers from content using a simple delimiter. As a result, the overhead of reading and parsing template files is minimal. This should eliminate the need for a cache and improve the overall performance of template- driven sites.
Since PHP's dollar sign notation (ie. "$var") is used to identify content placeholders, it is sometimes necessary to escape dollar signs in your template (ie. "\$$amount"). You can use arrays with the form $array[element]; just don't quote the index. $array['element'] or $array["element"] will generate PHP parse errors due to the way PHP evaluates hashes in a string context. For the same reason, multi-level arrays will not work ("$a[b][c]" becomes the value of $a[b] followed by the literal text "[c]").
Global variables can be accessed using the usual $GLOBALS[] array method. For instance, to get the script URL, you can use $GLOBALS[PHP_SELF].
There are a few other differences. The assign() method found in most PHP template classes is gone. Instead, all assigned variables must be provided as a hash that is passed to the parse() method. Since in almost every single case a series of assign()'s is done followed by a single call to parse(), this eliminates some redundancy. It also provides a more strict scoping to template variables which should result in scripts that are easier to debug.
Two variations on parse() exist: parseLoop() and parseOut(). parseLoop() takes a list of hashes instead of a single hash of variables to assign and calls parse() on the same block for each. This allows you to populate tables and drop-downs without the need to write loops into your code. parseOut() iteratively calls parse() for a given block and each of its parents in order. For instance, parseOut('main.section.sub') will parse 'main.section.sub', then 'main.section', then 'main'. Both of these methods should reduce the amount of code you need to write for typical operations.
You will also notice that there is no out(), text(), or print() method. Rather than holding onto all output internally, the parse() and related methods return the resulting output. To output the result of a parse operation, simply: echo parse(...);
PHP's native error handling is used for all errors and warnings. In addition, by adding "error_handling(E_ALL);" to your scripts, the PHP interpreter will warn you about any uninitialized template variables. Granted, the error messages are a bit odd (since interpolation is done inside of an eval()), but this can be a good way to track down typos. Hopefully PHP will provide stack traces on errors soon.
Any comments, code suggestions, or bug-fixes would be appreciated. Don't expect any big feature additions, though; my goal was to keep this fast, simple, and effective. If you're looking for a more robust, feature-laden solution, I'd suggest you take a look at Smarty. On the other hand, if speed and transparency are your primary concerns, this may be just what you have been looking for.
Peace,
Dave Benjamin
Lead developer, Ovum Design