Template Toolkit: Модули: Template::Plugin

"Плагин" Template Toolkit это модуль Perl, который находится в определенном пространстве имен пакетов (например, Template::Plugin::*) и соответствует формальному стандарту, позволяющему загрузить и использовать его автоматически.

Модуль Template::Plugin определяет базовый класс, из которого можно произвести другие модули плагинов. Плагин не обязательно должен быть производным от Template::Plugin, но должен по крайней мере соответствовать его объектно-ориентированному интерфейсу.

Рекомендуется создавать плагины в собственном пространстве имен пакетов во избежание конфликта с плагинами библиотеки. Например:

    package MyOrg::Template::Plugin::FooBar;

Используйте опцию PLUGIN_BASE, чтобы определить используемое пространство имен. Например:

    use Template;
    my $template = Template->new({
	PLUGIN_BASE => 'MyOrg::Template::Plugin',
    });

Следующие методы образуют базовый интерфейс между Template Toolkit и модулями плагинов.

load($context)

Этот метод вызывается Template Toolkit, когда модуль плагина загружается первый раз. Он вызывается как метод пакета и поэтому неявно получает в качестве первого параметра имя пакета. Также передается ссылка на объект Template::Context, загрузивший плагин. По умолчанию метод load() просто возвращает имя класса. Вызвавший контекст затем использует имя класса, чтобы вызвать метод пакета new().
```
    package MyPlugin;
```
```
    sub load {               # вызывается как MyPlugin->load($context)
        my ($class, $context) = @_;
        return $class;       # возвращает 'MyPlugin'
    }
```
new($context, @params)

Этот метод вызывается, чтобы создать новый экземпляр объекта плагина для директивы USE. Он вызывается как метод пакета с именем класса, возвращенным load(). Методу в качестве аргументов передается ссылка на объект Template::Context, создавший плагин, вместе с дополнительными параметрами, указанными в директиве USE.
```
    sub new {                # вызывается как MyPlugin->new($context)
        my ($class, $context, @params) = @_;
        bless {
            _CONTEXT => $context,
        }, $class;	     # возвращает связанный объект MyPlugin
    }
```
error($error)

Метод, унаследованный из модуля Template::Base, используется для сообщения об ошибках. Он может быть вызван как метод пакета для установки/получения переменной пакета $ERROR, или как метод объекта для установки/получения переменной объекта _ERROR. Когда метод вызывается с параметром, он устанавливает соответствующую переменную и возвращает undef. Когда вызвается без аргумента, возвращает значение переменной.
```
    sub new {
        my ($class, $context, $dsn) = @_;
```
```
        return $class->error('No data source specified')
	    unless $dsn;
```
```
        bless {
            _DSN => $dsn,
        }, $class;
    }
```
```
    ...
```
```
    my $something = MyModule->new()
        || die MyModule->error(), "\n";
```
```
    $something->do_something()
        || die $something->error(), "\n";
```

Объект Template::Context, который управляет загрузкой и использованием плагинов вызывает методы new() и error() вместе с именем пакета, возвращаемым методом load(). В терминах псевдо-кода это может выглядеть примерно так:

    $class  = MyPlugin->load($context);       # возвращает 'MyPlugin'

    $object = $class->new($context, @params)  # MyPlugin->new(...)
        || die $class->error();               # MyPlugin->error()

Вместо этого метод load() может возвратить связанную ссылку на объект. В этом случае new() и error() дальше будут вызываться как объектные методы этого прототипа.

    package YourPlugin;

    sub load {
        my ($class, $context) = @_;
        bless {
            _CONTEXT => $context,
        }, $class;
    }

    sub new {
        my ($self, $context, @params) = @_;
        return $self;
    }

В этом примере мы реализовали плагин 'Singleton' (название плагина дословно переводится "единственный экземпляр" - прим. переводчика). При вызове load() создается один объект и он просто возвращает самого себя при каждом вызове new().

Другая реализация может потребовать создания индивидуальных объектов на каждый вызов new(), но каждый объект должен разделять ссылку на какой-то другой объект, чтобы поддерживать закешированные данные, дескрипторы базы данных и т.п. Следующий пример демонстрирует принцип в псевдо-коде.

    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(@_);
    }

Когда плагин загружается, создается экземпляр MyServer. Метод new() вызываемый у этого объекта, создает и возвращает объект MyClient, который способен связываться с создавшим его MyServer.

Template Toolkit

(русская редакция)

Template::Plugin

Оглавление

ОБЗОР

ОПИСАНИЕ

API ПЛАГИНОВ

ВНУТРЕННЕЕ ВОЛШЕБСТВО

ДЕЛЕГИРОВАНИЕ В Template::Plugin

АВТОР

ВЕРСИЯ

АВТОРСКИЕ ПРАВА

СМОТРИ ТАКЖЕ