oracular (3) Template::Provider.3pm.gz

NAME

       Template::Provider - Provider module for loading/compiling templates

SYNOPSIS

           $provider = Template::Provider->new(\%options);

           ($template, $error) = $provider->fetch($name);

DESCRIPTION

       The Template::Provider 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 Template::Context objects maintain a list of Template::Provider 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 Template::Provider can also be subclassed to provide templates from a different source, e.g. a
       database. See SUBCLASSING below.

       This documentation needs work.

PUBLIC METHODS

   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 Template::Manual::Config 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.

   store($name, $template)
       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.

CONFIGURATION OPTIONS

       The following list summarises the configuration options that can be provided to the "Template::Provider"
       new() constructor. Please consult Template::Manual::Config for further details and examples of each
       configuration option in use.

   INCLUDE_PATH
       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' ],
           });

   ABSOLUTE
       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,
           });

   RELATIVE
       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,
           });

   DEFAULT
       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.

   ENCODING
       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.

   CACHE_SIZE
       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
           });

   STAT_TTL
       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
           });

   COMPILE_EXT
       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',
           });

   COMPILE_DIR
       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',
           });

   TOLERANT
       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".

   PARSER
       The PARSER option can be used to define a parser module other than the default of Template::Parser.

           my $provider = Template::Provider->new({
               PARSER => MyOrg::Template::Parser->new({ ... }),
           });

   DEBUG
       The DEBUG option can be used to enable debugging messages from the Template::Provider module by setting
       it to include the "DEBUG_PROVIDER" value.

           use Template::Constants qw( :debug );

           my $template = Template->new({
               DEBUG => DEBUG_PROVIDER,
           });

SUBCLASSING

       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.

AUTHOR

       Andy Wardley <abw@wardley.org> <http://wardley.org/>

COPYRIGHT

       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.

SEE ALSO

       Template, Template::Parser, Template::Context