new(\%params)
The new() constructor method is called to instantiate a Template::Context
object. Configuration parameters may be specified as a HASH reference or
as a list of (name => value) pairs.
my $context = Template::Context->new({
INCLUDE_PATH => 'header',
POST_PROCESS => 'footer',
});
my $context = Template::Context->new( EVAL_PERL => 1 );
The new() method returns a Template::Context object (or sub-class) or
undef on error. In the latter case, a relevant error message can be
retrieved by the error() class method or directly from the
$Template::Context::ERROR package variable.
my $context = Template::Context->new(\%config)
|| die Template::Context->error();
my $context = Template::Context->new(\%config)
|| die $Template::Context::ERROR;
The following configuration items may be specified.
- VARIABLES, PRE_DEFINE
The VARIABLES option (or PRE_DEFINE - they're equivalent) can be used
to specify a hash array of template variables that should be used to
pre-initialise the stash when it is created. These items are ignored
if the STASH item is defined.
my $context = Template::Context->new({
VARIABLES => {
title => 'A Demo Page',
author => 'Joe Random Hacker',
version => 3.14,
},
};
or
my $context = Template::Context->new({
PRE_DEFINE => {
title => 'A Demo Page',
author => 'Joe Random Hacker',
version => 3.14,
},
};
- BLOCKS
The BLOCKS option can be used to pre-define a default set of template
blocks. These should be specified as a reference to a hash array
mapping template names to template text, subroutines or Template::Document
objects.
my $context = Template::Context->new({
BLOCKS => {
header => 'The Header. [% title %]',
footer => sub { return $some_output_text },
another => Template::Document->new({ ... }),
},
});
- TRIM
The TRIM option can be set to have any leading and trailing whitespace
automatically removed from the output of all template files and BLOCKs.
By example, the following BLOCK definition
[% BLOCK foo %]
Line 1 of foo
[% END %]
will be processed is as "\nLine 1 of foo\n". When INCLUDEd, the surrounding
newlines will also be introduced.
before
[% INCLUDE foo %]
after
output:
before
Line 1 of foo
after
With the TRIM option set to any true value, the leading and trailing
newlines (which count as whitespace) will be removed from the output
of the BLOCK.
before
Line 1 of foo
after
The TRIM option is disabled (0) by default.
- EVAL_PERL
This flag is used to indicate if PERL and/or RAWPERL blocks should be
evaluated. By default, it is disabled and any PERL or RAWPERL blocks
encountered will raise exceptions of type 'perl' with the message
'EVAL_PERL not set'. Note however that any RAWPERL blocks should
always contain valid Perl code, regardless of the EVAL_PERL flag. The
parser will fail to compile templates that contain invalid Perl code
in RAWPERL blocks and will throw a 'file' exception.
When using compiled templates (see
COMPILE_EXT and
COMPILE_DIR),
the EVAL_PERL has an affect when the template is compiled, and again
when the templates is subsequently processed, possibly in a different
context to the one that compiled it.
If the EVAL_PERL is set when a template is compiled, then all PERL and
RAWPERL blocks will be included in the compiled template. If the
EVAL_PERL option isn't set, then Perl code will be generated which
always throws a 'perl' exception with the message 'EVAL_PERL not
set' whenever the compiled template code is run.
Thus, you must have EVAL_PERL set if you want your compiled templates
to include PERL and RAWPERL blocks.
At some point in the future, using a different invocation of the
Template Toolkit, you may come to process such a pre-compiled
template. Assuming the EVAL_PERL option was set at the time the
template was compiled, then the output of any RAWPERL blocks will be
included in the compiled template and will get executed when the
template is processed. This will happen regardless of the runtime
EVAL_PERL status.
Regular PERL blocks are a little more cautious, however. If the
EVAL_PERL flag isn't set for the current context, that is, the
one which is trying to process it, then it will throw the familiar 'perl'
exception with the message, 'EVAL_PERL not set'.
Thus you can compile templates to include PERL blocks, but optionally
disable them when you process them later. Note however that it is
possible for a PERL block to contain a Perl "BEGIN { # some code }"
block which will always get run regardless of the runtime EVAL_PERL
status. Thus, if you set EVAL_PERL when compiling templates, it is
assumed that you trust the templates to Do The Right Thing. Otherwise
you must accept the fact that there's no bulletproof way to prevent
any included code from trampling around in the living room of the
runtime environment, making a real nuisance of itself if it really
wants to. If you don't like the idea of such uninvited guests causing
a bother, then you can accept the default and keep EVAL_PERL disabled.
- RECURSION
The template processor will raise a file exception if it detects
direct or indirect recursion into a template. Setting this option to
any true value will allow templates to include each other recursively.
- LOAD_TEMPLATES
The LOAD_TEMPLATE option can be used to provide a reference to a list
of Template::Provider objects or sub-classes thereof which will take
responsibility for loading and compiling templates.
my $context = Template::Context->new({
LOAD_TEMPLATES => [
MyOrg::Template::Provider->new({ ... }),
Template::Provider->new({ ... }),
],
});
When a PROCESS, INCLUDE or WRAPPER directive is encountered, the named
template may refer to a locally defined BLOCK or a file relative to
the INCLUDE_PATH (or an absolute or relative path if the appropriate
ABSOLUTE or RELATIVE options are set). If a BLOCK definition can't be
found (see the Template::Context template() method for a discussion of
BLOCK locality) then each of the LOAD_TEMPLATES provider objects is
queried in turn via the fetch() method to see if it can supply the
required template. Each provider can return a compiled template, an
error, or decline to service the request in which case the
responsibility is passed to the next provider. If none of the
providers can service the request then a 'not found' error is
returned. The same basic provider mechanism is also used for the
INSERT directive but it bypasses any BLOCK definitions and doesn't
attempt is to parse or process the contents of the template file.
This is an implementation of the 'Chain of Responsibility'
design pattern as described in
"Design Patterns", Erich Gamma, Richard Helm, Ralph Johnson, John
Vlissides), Addision-Wesley, ISBN 0-201-63361-2, page 223
.
If LOAD_TEMPLATES is undefined, a single default provider will be
instantiated using the current configuration parameters. For example,
the Template::Provider INCLUDE_PATH option can be specified in the Template::Context configuration and will be correctly passed to the provider's
constructor method.
my $context = Template::Context->new({
INCLUDE_PATH => '/here:/there',
});
- LOAD_PLUGINS
The LOAD_PLUGINS options can be used to specify a list of provider
objects (i.e. they implement the fetch() method) which are responsible
for loading and instantiating template plugin objects. The
Template::Content plugin() method queries each provider in turn in a
"Chain of Responsibility" as per the template() and filter() methods.
my $context = Template::Context->new({
LOAD_PLUGINS => [
MyOrg::Template::Plugins->new({ ... }),
Template::Plugins->new({ ... }),
],
});
By default, a single Template::Plugins object is created using the
current configuration hash. Configuration items destined for the
Template::Plugins constructor may be added to the Template::Context
constructor.
my $context = Template::Context->new({
PLUGIN_BASE => 'MyOrg::Template::Plugins',
LOAD_PERL => 1,
});
- LOAD_FILTERS
The LOAD_FILTERS option can be used to specify a list of provider
objects (i.e. they implement the fetch() method) which are responsible
for returning and/or creating filter subroutines. The
Template::Context filter() method queries each provider in turn in a
"Chain of Responsibility" as per the template() and plugin() methods.
my $context = Template::Context->new({
LOAD_FILTERS => [
MyTemplate::Filters->new(),
Template::Filters->new(),
],
});
By default, a single Template::Filters object is created for the
LOAD_FILTERS list.
- STASH
A reference to a Template::Stash object or sub-class which will take
responsibility for managing template variables.
my $stash = MyOrg::Template::Stash->new({ ... });
my $context = Template::Context->new({
STASH => $stash,
});
If unspecified, a default stash object is created using the VARIABLES
configuration item to initialise the stash variables. These may also
be specified as the PRE_DEFINE option for backwards compatibility with
version 1.
my $context = Template::Context->new({
VARIABLES => {
id => 'abw',
name => 'Andy Wardley',
},
};
- DEBUG
The DEBUG option can be used to enable various debugging features
of the Template::Context module.
use Template::Constants qw( :debug );
my $template = Template->new({
DEBUG => DEBUG_CONTEXT | DEBUG_DIRS,
});
The DEBUG value can include any of the following. Multiple values
should be combined using the logical OR operator, '|'.
- DEBUG_CONTEXT
Enables general debugging messages for the
Template::Context module.
- DEBUG_DIRS
This option causes the Template Toolkit to generate comments
indicating the source file, line and original text of each directive
in the template. These comments are embedded in the template output
using the format defined in the DEBUG_FORMAT configuration item, or a
simple default format if unspecified.
For example, the following template fragment:
Hello World
would generate this output:
## input text line 1 : ##
Hello
## input text line 2 : World ##
World
template($name)
Returns a compiled template by querying each of the LOAD_TEMPLATES providers
(instances of Template::Provider, or sub-class) in turn.
$template = $context->template('header');
On error, a Template::Exception object of type 'file' is thrown via
die(). This can be caught by enclosing the call to template() in an
eval block and examining $@.
eval {
$template = $context->template('header');
};
if ($@) {
print "failed to fetch template: $@\n";
}
plugin($name, \@args)
Instantiates a plugin object by querying each of the LOAD_PLUGINS
providers. The default LOAD_PLUGINS provider is a Template::Plugins
object which attempts to load plugin modules, according the various
configuration items such as PLUGIN_BASE, LOAD_PERL, etc., and then
instantiate an object via new(). A reference to a list of constructor
arguments may be passed as the second parameter. These are forwarded
to the plugin constructor.
Returns a reference to a plugin (which is generally an object, but
doesn't have to be). Errors are thrown as Template::Exception objects
of type 'plugin'.
$plugin = $context->plugin('DBI', 'dbi:msql:mydbname');
filter($name, \@args, $alias)
Instantiates a filter subroutine by querying the LOAD_FILTERS providers.
The default LOAD_FILTERS providers is a Template::Filters object.
Additional arguments may be passed by list reference along with an
optional alias under which the filter will be cached for subsequent
use. The filter is cached under its own $name if $alias is undefined.
Subsequent calls to filter($name) will return the cached entry, if
defined. Specifying arguments bypasses the caching mechanism and
always creates a new filter. Errors are thrown as Template::Exception
objects of typre 'filter'.
# static filter (no args)
$filter = $context->filter('html');
# dynamic filter (args) aliased to 'padright'
$filter = $context->filter('format', '%60s', 'padright');
# retrieve previous filter via 'padright' alias
$filter = $context->filter('padright');
process($template, \%vars)
Processes a template named or referenced by the first parameter and returns
the output generated. An optional reference to a hash array may be passed
as the second parameter, containing variable definitions which will be set
before the template is processed. The template is processed in the current
context, with no localisation of variables performed. Errors are thrown
as Template::Exception objects via die().
$output = $context->process('header', { title => 'Hello World' });
include($template, \%vars)
Similar to process() above, but using localised variables. Changes made to
any variables will only persist until the include() method completes.
$output = $context->include('header', { title => 'Hello World' });
throw($error_type, $error_message, \\)
Raises an exception in the form of a Template::Exception object by
calling die(). This method may be passed a reference to an existing
Template::Exception object; a single value containing an error message
which is used to instantiate a Template::Exception of type 'undef'; or
a pair of values representing the exception type and info from which a
Template::Exception object is instantiated. e.g.
$context->throw($exception);
$context->throw("I'm sorry Dave, I can't do that");
$context->throw('denied', "I'm sorry Dave, I can't do that");
The optional third parameter may be a reference to the current output
buffer. This is then stored in the exception object when created,
allowing the catcher to examine and use the output up to the point at
which the exception was raised.
$output .= 'blah blah blah';
$output .= 'more rhubarb';
$context->throw('yack', 'Too much yacking', \$output);
catch($exception, \\)
Catches an exception thrown, either as a reference to a
Template::Exception object or some other value. In the latter case,
the error string is promoted to a Template::Exception object of
'undef' type. This method also accepts a reference to the current
output buffer which is passed to the Template::Exception constructor,
or is appended to the output buffer stored in an existing
Template::Exception object, if unique (i.e. not the same reference).
By this process, the correct state of the output buffer can be
reconstructed for simple or nested throws.
define_block($name, $block)
Adds a new block definition to the internal BLOCKS cache. The first
argument should contain the name of the block and the second a reference
to a Template::Document object or template sub-routine, or template text
which is automatically compiled into a template sub-routine. Returns
a true value (the sub-routine or Template::Document reference) on
success or undef on failure. The relevant error message can be
retrieved by calling the error() method.
define_filter($name, \&filter, $is_dynamic)
Adds a new filter definition by calling the store() method on each of
the LOAD_FILTERS providers until accepted (in the usual case, this is
accepted straight away by the one and only Template::Filters
provider). The first argument should contain the name of the filter
and the second a reference to a filter subroutine. The optional
third argument can be set to any true value to indicate that the
subroutine is a dynamic filter factory. Returns a true value or
throws a 'filter' exception on error.
localise(\%vars)
Clones the stash to create a context with localised variables. Returns a
reference to the newly cloned stash object which is also stored
internally.
$stash = $context->localise();
delocalise()
Restore the stash to its state prior to localisation.
$stash = $context->delocalise();
visit(\%blocks)
This method is called by Template::Document objects immediately before
they process their content. It is called to register any local BLOCK
definitions with the context object so that they may be subsequently
delivered on request.
leave()
Compliment to visit(), above. Called by Template::Document objects
immediately after they process their content.
reset()
Clears the local BLOCKS cache of any BLOCK definitions. Any initial set of
BLOCKS specified as a configuration item to the constructor will be reinstated.
AUTOLOAD
An AUTOLOAD method provides access to context configuration items.
$stash = $context->stash();
$tflag = $context->trim();
$epflag = $context->eval_perl();
...
|
