Unix/Linux Go Back    

CentOS 7.0 - man page for template::provider (centos section 3)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

Template::Provider(3)	       User Contributed Perl Documentation	    Template::Provider(3)

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

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

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

       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.

       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.

       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.

       Loads a template without parsing or compiling it.  This is used by the the INSERT

   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.

       Accessor method for the "INCLUDE_PATH" setting.	If called with an argument, this method
       will replace the existing "INCLUDE_PATH" with the new value.

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

	   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

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

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

       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({

       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

       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

       This method returns the content of the template for all "INCLUDE", "PROCESS", and "INSERT"

       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, Template::Parser, Template::Context

perl v5.16.3				    2012-01-25			    Template::Provider(3)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 10:01 PM.