Author image Taisuke Yamada


 Text::SimpleTemplate - Yet another module for template processing


 use Text::SimpleTemplate;

 $tmpl = new Text::SimpleTemplate;    # create processor object
 $tmpl->setq(TEXT => "hello, world"); # export data to template
 $tmpl->load($file);                  # loads template from named file
 $tmpl->pack(q{TEXT: <% $TEXT; %>});  # loads template from in-memory data

 print $tmpl->fill;                   # prints "TEXT: hello, world"


This is yet another library for template-based text generation.

Template-based text generation is a way to separate program code and data, so non-programmer can control final result (like HTML) as desired without tweaking the program code itself. By doing so, jobs like website maintenance is much easier because you can leave program code unchanged even if page redesign was needed.

The idea is simple. Whenever a block of text surrounded by '<%' and '%>' (or any pair of delimiters you specify) is found, it will be taken as Perl expression, and will be replaced by its evaluated result.

Major goal of this library is simplicity and speed. While there're many modules for template processing, this module has near raw Perl-code (i.e., "s|xxx|xxx|ge") speed, while providing simple-to-use objective interface.


This module requires and Since these are standard modules, all you need is perl itself.

For installation, standard procedure of

    perl Makefile.PL
    make test
    make install

should work just fine.


Suppose you have a following template named "sample.tmpl":

    === Module Information ===
    Name: <% $INFO->{Name}; %>
    Description: <% $INFO->{Description}; %>
    Author: <% $INFO->{Author}; %> <<% $INFO->{Email}; %>>

With the following code...

    use Safe;
    use Text::SimpleTemplate;

    $tmpl = new Text::SimpleTemplate;
    $tmpl->setq(INFO => {
        Name        => "Text::SimpleTemplate",
        Description => "Yet another module for template processing",
        Author      => "Taisuke Yamada",
        Email       => "tai\",

    print $tmpl->fill(PACKAGE => new Safe); will get following result:

    === Module Information ===
    Name: Text::SimpleTemplate
    Description: Yet another module for template processing
    Author: Taisuke Yamada <>

As you might have noticed, any scalar data can be exported to template namespace, even hash reference or code reference.

By the way, although I used "Safe" module in example above, this is not a requirement. However, if you want to control power of the template editor over program logic, its use is strongly recommended (see Safe for more).


In addition to its native interface, you can also access directly to template namespace.

    $FOO::text = 'hello, world';
    @FOO::list = qw(foo bar baz);

    $tmpl = new Text::SimpleTemplate;
    $tmpl->pack(q{TEXT: <% $text; %>, LIST: <% "@list"; %>});

    print $tmpl->fill(PACKAGE => 'FOO');

While I don't recommend this style, this might be useful if you want to export list, hash, or subroutine directly without using reference.


Following methods are currently available.

$tmpl = Text::SimpleTemplate->new;

Constructor. Returns newly created object.

If this method was called through existing object, cloned object will be returned. This cloned instance inherits all properties except for internal buffer which holds template data. Cloning is useful for chained template processing.

$tmpl->setq($name => $data, $name => $data, ...);

Exports scalar data ($data) to template namespace, with $name as a scalar variable name to be used in template.

You can repeat the pair to export multiple sets in one operation.

$tmpl->load($file, %opts);

Loads template file ($file) for later evaluation. File can be specified in either form of pathname or fileglob.

This method accepts DELIM option, used to specify delimiter for parsing template. It is speficied by passing reference to array containing delimiter pair, just like below:

    $tmpl->load($file, DELIM => [qw(<? ?>)]);

Returns object reference to itself.

$tmpl->pack($data, %opts);

Loads in-memory data ($data) for later evaluation. Except for this difference, works just like $tmpl->load.

$text = $tmpl->fill(%opts);

Returns evaluated result of template, which was preloaded by either $tmpl->pack or $tmpl->load method.

This method accepts two options: PACKAGE and OHANDLE.

PACKAGE option specifies the namespace where template evaluation takes place. You can either pass the name of the package, or the package object itself. So either of

    $tmpl->fill(PACKAGE => new Safe);
    $tmpl->fill(PACKAGE => new Some::Module);
    $tmpl->fill(PACKAGE => 'Some::Package');

works. In case Safe module (or its subclass) was passed, its "reval" method will be used instead of built-in eval.

OHANDLE option is for output selection. By default, this method returns the result of evaluation, but with OHANDLE option set, you can instead make it print to given handle. Either style of

    $tmpl->fill(OHANDLE => \*STDOUT);
    $tmpl->fill(OHANDLE => new FileHandle(...));

is supported.


Nested template delimiter will cause this module to fail.


Please send any bug reports/comments to <>.


 - Taisuke Yamada <>
 - Lin Tianshan <>


Copyright 1999-2001. All rights reserved.

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