Contents
Top- SYNOPSIS
- DESCRIPTION
- METHODS
- new(\%params)
- VARIABLES
- BLOCKS
- TRIM
- EVAL_PERL
- RECURSION
- LOAD_TEMPLATES
- LOAD_PLUGINS
- LOAD_FILTERS
- STASH
- DEBUG
- template($name)
- plugin($name, \@args)
- filter($name, \@args, $alias)
- process($template, \%vars)
- include($template, \%vars)
- throw($error_type, $error_message, \$output)
- catch($exception, \$output)
- define_block($name, $block)
- define_filter($name, \&filter, $is_dynamic)
- localise(\%vars)
- delocalise()
- visit(\%blocks)
- leave()
- reset()
- AUTOLOAD
- AUTHOR
- COPYRIGHT
- SEE ALSO
SYNOPSIS
Topuse 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();
...
              DESCRIPTION
Top
                      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. Template::Provider, Template::Plugins, Template::Filters,
                      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
                      Template::Config 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
    ...
});
              METHODS
Topnew(\%params)
Top
                          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 Template::Manual::Config for further details.
VARIABLES
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,
    },
};
                        
                        BLOCKS
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({ ... }),
    },
}); 
                        
                        TRIM
                          The TRIM option can be set to have any leading and
                          trailing whitespace automatically removed from the output of all template
                          files and BLOCKs.
                        
example:
[% BLOCK foo %] Line 1 of foo [% END %] before [% INCLUDE foo %] after
output:
before Line 1 of foo after
EVAL_PERL
                          The EVAL_PERL is used to indicate if
                          PERL and/or RAWPERL blocks should be evaluated.
                          It is disabled by default.
                        
RECURSION
                          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).
                        
LOAD_TEMPLATES
The LOAD_TEMPLATES option can be used to provide a reference to a list of Template::Provider 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({ ... }),
    ],
});
                        
                        LOAD_PLUGINS
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({ ... }),
    ],
});
                        
                        LOAD_FILTERS
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(),
    ],
});
                        
                        STASH
The STASH option can be used to specify a Template::Stash 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,
});
                        
                        DEBUG
The DEBUG option can be used to enable various debugging features of the Template::Context module.
use Template::Constants qw( :debug );
my $template = Template->new({
    DEBUG => DEBUG_CONTEXT | DEBUG_DIRS,
});
                  template($name)
TopReturns a compiled template by querying each of the LOAD_TEMPLATES providers (instances of Template::Provider, or sub-class) in turn.
$template = $context->template('header');
                        
                          On error, a Template::Exception 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";
}
                  plugin($name, \@args)
TopInstantiates a plugin object by querying each of the LOAD_PLUGINS providers. The default LOAD_PLUGINS provider is a Template::Plugins 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 Template::Exception objects
                          with the type set to 'plugin'.
                        
$plugin = $context->plugin('DBI', 'dbi:msql:mydbname');
                  filter($name, \@args, $alias)
TopInstantiates a filter subroutine by querying the LOAD_FILTERS providers. The default LOAD_FILTERS provider is a Template::Filters 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 Template::Exception 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');
                  process($template, \%vars)
Top
                          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 Template::Exception objects via die().
                        
$output = $context->process('header', { title => 'Hello World' });
                  include($template, \%vars)
Top
                          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' });
                  throw($error_type, $error_message, \$output)
Top
                          Raises an exception in the form of a Template::Exception object by
                          calling die(). This method may be passed a reference to an
                          existing Template::Exception object; a single value containing an error
                          message which is used to instantiate a Template::Exception of type
                          'undef'; or a pair of values representing the exception
                          type and info from which a Template::Exception 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);
                  catch($exception, \$output)
Top
                          Catches an exception thrown, either as a reference to a Template::Exception object or
                          some other value. In the latter case, the error string is promoted to a
                          Template::Exception object of 'undef' type. This
                          method also accepts a reference to the current output buffer which is
                          passed to the Template::Exception constructor, or is appended to the output
                          buffer stored in an existing Template::Exception 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.
                        
define_block($name, $block)
TopAdds 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 Template::Document 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 Template::Document reference) on success or undef on failure. The relevant error message can be retrieved by calling the error() method.
define_filter($name, \&filter, $is_dynamic)
TopAdds 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 Template::Filters 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.
                        
localise(\%vars)
TopClones 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();
delocalise()
TopRestore the stash to its state prior to localisation.
$stash = $context->delocalise();
visit(\%blocks)
Top
                          This method is called by Template::Document 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.
                        
leave()
TopCompliment to the visit() method. Called by Template::Document objects immediately after they process their content.
reset()
TopAUTOLOAD
Top
                          An AUTOLOAD method provides access to context configuration
                          items.
                        
$stash = $context->stash(); $tflag = $context->trim(); $epflag = $context->eval_perl(); ...
AUTHOR
TopAndy Wardley <abw@wardley.org> http://wardley.org/
COPYRIGHT
TopCopyright (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.