template::plugin(3)

NAME

Template::Plugin - Base class for Template Toolkit plugins

SYNOPSIS

package MyOrg::Template::Plugin::MyPlugin;
use base qw( Template::Plugin );
use Template::Plugin;
use MyModule;
sub new {
    my $class   = shift;
    my $context = shift;
    bless {
        ...
    }, $class;
}

DESCRIPTION

A "plugin" for the Template Toolkit is simply a Perl mod
ule which exists in a known package location (e.g. Tem
plate::Plugin::*) and conforms to a regular standard,
allowing it to be loaded and used automatically.

The Template::Plugin module defines a base class from
which other plugin modules can be derived. A plugin does
not have to be derived from Template::Plugin but should at
least conform to its object-oriented interface.

It is recommended that you create plugins in your own package namespace to avoid conflict with toolkit plugins. e.g.: package MyOrg::Template::Plugin::FooBar;
Use the PLUGIN_BASE option to specify the namespace that you use. e.g.: use Template;
my $template = Template->new({
PLUGIN_BASE => 'MyOrg::Template::Plugin',; });

PLUGIN API

The following methods form the basic interface between the
Template Toolkit and plugin modules.

load($context): This method is called by the Template Toolkit when the
plugin module is first loaded. It is called as a
package method and thus implicitly receives the pack
age name as the first parameter. A reference to the
Template::Context object loading the plugin is also
passed. The default behaviour for the load() method
is to simply return the class name. The calling con
text then uses this class name to call the new() pack
age method.

package MyPlugin;

sub load { # called as MyPlug

in->load($context)
my ($class, $context) = @_;
return $class; # returns 'MyPlugin'

}
new($context, @params): This method is called to instantiate a new plugin
object for the USE directive. It is called as a pack
age method against the class name returned by load(). A reference to the Template::Context object creating
the plugin is passed, along with any additional param
eters specified in the USE directive.

sub new { # called as MyPlug

in->new($context)
my ($class, $context, @params) = @_;
bless {
_CONTEXT => $context,

}, $class; # returns blessed MyPlug

in object

}
error($error): This method, inherited from the Template::Base module,
is used for reporting and returning errors. It can
be called as a package method to set/return the $ERROR
package variable, or as an object method to set/return
the object _ERROR member. When called with an argu
ment, it sets the relevant variable and returns undef.
When called without an argument, it returns the value
of the variable.

sub new {
my ($class, $context, $dsn) = @_;

return $class->error('No data source speci

fied')
unless $dsn;

bless {

_DSN => $dsn,

}, $class;

}

...

my $something = MyModule->new()

|| die MyModule->error(), "0;

$something->do_something()

|| die $something->error(), "0;

DEEPER MAGIC

The Template::Context object that handles the loading and use of plugins calls the new() and error() methods against the package name returned by the load() method. In pseudo-code terms, it might look something like this:: $class = MyPlugin->load($context); # returns; 'MyPlugin'; $object = $class->new($context, @params) # MyPlug; in->new(...)
|| die $class->error(); # MyPlug

in->error()
The load() method may alterately return a blessed refer ence to an object instance. In this case, new() and error() are then called as object methods against that prototype instance.: package YourPlugin;; sub load {
my ($class, $context) = @_;
bless {
_CONTEXT => $context,

}, $class;; }; sub new {
my ($self, $context, @params) = @_;
return $self;; }
In this example, we have implemented a 'Singleton' plugin. One object gets created when load() is called and this simply returns itself for each call to new().
Another implementation might require individual objects to be created for every call to new(), but with each object sharing a reference to some other object to maintain cached data, database handles, etc. This pseudo-code example demonstrates the principle.: package MyServer;; sub load {
my ($class, $context) = @_;
bless {
_CONTEXT => $context,
_CACHE => { },

}, $class;; }; sub new {
my ($self, $context, @params) = @_;
MyClient->new($self, @params);; }; sub add_to_cache { ... }; sub get_from_cache { ... }; package MyClient;; sub new {
my ($class, $server, $blah) = @_;
bless {
_SERVER => $server,
_BLAH => $blah,

}, $class;; }; sub get {
my $self = shift;
$self->{ _SERVER }->get_from_cache(@_);; }; sub put {
my $self = shift;
$self->{ _SERVER }->add_to_cache(@_);; }
When the plugin is loaded, a MyServer instance is created. The new() method is called against this object which instantiates and returns a MyClient object, primed to com municate with the creating MyServer.

Template::Plugin Delegation

As of version 2.01, the Template::Plugin module no longer
provides an AUTOLOAD method to delegate to other objects
or classes. This was a badly designed featured that
caused more trouble than good. You can easily add your
own AUTOLOAD method to perform delegation if you require
this kind of functionality.

AUTHOR

Andy Wardley <abw@andywardley.com>

<http://www.andywardley.com/|http://www.andywardley.com/>

VERSION

2.53, distributed as part of the Template Toolkit version
2.08, released on 30 July 2002.

COPYRIGHT

Ltd.
This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

docs.sk

comprehensive documentation repository

In section