|
Template - Front-end module to the Template Toolkit |
Template - Front-end module to the Template Toolkit
use Template;
# some useful options (see below for full list)
my $config = {
INCLUDE_PATH => '/search/path', # or list ref
INTERPOLATE => 1, # expand "$var" in plain text
POST_CHOMP => 1, # cleanup whitespace
PRE_PROCESS => 'header', # prefix each template
EVAL_PERL => 1, # evaluate Perl code blocks
};
# create Template object my $template = Template->new($config);
# define template variables for replacement
my $vars = {
var1 => $value,
var2 => \%hash,
var3 => \@list,
var4 => \&code,
var5 => $object,
};
# specify input filename, or file handle, text reference, etc. my $input = 'myfile.html';
# process input template, substituting variables
$template->process($input, $vars)
|| die $template->error();
This documentation describes the Template module which is the direct Perl interface into the Template Toolkit. It covers the use of the module and gives a brief summary of configuration options and template directives. Please see the Template::Manual manpage for the complete reference manual which goes into much greater depth about the features and use of the Template Toolkit. The the Template::Tutorial manpage is also available as an introductory guide to using the Template Toolkit.
new(\%config)The new() constructor method (implemented by the Template::Base base
class) instantiates a new Template object. A reference to a hash
array of configuration items may be passed as a parameter.
my $tt = Template->new({
INCLUDE_PATH => '/usr/local/templates',
EVAL_PERL => 1,
}) || die $Template::ERROR, "\n";
A reference to a new Template object is returned, or undef on error.
In the latter case, the error message can be retrieved by calling
error() as a class method (e.g. Template->error()) or by
examining the $ERROR package variable directly
(e.g. $Template::ERROR).
my $tt = Template->new(\%config)
|| die Template->error(), "\n";
my $tt = Template->new(\%config)
|| die $Template::ERROR, "\n";
For convenience, configuration items may also be specified as a list of items instead of a hash array reference. These are automatically folded into a hash array by the constructor.
my $tt = Template->new(INCLUDE_PATH => '/tmp', POST_CHOMP => 1)
|| die $Template::ERROR, "\n";
The process() method is called to process a template. The first
parameter indicates the input template as one of: a filename relative
to INCLUDE_PATH, if defined; a reference to a text string containing
the template text; or a file handle reference (e.g. IO::Handle or
sub-class) or GLOB (e.g. \*STDIN), from which the template can be
read. A reference to a hash array may be passed as the second
parameter, containing definitions of template variables.
$text = "[% INCLUDE header %]\nHello world!\n[% INCLUDE footer %]";
# filename
$tt->process('welcome.tt2')
|| die $tt->error(), "\n";
# text reference
$tt->process(\$text)
|| die $tt->error(), "\n";
# GLOB
$tt->process(\*DATA)
|| die $tt->error(), "\n";
__END__
[% INCLUDE header %]
This is a template defined in the __END__ section which is
accessible via the DATA "file handle".
[% INCLUDE footer %]
By default, the processed template output is printed to STDOUT. The
process() method then returns 1 to indicate success. A third
parameter may be passed to the process() method to specify a different
output location. This value may be one of: a plain string indicating
a filename which will be opened (relative to OUTPUT_PATH, if defined)
and the output written to; a file GLOB opened ready for output; a
reference to a scalar (e.g. a text string) to which output/error is
appended; a reference to a subroutine which is called, passing the
output as a parameter; or any object reference which implements a
'print' method (e.g. IO::Handle, Apache::Request, etc.) which will
be called, passing the generated output as a parameter.
Examples:
# output filename
$tt->process('welcome.tt2', $vars, 'welcome.html')
|| die $tt->error(), "\n";
# reference to output subroutine
sub myout {
my $output = shift;
...
}
$tt->process('welcome.tt2', $vars, \&myout)
|| die $tt->error(), "\n";
# reference to output text string
my $output = '';
$tt->process('welcome.tt2', $vars, \$output)
|| die $tt->error(), "\n";
print "output: $output\n";
In an Apache/mod_perl handler:
sub handler {
my $req = shift;
...
# direct output to Apache::Request via $req->print($output)
$tt->process($file, $vars, $req) || do {
$req->log_reason($tt->error());
return SERVER_ERROR;
};
return OK;
}
After the optional third output argument can come an optional reference to a hash or a list of (name, value) pairs providing further options for the output. The only option currently supported is ``binmode'' which, when set to any true value will ensure that files created (but not any existing file handles passed) will be set to binary mode.
# either: hash reference of options
$tt->process($infile, $vars, $outfile, { binmode => 1 })
|| die $tt->error(), "\n";
# or: list of name, value pairs
$tt->process($infile, $vars, $outfile, binmode => 1)
|| die $tt->error(), "\n";
The OUTPUT configuration item can be used to specify a default output location other than \*STDOUT. The OUTPUT_PATH specifies a directory which should be prefixed to all output locations specified as filenames.
my $tt = Template->new({
OUTPUT => sub { ... }, # default
OUTPUT_PATH => '/tmp',
...
}) || die Template->error(), "\n";
# use default OUTPUT (sub is called)
$tt->process('welcome.tt2', $vars)
|| die $tt->error(), "\n";
# write file to '/tmp/welcome.html'
$tt->process('welcome.tt2', $vars, 'welcome.html')
|| die $tt->error(), "\n";
The process() method returns 1 on success or undef on error. The error
message generated in the latter case can be retrieved by calling the
error() method. See also CONFIGURATION SUMMARY which describes how
error handling may be further customised.
error()When called as a class method, it returns the value of the $ERROR package variable. Thus, the following are equivalent.
my $tt = Template->new()
|| die Template->error(), "\n";
my $tt = Template->new()
|| die $Template::ERROR, "\n";
When called as an object method, it returns the value of the internal _ERROR variable, as set by an error condition in a previous call to process().
$tt->process('welcome.tt2')
|| die $tt->error(), "\n";
Errors are represented in the Template Toolkit by objects of the
Template::Exception class. If the process() method returns a false
value then the error() method can be called to return an object of
this class. The type() and info() methods can called on the object to
retrieve the error type and information string, respectively. The
as_string() method can be called to return a string of the form ``$type
- $info''. This method is also overloaded onto the stringification
operator allowing the object reference itself to be printed to return
the formatted error string.
$tt->process('somefile') || do {
my $error = $tt->error();
print "error type: ", $error->type(), "\n";
print "error info: ", $error->info(), "\n";
print $error, "\n";
};
service()The Template module delegates most of the effort of processing templates to an underlying Template::Service object. This method returns a reference to that object.
context()The Template::Service module uses a core Template::Context object for runtime processing of templates. This method returns a reference to that object and is equivalent to $template->service->context();
The following list gives a short summary of each Template Toolkit configuration option. See the Template::Manual::Config manpage for full details.
template(s) to process before/after main template.
template(s) to process instead of main template.
The following list gives a short summary of each Template Toolkit directive. See the Template::Manual::Directives manpage for full details.
[% GET variable %] # 'GET' keyword is optional
[% variable %]
[% hash.key %]
[% list.n %]
[% code(args) %]
[% obj.meth(args) %]
[% "value: $var" %]
[% CALL variable %]
[% SET variable = value %] # 'SET' also optional
[% variable = other_variable
variable = 'literal text @ $100'
variable = "interpolated text: $var"
list = [ val, val, val, val, ... ]
list = [ val..val ]
hash = { var => val, var => val, ... }
%]
[% DEFAULT variable = value %]
[% INSERT legalese.txt %]
[% INCLUDE template %]
[% INCLUDE template var = val, ... %]
[% PROCESS template %]
[% PROCESS template var = val, ... %]
[% WRAPPER template %]
content...
[% END %]
[% BLOCK template %]
content
[% END %]
[% FOREACH variable = [ val, val, val ] %] # either
[% FOREACH variable = list %] # or
[% FOREACH list %] # or
content...
[% variable %]
[% END %]
[% WHILE condition %]
content
[% END %]
[% IF condition %]
content
[% ELSIF condition %]
content
[% ELSE %]
content
[% END %]
[% UNLESS condition %]
content
[% # ELSIF/ELSE as per IF, above %]
content
[% END %]
[% SWITCH variable %]
[% CASE val1 %]
content
[% CASE [ val2, val3 ] %]
content
[% CASE %] # or [% CASE DEFAULT %]
content
[% END %]
[% MACRO name <directive> %]
[% MACRO name(arg1, arg2) <directive> %]
...
[% name %]
[% name(val1, val2) %]
[% FILTER name %] # either
[% FILTER name( params ) %] # or
[% FILTER alias = name( params ) %] # or
content
[% END %]
[% USE name %] # either
[% USE name( params ) %] # or
[% USE var = name( params ) %] # or
...
[% name.method %]
[% var.method %]
[% PERL %]
# perl code goes here
$stash->set('foo', 10);
print "set 'foo' to ", $stash->get('foo'), "\n";
print $context->include('footer', { var => $val });
[% END %]
[% RAWPERL %]
# raw perl code goes here, no magic but fast.
$output .= 'some output';
[% END %]
[% TRY %]
content
[% THROW type info %]
[% CATCH type %]
catch content
[% error.type %] [% error.info %]
[% CATCH %] # or [% CATCH DEFAULT %]
content
[% FINAL %]
this block is always processed
[% END %]
[% NEXT %]
[% LAST %]
[% RETURN %]
[% STOP %]
[% TAGS html %]
[% TAGS <!-- --> %]
[% # this is a comment to the end of line
foo = 'bar'
%]
[%# placing the '#' immediately inside the directive
tag comments out the entire directive
%]
Andy Wardley <abw@andywardley.com>
http://www.andywardley.com/|http://www.andywardley.com/
Template Toolkit version 2.10, released on 24 July 2003.
Copyright (C) 1996-2003 Andy Wardley. All Rights Reserved. Copyright (C) 1998-2002 Canon Research Centre Europe Ltd.
This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
|
Template - Front-end module to the Template Toolkit |