template(3)

NAME

Template - Front-end module to the Template Toolkit

SYNOPSIS

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();

DESCRIPTION

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
Template::Manual for the complete reference manual which
goes into much greater depth about the features and use of
the Template Toolkit. The Template::Tutorial is also
available as an introductory guide to using the Template
Toolkit.

METHODS

new%(config)

The new() constructor method (implemented by the Tem plate::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, "0;
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. "Tem plate->error()") or by examining the $ERROR package variable directly (e.g. $Template::ERROR).: my $tt = Template->new(config)
|| die Template->error(), "0;; my $tt = Template->new(config)
|| die $Template::ERROR, "0;
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, "0;
process($template,%vars, $output)
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. TDIN), 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 %]0ello world!INCLUDE foot; er %]";; # filename
$tt->process('welcome.tt2')
|| die $tt->error(), "0;; # text reference
$tt->process(ext)
|| die $tt->error(), "0;; # GLOB
$tt->process(ATA)
|| die $tt->error(), "0;; __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 out put; 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(), "0;; # reference to output subroutine
sub myout {
my $output = shift;
...; }
$tt->process('welcome.tt2', $vars, myout)
|| die $tt->error(), "0;; # reference to output text string
my $output = '';
$tt->process('welcome.tt2', $vars, utput)
|| die $tt->error(), "0;; print "output: $output0;
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;; }
The OUTPUT configuration item can be used to specify a default output location other than TDOUT. The OUT PUT_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(), "0;; # use default OUTPUT (sub is called)
$tt->process('welcome.tt2', $vars)
|| die $tt->error(), "0;; # write file to '/tmp/welcome.html'
$tt->process('welcome.tt2', $vars, 'welcome.html')
|| die $tt->error(), "0;
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 equiva lent.: my $tt = Template->new()
|| die Template->error(), "0;; my $tt = Template->new()
|| die $Template::ERROR, "0;
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(), "0;
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(), "0;
print "error info: ", $error->info(), "0;
print $error, "0;; };
service()
The Template module delegates most of the effort of pro cessing 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();

CONFIGURATION SUMMARY

The following list gives a short summary of each Template
Toolkit configuration option. See Template::Manual::Con
fig for full details.

Template Style and Parsing Options

START_TAG, END_TAG: Define tokens that indicate start and end of direc
tives (default: '[%' and '%]').
TAG_STYLE: Set START_TAG and END_TAG according to a pre-defined
style (default: 'template', as above).
PRE_CHOMP, POST_CHOMP: Remove whitespace before/after directives (default:
0/0).
TRIM: Remove leading and trailing whitespace from template
output (default: 0).
INTERPOLATE: Interpolate variables embedded like $this or ${this}
(default: 0).
ANYCASE: Allow directive keywords in lower case (default: 0 UPPER only).
Template Files and Blocks
INCLUDE_PATH: One or more directories to search for templates.
DELIMITER: Delimiter for separating paths in INCLUDE_PATH
(default: ':').
ABSOLUTE: Allow absolute file names, e.g. /foo/bar.html
(default: 0).
RELATIVE: Allow relative filenames, e.g. ../foo/bar.html
(default: 0).
DEFAULT: Default template to use when another not found.
BLOCKS: Hash array pre-defining template blocks.
AUTO_RESET: Enabled by default causing BLOCK definitions to be
reset each time a template is processed. Disable to
allow BLOCK definitions to persist.
RECURSION: Flag to permit recursion into templates (default: 0).
Template Variables
VARIABLES, PRE_DEFINE: Hash array of variables and values to pre-define in
the stash.
Runtime Processing Options
EVAL_PERL: Flag to indicate if PERL/RAWPERL blocks should be pro
cessed (default: 0).
PRE_PROCESS, POST_PROCESS: Name of template(s) to process before/after main tem
plate.
PROCESS: Name of template(s) to process instead of main tem
plate.
ERROR: Name of error template or reference to hash array map
ping error types to templates.
OUTPUT: Default output location or handler.
OUTPUT_PATH: Directory into which output files can be written.
DEBUG: Flag which, when enabled, causes any access to an
undefined variable to be raised as an 'undef' error.
Caching and Compiling Options
CACHE_SIZE: Maximum number of compiled templates to cache in mem
ory (default: undef - cache all)
COMPILE_EXT: Filename extension for compiled template files
(default: undef - don't compile).
COMPILE_DIR: Root of directory in which compiled template files
should be written (default: undef - don't compile).
Plugins and Filters
PLUGINS: Reference to a hash array mapping plugin names to Perl
packages.
PLUGIN_BASE: One or more base classes under which plugins may be
found.
LOAD_PERL: Flag to indicate regular Perl modules should be loaded
if a named plugin can't be found (default: 0).
FILTERS: Hash array mapping filter names to filter subroutines
or factories.
Compatibility, Customisation and Extension
V1DOLLAR: Backwards compatibility flag enabling version 1.* han
dling (i.e. ignore it) of leading '$' on variables
(default: 0 - '$' indicates interpolation).
LOAD_TEMPLATES: List of template providers.
LOAD_PLUGINS: List of plugin providers.
LOAD_FILTERS: List of filter providers.
TOLERANT: Set providers to tolerate errors as declinations
(default: 0).
SERVICE: Reference to a custom service object (default:
Template::Service).
CONTEXT: Reference to a custom context object (default: Tem
plate::Context).
STASH: Reference to a custom stash object (default: Tem
plate::Stash).
PARSER: Reference to a custom parser object (default: Tem
plate::Parser).
GRAMMAR: Reference to a custom grammar object (default: Tem
plate::Grammar).

DIRECTIVE SUMMARY

The following list gives a short summary of each Template
Toolkit directive. See Template::Manual::Directives for
full details.

GET Evaluate and print a variable or value.: [% GET variable %] # 'GET' keyword is option; al; [% variable %]
[% hash.key %]
[% list.n %]
[% code(args) %]
[% obj.meth(args) %]
[% "value: $var" %]
CALL: As per GET but without printing result (e.g. call
code)

[% CALL variable %]
SET Assign a values to variables.: [% SET variable = value %] # 'SET' also option; al; [% 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: Like SET above, but variables are only set if cur
rently unset (i.e. have no true value).

[% DEFAULT variable = value %]
INSERT: Insert a file without any processing performed on the
contents.

[% INSERT legalese.txt %]
INCLUDE: Process another template file or block and include the
output. Variables are localised.

[% INCLUDE template %]
[% INCLUDE template var = val, ... %]
PROCESS: As INCLUDE above, but without localising variables.

[% PROCESS template %]
[% PROCESS template var = val, ... %]
WRAPPER: Process the enclosed block WRAPPER ... END block then
INCLUDE the named template, passing the block output
in the 'content' variable.

[% WRAPPER template %]
content...

[% END %]
BLOCK: Define a named template block for subsequent INCLUDE,
PROCESS, etc.,

[% BLOCK template %]
content

[% END %]
FOREACH: Repeat the enclosed FOREACH ... END block for each
value in the list.

[% FOREACH variable = [ val, val, val ] %] #

either
[% FOREACH variable = list %] # or
[% FOREACH list %] # or
content...
[% variable %]

[% END %]
WHILE: Enclosed WHILE ... END block is processed while condi
tion is true.

[% WHILE condition %]
content

[% END %]
IF / UNLESS / ELSIF / ELSE: Enclosed block is processed if the condition is true /
false.

[% IF condition %]
content

[% ELSIF condition %]

content

[% ELSE %]

content

[% END %]

[% UNLESS condition %]

content

[% # ELSIF/ELSE as per IF, above %]

content

[% END %]
SWITCH / CASE: Multi-way switch/case statement.

[% SWITCH variable %]
[% CASE val1 %]
content

[% CASE [ val2, val3 ] %]

content

[% CASE %] # or [% CASE DEFAULT %]

content

[% END %]
MACRO: Define a named macro.

[% MACRO name <directive> %]
[% MACRO name(arg1, arg2) <directive> %]
...
[% name %]
[% name(val1, val2) %]
FILTER: Process enclosed FILTER ... END block then pipe
through a filter.

[% FILTER name %] # either
[% FILTER name( params ) %] # or
[% FILTER alias = name( params ) %] # or
content

[% END %]
USE Load a "plugin" module, or any regular Perl module if: LOAD_PERL option is set.

[% USE name %] # either
[% USE name( params ) %] # or
[% USE var = name( params ) %] # or
...
[% name.method %]
[% var.method %]
PERL / RAWPERL: Evaluate enclosed blocks as Perl code (requires
EVAL_PERL option to be set).

[% PERL %]
# perl code goes here
$stash->set('foo', 10);
print "set 'foo' to ", $stash->get('foo'),

"0;
print $context->include('footer', { var =>

$val });

[% END %]

[% RAWPERL %]

# raw perl code goes here, no magic but fast.
$output .= 'some output';

[% END %]
TRY / THROW / CATCH / FINAL: Exception handling.

[% 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: Jump straight to the next item in a FOREACH/WHILE
loop.

[% NEXT %]
LAST: Break out of FOREACH/WHILE loop.

[% LAST %]
RETURN: Stop processing current template and return to includ
ing templates.

[% RETURN %]
STOP: Stop processing all templates and return to caller.

[% STOP %]
TAGS: Define new tag style or characters (default: [% %]).

[% TAGS html %]
[% TAGS  %]
COMMENTS: Ignored and deleted.

[% # this is a comment to the end of line
foo = 'bar'

%]

[%# placing the '#' immediately inside the direc

tive

tag comments out the entire directive

%]

AUTHOR

Andy Wardley <abw@andywardley.com>

<http://www.andywardley.com/|http://www.andywardley.com/>

VERSION

Template Toolkit version 2.08, released on 30 July 2002.

COPYRIGHT

Ltd.
This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

docs.sk

comprehensive documentation repository

In section