Template::Provider - Provider module for loading/compiling templates |
Template::Provider - Provider module for loading/compiling templates
$provider = Template::Provider->new(\%options); ($template, $error) = $provider->fetch($name);
The the Template::Provider manpage is used to load, parse, compile and cache template documents. This object may be sub-classed to provide more specific facilities for loading, or otherwise providing access to templates.
The the Template::Context manpage objects maintain a list of the Template::Provider manpage objects which are polled in turn (via fetch()) to return a requested template. Each may return a compiled template, raise an error, or decline to serve the request, giving subsequent providers a chance to do so.
The the Template::Provider manpage can also be subclassed to provide templates from a different source, e.g. a database. See SUBCLASSING below.
This documentation needs work.
new(\%options)
Constructor method which instantiates and returns a new Template::Provider
object. A reference to a hash array of configuration options may be passed.
See CONFIGURATION OPTIONS below for a summary of configuration options and the Template::Manual::Config manpage for full details.
fetch($name)
Returns a compiled template for the name specified. If the template cannot be
found then (undef, STATUS_DECLINED)
is returned. If an error occurs (e.g.
read error, parse error) then ($error, STATUS_ERROR)
is returned, where
$error
is the error message generated. If the TOLERANT option is set the
the method returns (undef, STATUS_DECLINED)
instead of returning an error.
load($name)
Loads a template without parsing or compiling it. This is used by the the INSERT directive.
Stores the compiled template, $template
, in the cache under the name,
$name
. Susbequent calls to fetch($name)
will return this template in
preference to any disk-based file.
include_path(\@newpath)
Accessor method for the INCLUDE_PATH
setting. If called with an
argument, this method will replace the existing INCLUDE_PATH
with
the new value.
paths()
This method generates a copy of the INCLUDE_PATH
list. Any elements in the
list which are dynamic generators (e.g. references to subroutines or objects
implementing a paths()
method) will be called and the list of directories
returned merged into the output list.
It is possible to provide a generator which returns itself, thus sending
this method into an infinite loop. To detect and prevent this from happening,
the $MAX_DIRS
package variable, set to 64
by default, limits the maximum
number of paths that can be added to, or generated for the output list. If
this number is exceeded then the method will immediately return an error
reporting as much.
The following list summarises the configuration options that can be provided
to the Template::Provider
new() constructor. Please consult
the Template::Manual::Config manpage for further details and examples of each
configuration option in use.
The INCLUDE_PATH option is used to specify one or more directories in which template files are located.
# single path my $provider = Template::Provider->new({ INCLUDE_PATH => '/usr/local/templates', });
# multiple paths my $provider = Template::Provider->new({ INCLUDE_PATH => [ '/usr/local/templates', '/tmp/my/templates' ], });
The ABSOLUTE flag is used to indicate if
templates specified with absolute filenames (e.g. '/foo/bar
') should be
processed. It is disabled by default and any attempt to load a template by
such a name will cause a 'file
' exception to be raised.
my $provider = Template::Provider->new({ ABSOLUTE => 1, });
The RELATIVE flag is used to indicate if
templates specified with filenames relative to the current directory (e.g.
./foo/bar
or ../../some/where/else
) should be loaded. It is also disabled
by default, and will raise a file
error if such template names are
encountered.
my $provider = Template::Provider->new({ RELATIVE => 1, });
The DEFAULT option can be used to specify a default template which should be used whenever a specified template can't be found in the INCLUDE_PATH.
my $provider = Template::Provider->new({ DEFAULT => 'notfound.html', });
If a non-existant template is requested through the Template
process() method, or by an INCLUDE
, PROCESS
or
WRAPPER
directive, then the DEFAULT
template will instead be processed, if
defined. Note that the DEFAULT
template is not used when templates are
specified with absolute or relative filenames, or as a reference to a input
file handle or text string.
The Template Toolkit will automatically decode Unicode templates that have a Byte Order Marker (BOM) at the start of the file. This option can be used to set the default encoding for templates that don't define a BOM.
my $provider = Template::Provider->new({ ENCODING => 'utf8', });
See Encode for further information.
The CACHE_SIZE option can be used to limit the number of compiled templates that the module should cache. By default, the CACHE_SIZE is undefined and all compiled templates are cached.
my $provider = Template::Provider->new({ CACHE_SIZE => 64, # only cache 64 compiled templates });
The STAT_TTL value can be set to control
how long the Template::Provider
will keep a template cached in memory
before checking to see if the source template has changed.
my $provider = Template::Provider->new({ STAT_TTL => 60, # one minute });
The COMPILE_EXT option can be provided to specify a filename extension for compiled template files. It is undefined by default and no attempt will be made to read or write any compiled template files.
my $provider = Template::Provider->new({ COMPILE_EXT => '.ttc', });
The COMPILE_DIR option is used to specify an alternate directory root under which compiled template files should be saved.
my $provider = Template::Provider->new({ COMPILE_DIR => '/tmp/ttc', });
The TOLERANT flag can be set to indicate
that the Template::Provider
module should ignore any errors encountered while
loading a template and instead return STATUS_DECLINED
.
The PARSER option can be used to define a parser module other than the default of the Template::Parser manpage.
my $provider = Template::Provider->new({ PARSER => MyOrg::Template::Parser->new({ ... }), });
The DEBUG option can be used to enable
debugging messages from the the Template::Provider manpage module by setting it to include
the DEBUG_PROVIDER
value.
use Template::Constants qw( :debug ); my $template = Template->new({ DEBUG => DEBUG_PROVIDER, });
The Template::Provider
module can be subclassed to provide templates from a
different source (e.g. a database). In most cases you'll just need to provide
custom implementations of the _template_modified()
and _template_content()
methods. If your provider requires and custom initialisation then you'll also
need to implement a new _init()
method.
Caching in memory and on disk will still be applied (if enabled) when overriding these methods.
_template_modified($path)
Returns a timestamp of the $path
passed in by calling stat()
.
This can be overridden, for example, to return a last modified value from
a database. The value returned should be a timestamp value (as returned by time()
,
although a sequence number should work as well.
_template_content($path)
This method returns the content of the template for all INCLUDE
, PROCESS
,
and INSERT
directives.
When called in scalar context, the method returns the content of the template
located at $path
, or undef
if $path
is not found.
When called in list context it returns ($content, $error, $mtime)
,
where $content
is the template content, $error
is an error string
(e.g. ``$path: File not found
''), and $mtime
is the template modification
time.
Andy Wardley <abw@wardley.org> http://wardley.org/
Copyright (C) 1996-2007 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::Parser manpage, the Template::Context manpage
Template::Provider - Provider module for loading/compiling templates |