Template::Provider - phpMan

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 AT 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