- NAME
- SYNOPSIS
- DESCRIPTION
- METHODS
new(\%params)
template($name)
- plugin($name, \@args)
- filter($name, \@args, $alias)
- process($template, \%vars)
- include($template, \%vars)
insert($template)
- throw($error_type, $error_message, \$output)
- catch($exception, \$output)
- define_block($name, $block)
- define_filter($name, \&filter, $is_dynamic)
- define_vmethod($type, $name, $code)
- define_view($name, \%params)
define_views($views)
stash()
localise(\%vars)
delocalise()
visit(\%blocks)
leave()
view()
reset()
- debugging($flag, @args)
- AUTOLOAD
- AUTHOR
- COPYRIGHT
- SEE ALSO
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
...
});
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,
});
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' });
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) %]
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.
This method returns the the Template::Stash manpage object used internally to manage
template variables.
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();
Restore the stash to its state prior to localisation.
$stash = $context->delocalise();
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.
Compliment to the visit() method. Called by the Template::Document manpage objects
immediately after they process their content.
This method creates a the Template::View manpage object bound to the context.
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-2013 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
|