NAME
    Text::SimpleTemplate - Yet another module for template processing

SYNOPSIS
    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"

DESCRIPTION
   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.

INSTALLATION / REQUIREMENTS
   This module requires Carp.pm and FileHandle.pm. Since these are standard
   modules, all you need is perl itself.

   For installation, standard procedure of

       perl Makefile.PL
       make
       make test
       make install

   should work just fine.

TEMPLATE SYNTAX AND USAGE
   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\@imasy.or.jp",
       });
       $tmpl->load("sample.tmpl");

       print $tmpl->fill(PACKAGE => new Safe);

   ...you will get following result:

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

   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 the Safe
   manpage for more).

DIRECT ACCESS TO TEMPLATE NAMESPACE
   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.

METHODS
   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.

NOTES / BUGS
   Nested template delimiter will cause this module to fail.

CONTACT ADDRESS
   Please send any bug reports/comments to <[email protected]>.

AUTHORS / CONTRIBUTORS
    - Taisuke Yamada <[email protected]>
    - Lin Tianshan <[email protected]>

COPYRIGHT
   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.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.