NAME
Template::TAL - Process TAL templates with Perl
SYNOPSIS
# create the TT object, telling it where the templates are
my $tt = Template::TAL->new( include_path => "./templates" );
# data to interpolate into the template
my $data = {
foo => "bar",
};
# process the template from disk (in ./templates/test.tal) with the data
print $tt->process("test.tal", $data);
DESCRIPTION
TAL is a templating language used in the Zope CMS. Template::TAL is a
Perl implementation of TAL based on the published specs on the Zope
wiki.
TAL templates are XML documents, and use attributes in the TAL namespace
to define how elements of the template should be treated/displayed. For
example:
my $template = <<'ENDOFXML';
<html xmlns:tal="
http://xml.zope.org/namespaces/tal">
<head>
<title tal:content="title"/>
</head>
<body>
<h1>This is the <span tal:replace="title"/> page</h1>
<ul>
<li tal:repeat="user users">
<a href="?" tal:attributes="href user/url"><span tal:replace="user/name"/></a>
</li>
</ul>
</body>
</html>
ENDOFXML
This template can be processed by passing it and the parameters to the
"process" method:
my $tt = Template::TAL->new();
$tt->process(\$template, {
title => "Bert and Ernie Fansite",
users => [
{ url => "
http://www.henson.com/", name => "Henson", },
{ url => "
http://www.sesameworkshop.org/", name => "Workshop", },
{ url => "
http://www.bertisevil.tv/", name => "Bert is Evil", },
],
})
Alternativly you can store the templates on disk, and pass the filename
to "process" directly instead of via a reference (as shown in the
synopsis above.)
Template::TAL is designed to be extensible, allowing you to load
templates from different places and produce more than one type of
output. By default the XML template will be output as cross-browser
compatible HTML (meaning, for example, that image tags won't be closed.)
Other output formats, including well-formed XML, can easily be produced
by changing the output class (detailed below.)
For more infomation on the TAL spec itself, see
http://www.zope.org/Wikis/DevSite/Projects/ZPT/TAL%20Specification%201.4
METHODS
new( include_path => ['/foo/bar'], charset => 'utf-8' )
Creates and initializes a new Template::TAL object. Options valid
here are:
include_path
If this parameter is set then it is passed to the provider,
telling it where to load files from disk (if applicable for the
provider.)
charset
If this parameter is set then it is passed to the output,
telling it what charset to use instead of its default. The
default output class will use the 'utf-8' charset unless you
tell it otherwise.
provider
Pass a 'provider' option to specify a provider rather than using
the default provider that reads from disk. This can either be a
class name of a loaded class, or an object instance.
output
Pass a 'output' option to specify a output class rather than
using the default output class that dumps the DOM tree to as a
string to create HTML. This can either be a class name of a
loaded class, or an object instance.
languages
a listref of language plugins we will use when parsing. All
templates get at least the Template::TAL::Language:TAL language
module.
add_language( language module, module, module... )
adds a language to the list of those used by the template renderer.
'module' here can be a classname or an instance.
process( $template, $data_hashref )
Process the template with the passed data and return the resulting
rendered byte sequence.
$template can either be a string containing where the provider
should get the template from (i.e. the filename of the template in
the include path), a reference to a string containing the literal
text of the template, or a Template::TAL::Template object.
$data_hashref should be a reference to a hash containing the values
that are to be substituted into the template.
parse_tales( value, context, context,... )
Parses a TALES string (see
http://www.zope.org/Wikis/DevSite/Projects/ZPT/TALES), looking in
each of the passed contexts in order for variable values, and
returns the value.
ATTRIBUTES
These are get/set chained accessor methods that can be used to alter the
object after initilisation (meaning they return their value when called
without arguments, and set the value and return $self when called with.)
In both cases you can set these to either class names or actual
instances and they with do the right thing.
provider
The instance of the Template::TAL::Provider subclass that will be
providing templates to this engine.
output
The instance of the Template::TAL::Output subclass that will be used
to render the produced template output.
RATIONALE
Petal is another Perl module that can process a templating language
suspiciously similar to TAL. So why did we implement Yet Another
Templating Engine? Well, we liked Petal a lot. However, at the time of
writing our concerns with Petal were:
* Petal isn't strictly TAL. We consider this a flaw.
* Petal assumes rather strongly that templates are stored on disk. We
wanted a system with a pluggable template source so that we could
store templates in other places (such as a database.)
* Petal does lots of caching. This is a good thing if you've got a
small number of templates compared to the number of pages you serve.
However, if you've got a vast number of templates - more than you
can hold in memory - then this quickly becomes self defeating. We
wanted code that doesn't have any caching in it at all.
In conclusion: You may be better off using Petal. Certainly the caching
layer could be very useful to you.
There's more than one way to do it.
COPYRIGHT
Written by Tom Insam, Copyright 2005 Fotango Ltd. All Rights Reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
BUGS
Template::TAL creates superfluous XML namespace attributes in the
output.
Please report any bugs you find via the CPAN RT system.
http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Template::TAL
SEE ALSO
The TAL specification:
http://www.zope.org/Wikis/DevSite/Projects/ZPT/TAL%20Specification%201.4
Petal, another Perl implementation of TAL on CPAN.
