Template::Context - Runtime context in which templates are processed |
new(\%params)
template($name)
insert($template)
define_views($views)
stash()
localise(\%vars)
delocalise()
visit(\%blocks)
leave()
view()
reset()
Template::Context - Runtime context in which templates are processed
use Template::Context; # constructor $context = Template::Context->new(\%config) || die $Template::Context::ERROR; # fetch (load and compile) a template $template = $context->template($template_name); # fetch (load and instantiate) a plugin object $plugin = $context->plugin($name, \@args); # fetch (return or create) a filter subroutine $filter = $context->filter($name, \@args, $alias); # process/include a template, errors are thrown via die() $output = $context->process($template, \%vars); $output = $context->include($template, \%vars); # raise an exception via die() $context->throw($error_type, $error_message, \$output_buffer); # catch an exception, clean it up and fix output buffer $exception = $context->catch($exception, \$output_buffer); # save/restore the stash to effect variable localisation $new_stash = $context->localise(\%vars); $old_stash = $context->delocalise(); # add new BLOCK or FILTER definitions $context->define_block($name, $block); $context->define_filter($name, \&filtersub, $is_dynamic); # reset context, clearing any imported BLOCK definitions $context->reset(); # methods for accessing internal items $stash = $context->stash(); $tflag = $context->trim(); $epflag = $context->eval_perl(); $providers = $context->templates(); $providers = $context->plugins(); $providers = $context->filters(); ...
The Template::Context
module defines an object class for representing
a runtime context in which templates are processed. It provides an
interface to the fundamental operations of the Template Toolkit
processing engine through which compiled templates (i.e. Perl code
constructed from the template source) can process templates, load
plugins and filters, raise exceptions and so on.
A default Template::Context
object is created by the Template module.
Any Template::Context
options may be passed to the Template
new() constructor method and will be forwarded to the
Template::Context
constructor.
use Template; my $template = Template->new({ TRIM => 1, EVAL_PERL => 1, BLOCKS => { header => 'This is the header', footer => 'This is the footer', }, });
Similarly, the Template::Context
constructor will forward all configuration
parameters onto other default objects (e.g. the Template::Provider manpage,
the Template::Plugins manpage, the Template::Filters manpage, etc.) that it may need to
instantiate.
$context = Template::Context->new({ INCLUDE_PATH => '/home/abw/templates', # provider option TAG_STYLE => 'html', # parser option });
A Template::Context
object (or subclass) can be explicitly instantiated and
passed to the Template new() constructor method as the
CONTEXT
configuration item.
use Template; use Template::Context; my $context = Template::Context->new({ TRIM => 1 }); my $template = Template->new({ CONTEXT => $context });
The Template module uses the the Template::Config manpage
context() factory method to create a default
context object when required. The $Template::Config::CONTEXT
package
variable may be set to specify an alternate context module. This will be
loaded automatically and its new() constructor method called by the
context() factory method when a default context
object is required.
use Template; $Template::Config::CONTEXT = 'MyOrg::Template::Context'; my $template = Template->new({ EVAL_PERL => 1, EXTRA_MAGIC => 'red hot', # your extra config items ... });
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 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. Please see the Template::Manual::Config manpage for further details.
The VARIABLES option can be used to specify a hash array of template variables.
my $context = Template::Context->new({ VARIABLES => { title => 'A Demo Page', author => 'Joe Random Hacker', version => 3.14, }, };
The BLOCKS option can be used to pre-define a default set of template blocks.
my $context = Template::Context->new({ BLOCKS => { header => 'The Header. [% title %]', footer => sub { return $some_output_text }, another => Template::Document->new({ ... }), }, });
The VIEWS option can be used to pre-define one or more the Template::View manpage objects.
my $context = Template::Context->new({ VIEWS => [ bottom => { prefix => 'bottom/' }, middle => { prefix => 'middle/', base => 'bottom' }, top => { prefix => 'top/', base => 'middle' }, ], });
The TRIM option can be set to have any
leading and trailing whitespace automatically removed from the output of all
template files and BLOCK
s.
example:
[% BLOCK foo %] Line 1 of foo [% END %] before [% INCLUDE foo %] after
output:
before Line 1 of foo after
The EVAL_PERL is used to indicate if
PERL
and/or RAWPERL
blocks should be evaluated. It is disabled by
default.
The RECURSION can be set to
allow templates to recursively process themselves, either directly
(e.g. template foo
calls INCLUDE foo
) or indirectly (e.g.
foo
calls INCLUDE bar
which calls INCLUDE foo
).
The LOAD_TEMPLATES option can be used to provide a reference to a list of the Template::Provider manpage 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({ ... }), ], });
The LOAD_PLUGINS options can be used to specify a list of provider objects responsible for loading and instantiating template plugin objects.
my $context = Template::Context->new({ LOAD_PLUGINS => [ MyOrg::Template::Plugins->new({ ... }), Template::Plugins->new({ ... }), ], });
The LOAD_FILTERS option can be used to specify a list of provider objects for returning and/or creating filter subroutines.
my $context = Template::Context->new({ LOAD_FILTERS => [ MyTemplate::Filters->new(), Template::Filters->new(), ], });
The STASH option can be used to specify a the Template::Stash manpage 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, });
The DEBUG option can be used to enable various debugging features of the the Template::Context manpage module.
use Template::Constants qw( :debug ); my $template = Template->new({ DEBUG => DEBUG_CONTEXT | DEBUG_DIRS, });
template($name)
Returns a compiled template by querying each of the LOAD_TEMPLATES providers (instances of the Template::Provider manpage, or sub-class) in turn.
$template = $context->template('header');
On error, a the Template::Exception manpage 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"; }
Instantiates a plugin object by querying each of the LOAD_PLUGINS providers. The default LOAD_PLUGINS provider is a the Template::Plugins manpage 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 the Template::Exception manpage objects
with the type set to 'plugin
'.
$plugin = $context->plugin('DBI', 'dbi:msql:mydbname');
Instantiates a filter subroutine by querying the LOAD_FILTERS providers. The default LOAD_FILTERS provider is a the Template::Filters manpage 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 the Template::Exception manpage objects with the type set to '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');
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 the Template::Exception manpage objects via die()
.
$output = $context->process('header', { title => 'Hello World' });
Similar to process(), but using localised variables. Changes made to
any variables will only persist until the include()
method completes.
$output = $context->include('header', { title => 'Hello World' });
insert($template)
This method returns the source content of a template file without performing
any evaluation. It is used to implement the INSERT
directive.
Raises an exception in the form of a the Template::Exception manpage object by calling
die()
. This method may be passed a reference to an existing
the Template::Exception manpage object; a single value containing an error message
which is used to instantiate a the Template::Exception manpage of type 'undef
'; or a
pair of values representing the exception type
and info
from which a
the Template::Exception manpage 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);
Catches an exception thrown, either as a reference to a the Template::Exception manpage
object or some other value. In the latter case, the error string is promoted
to a the Template::Exception manpage object of 'undef
' type. This method also
accepts a reference to the current output buffer which is passed to the
the Template::Exception manpage constructor, or is appended to the output buffer stored
in an existing the Template::Exception manpage 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.
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 the Template::Document manpage 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 the Template::Document manpage reference) on success or undef on failure. The relevant error message can be retrieved by calling the error() method.
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 the Template::Filters manpage 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.
This method is a wrapper around the the Template::Stash manpage define_vmethod() method. It can be used to define new virtual methods.
# define a new scalar (item) virtual method $context->define_vmethod( item => ucfirst => sub { my $text = shift; return ucfirst $text; } )
This method allows you to define a named view.
$context->define_view( my_view => { prefix => 'my_templates/' } );
The view is then accessible as a template variable.
[% my_view.print(some_data) %]
define_views($views)
This method allows you to define multiple named views. A reference to a hash array or list reference should be passed as an argument.
$context->define_view({ # hash reference my_view_one => { prefix => 'my_templates_one/' }, my_view_two => { prefix => 'my_templates_two/' } });
If you're defining multiple views of which one or more are based on other views in the same definition then you should pass them as a list reference. This ensures that they get created in the right order (Perl does not preserve the order of items defined in a hash reference so you can't guarantee that your base class view will be defined before your subclass view).
$context->define_view([ # list referenence my_view_one => { prefix => 'my_templates_one/' }, my_view_two => { prefix => 'my_templates_two/' , base => 'my_view_one', } ]);
The views are then accessible as template variables.
[% my_view_one.print(some_data) %] [% my_view_two.print(some_data) %]
See also the VIEWS option.
stash()
This method returns the the Template::Stash manpage object used internally to manage template variables.
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 the Template::Document manpage 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 the visit() method. Called by the Template::Document manpage objects immediately after they process their content.
view()
This method creates a the Template::View manpage object bound to the context.
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.
This method is used to control debugging output. It is used to implement the DEBUG directive.
The first argument can be on
or off
to enable or disable debugging
respectively. The numerical values 0
and 1
can also be used if you
prefer.
$context->debugging('on');
Alternately, the first argument can be format
to define a new debug message
format. The second argument should be the format string which can contain
any of the $file
, $line
or $text
symbols to indicate where the
relevant values should be inserted.
# note single quotes to prevent interpolated of variables $context->debugging( format => '## $file line $line: $text' );
The final use of this method is to generate debugging messages themselves.
The first argument should be msg
, followed by a reference to a hash array
of value to insert into the debugging format string.
$context->debugging( msg => { line => 20, file => 'example.tt', text => 'Trampoline! Trampoline!', } );
An AUTOLOAD
method provides access to context configuration items.
$stash = $context->stash(); $tflag = $context->trim(); $epflag = $context->eval_perl(); ...
Andy Wardley <abw@wardley.org> http://wardley.org/
Copyright (C) 1996-2012 Andy Wardley. All Rights Reserved.
This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
Template, the Template::Document manpage, the Template::Exception manpage, the Template::Filters manpage, the Template::Plugins manpage, the Template::Provider manpage, the Template::Service manpage, the Template::Stash manpage
Template::Context - Runtime context in which templates are processed |