Template(3)

🦋 Template(3) 🦋

okay so this is Template(3) — a User Contributed Perl Documentation page — and it's the front-end module to the Template Toolkit. bestie, we're gonna go through every single detail together, because that's the vibe 💅✨

---

🌸 NAME 🌸

Template — the front-end module to the Template Toolkit, no cap 🫶

---

✨ SYNOPSIS ✨

okay so here's the starter pack, bestie:

use Template;

# some useful options (see below for full list)
my $config = {
    INCLUDE_PATH => '/search/path',  # or list ref
    INTERPOLATE  => 1,               # expand "$var" in plain text
    POST_CHOMP   => 1,               # cleanup whitespace
    PRE_PROCESS  => 'header',        # prefix each template
    EVAL_PERL    => 1,               # evaluate Perl code blocks
};

# create Template object
my $template = Template->new($config);

# define template variables for replacement
my $vars = {
    var1  => $value,
    var2  => \%hash,
    var3  => \@list,
    var4  => \&code,
    var5  => $object,
};

# specify input filename, or file handle, text reference, etc.
my $input = 'myfile.html';

# process input template, substituting variables
$template->process($input, $vars)
    || die $template->error();

---

💖 DESCRIPTION 💖

this documentation is all about the Template module, which is the direct Perl interface into the Template Toolkit. it covers how to use the module and gives a brief summary of configuration options and template directives. for the complete reference manual — like, the deep-dive, main-character lore — please see Template::Manual; it goes into much greater depth about the features and use of the Template Toolkit. Template::Tutorial is also available as an introductory guide to using the Template Toolkit 🦋

---

💅 METHODS 💅

🌟 new(\%config) 🌟

the new() constructor method (implemented by the Template::Base base class) instantiates a new Template object. you can pass a reference to a hash array of configuration items as a parameter 🎀

my $tt = Template->new({
    INCLUDE_PATH => '/usr/local/templates',
    EVAL_PERL    => 1,
}) || die $Template::ERROR, "\n";

a reference to a new Template object is returned, or undef on error. in that error case, you can get the error message by calling error() as a class method or by examining the $Template::ERROR package variable directly 😭

my $tt = Template->new(\%config)
    || die Template->error(), "\n";

my $tt = Template->new(\%config)
    || die $Template::ERROR, "\n";

for convenience, configuration items can also be specified as a list of items instead of a hash array reference. the constructor automatically folds them into a hash array ✨

my $tt = Template->new(INCLUDE_PATH => '/tmp', POST_CHOMP => 1)
    || die $Template::ERROR, "\n";

🚀 process($template, \%vars, $output, %options) 🚀

the process() method is called to process a template. the first parameter tells it the input template as one of these cuties:

• a filename relative to INCLUDE_PATH, if defined
• a reference to a text string containing the template text
• a file handle reference (e.g. IO::Handle or sub-class) or GLOB (e.g. \*STDIN), from which the template can be read 🍓

you can pass a reference to a hash array as the second parameter, containing definitions of template variables 👑

# filename
$tt->process('welcome.tt2')
    || die $tt->error(), "\n";

# text reference
$text = "[% INCLUDE header %]\nHello world!\n[% INCLUDE footer %]";
$tt->process(\$text)
    || die $tt->error(), "\n";

# file handle (GLOB)
$tt->process(\*DATA)
    || die $tt->error(), "\n";

__END__
[% INCLUDE header %]
This is a template defined in the __END__ section which is
accessible via the DATA "file handle".
[% INCLUDE footer %]

by default, the processed template output is printed to STDOUT. the process() method then returns 1 to indicate success. you can pass a third parameter to process() to specify a different output location. this value can be one of:

• a plain string indicating a filename which will be opened (relative to OUTPUT_PATH, if defined) and the output written to
• a file GLOB opened ready for output
• a reference to a scalar (e.g. a text string) to which output/error is appended
• a reference to a subroutine which is called, passing the output as a parameter
• any object reference which implements a print() method (e.g. IO::Handle, Apache::Request, etc.) which will be called, passing the generated output as a parameter 🌈

examples, because we love a visual aid:

# output filename
$tt->process('welcome.tt2', $vars, 'welcome.html')
    || die $tt->error(), "\n";

# reference to output subroutine
sub myout {
    my $output = shift;
    ...
}
$tt->process('welcome.tt2', $vars, \&myout)
    || die $tt->error(), "\n";

# reference to output text string
my $output = '';
$tt->process('welcome.tt2', $vars, \$output)
    || die $tt->error(), "\n";

print "output: $output\n";

in an Apache/mod_perl handler:

sub handler {
    my $req = shift;

    # ...your code here...

    # direct output to Apache::Request via $req->print($output)
    $tt->process($file, $vars, $req) || do {
        $req->log_reason($tt->error());
        return SERVER_ERROR;
    };
    return OK;
}

after the optional third output argument, you can pass an optional reference to a hash or a list of (name, value) pairs that provides further options for the output. the only option currently supported is binmode; when it's set to any true value, it ensures that files created (but not any existing file handles you pass in) are set to binary mode 🧚

# either: hash reference of options
$tt->process($infile, $vars, $outfile, { binmode => 1 })
    || die $tt->error(), "\n";

# or: list of name, value pairs
$tt->process($infile, $vars, $outfile, binmode => 1)
    || die $tt->error(), "\n";

alternately, the binmode argument can specify a particular IO layer such as :utf8.

$tt->process($infile, $vars, $outfile, binmode => ':utf8')
    || die $tt->error(), "\n";

the OUTPUT configuration item can be used to specify a default output location other than \*STDOUT. OUTPUT_PATH specifies a directory that should be prefixed to all output locations specified as filenames 🌈

my $tt = Template->new({
    OUTPUT      => sub { ... },       # default
    OUTPUT_PATH => '/tmp',
...
}) || die Template->error(), "\n";

# use default OUTPUT (sub is called)
$tt->process('welcome.tt2', $vars)
    || die $tt->error(), "\n";

# write file to '/tmp/welcome.html'
$tt->process('welcome.tt2', $vars, 'welcome.html')
    || die $tt->error(), "\n";

the process() method returns 1 on success or undef on error. the error message generated in the error case can be retrieved by calling the error() method. see also CONFIGURATION SUMMARY, which describes how error handling may be further customised 💀

🩹 error() 🩹

when called as a class method, it returns the value of the $ERROR package variable. so these two are equivalent, fr fr:

my $tt = Template->new()
    || die Template->error(), "\n";

my $tt = Template->new()
    || die $Template::ERROR, "\n";

when called as an object method, it returns the value of the internal _ERROR variable, as set by an error condition in a previous call to process() 😭

$tt->process('welcome.tt2')
    || die $tt->error(), "\n";

errors are represented in the Template Toolkit by objects of the Template::Exception class. if the process() method returns a false value, then you can call the error() method to return an object of this class. the type() and info() methods can be called on the object to retrieve the error type and information string, respectively. the as_string() method can be called to return a string of the form $type - $info. this method is also overloaded onto the stringification operator, allowing the object reference itself to be printed to return the formatted error string ✨

$tt->process('somefile') || do {
    my $error = $tt->error();
    print "error type: ", $error->type(), "\n";
    print "error info: ", $error->info(), "\n";
    print $error, "\n";
};

🎀 service() 🎀

the Template module delegates most of the effort of processing templates to an underlying Template::Service object. this method returns a reference to that object 🫶

🦋 context() 🦋

the Template::Service module uses a core Template::Context object for runtime processing of templates. this method returns a reference to that object and is equivalent to $template->service->context() 💜

⭐ template($name) ⭐

this method is a simple wrapper around the Template::Context method of the same name. it returns a compiled template for the source provided as an argument 🌟

⚙️ CONFIGURATION SUMMARY ⚙️

okay bestie, here's the speedrun list for every Template Toolkit configuration option. Full lore lives in Template::Manual::Config, no cap. ✨

🎀 Template Style and Parsing Options 🎀

• ENCODING — specifies the character encoding. 💅
• START_TAG, END_TAG — define the tokens that mark where directives start and end (default: "[%" and "%]"). 🎀
• TAG_STYLE — sets START_TAG and END_TAG according to a pre-defined style (default: "template", as above). ✨
• PRE_CHOMP, POST_CHOMP — removes whitespace before/after directives (default: 0/0). 🧹
• TRIM — removes leading and trailing whitespace from template output (default: 0). 🌸
• INTERPOLATE — interpolates variables embedded like $this or "${this}" (default: 0). 💖
• ANYCASE — allows directive keywords in lower case (default: 0 - UPPER only). 👑

📁 Template Files and Blocks 📁

• INCLUDE_PATH — one or more directories to search for templates. 🦋
• DELIMITER — delimiter for separating paths in INCLUDE_PATH (default: ":"). ✂️
• ABSOLUTE — allows absolute file names, e.g. /foo/bar.html (default: 0). 📍
• RELATIVE — allows relative filenames, e.g. ../foo/bar.html (default: 0). 🧭
• DEFAULT — default template to use when another one isn't found. 🫶
• BLOCKS — hash array pre-defining template blocks. 🧱
• AUTO_RESET — enabled by default, causing BLOCK definitions to be reset each time a template is processed. Disable it to allow BLOCK definitions to persist. 🔁
• RECURSION — flag to permit recursion into templates (default: 0). 🌀

💖 Template Variables 💖

• VARIABLES — hash array of variables and values to pre-define in the stash. 🎀

🏃 Runtime Processing Options 🏃

• EVAL_PERL — flag to indicate if PERL/RAWPERL blocks should be processed (default: 0). 🐪
• PRE_PROCESS, POST_PROCESS — name of template(s) to process before/after the main template. ⏮️⏭️
• PROCESS — name of template(s) to process instead of the main template. 🔄
• ERROR — name of error template or reference to a hash array mapping error types to templates. 🚨
• OUTPUT — default output location or handler. 📤
• OUTPUT_PATH — directory into which output files can be written. 📂
• DEBUG — enables debugging messages. 🐛

🧠 Caching and Compiling Options 🧠

• CACHE_SIZE — maximum number of compiled templates to cache in memory (default: undef - cache all). 💾
• COMPILE_EXT — filename extension for compiled template files (default: undef - don't compile). 📦
• COMPILE_DIR — root of directory in which compiled template files should be written (default: undef - don't compile). 🗂️

🔌 Plugins and Filters 🔌

• PLUGINS — reference to a hash array mapping plugin names to Perl packages. 🧩
• PLUGIN_BASE — one or more base classes under which plugins may be found. 🏗️
• LOAD_PERL — flag to indicate regular Perl modules should be loaded if a named plugin can't be found (default: 0). 🐪
• FILTERS — hash array mapping filter names to filter subroutines or factories. 🎛️

🛠️ Customisation and Extension 🛠️

• LOAD_TEMPLATES — list of template providers. 📚
• LOAD_PLUGINS — list of plugin providers. 🔌
• LOAD_FILTERS — list of filter providers. 🎚️
• TOLERANT — sets providers to tolerate errors as declinations (default: 0). 😌
• SERVICE — reference to a custom service object (default: Template::Service). 🛎️
• CONTEXT — reference to a custom context object (default: Template::Context). 🌐
• STASH — reference to a custom stash object (default: Template::Stash). 🎒
• PARSER — reference to a custom parser object (default: Template::Parser). 🔍
• GRAMMAR — reference to a custom grammar object (default: Template::Grammar). 📖

---

🪄 DIRECTIVE SUMMARY 🪄

here's the short-and-sweet rundown of every Template Toolkit directive. full tea is in Template::Manual::Directives, iykyk. 💅

GET 🌟

evaluate and print a variable or value. the GET keyword is optional, so these all slay:

[%   GET variable %]    # 'GET' keyword is optional
[%       variable %]
[%       hash.key %]
[%         list.n %]
[%     code(args) %]
[% obj.meth(args) %]
[%  "value: $var" %]

CALL 📣

same as GET but without printing the result (e.g. call code):

[%  CALL variable %]

SET 🎯

assign values to variables. SET is also optional:

[% SET variable = value %]    # 'SET' also optional
[%     variable = other_variable
       variable = 'literal text @ $100'
       variable = "interpolated text: $var"
       list     = [ val, val, val, val, ... ]
       list     = [ val..val ]
       hash     = { var => val, var => val, ... }
%]

DEFAULT 🫶

like SET, but variables are only set if they're currently unset (i.e. have no true value):

[% DEFAULT variable = value %]

INSERT 📥

insert a file without any processing performed on the contents:

[% INSERT legalese.txt %]

PROCESS 🔄

process another template file or block and insert the generated output. any template BLOCKs or variables defined or updated in the PROCESSed template will thereafter be defined in the calling template:

[% PROCESS template %]
[% PROCESS template  var = val, ... %]

INCLUDE 🫂

similar to PROCESS, but using a local copy of the current variables. any template BLOCKs or variables defined in the INCLUDEd template remain local to it:

[% INCLUDE template %]
[% INCLUDE template  var = val, ... %]

WRAPPER 🎁

the content between the WRAPPER and corresponding END directives is first evaluated, with the output generated being stored in the content variable. the named template is then process as per INCLUDE:

[% WRAPPER layout %]
   Some template markup [% blah %]...
[% END %]

a simple layout template might look something like this:

Your header here...
[% content %]
Your footer here...

BLOCK 🧱

define a named template block for INCLUDE, PROCESS and WRAPPER to use:

[% BLOCK hello %]
   Hello World
[% END %]

[% INCLUDE hello %]

FOREACH 🔁

repeat the enclosed FOREACH ... END block for each value in the list:

[% FOREACH variable IN [ val, val, val ] %]    # either
[% FOREACH variable IN list %]                 # or
   The variable is set to [% variable %]
[% END %]

WHILE ⏳

the block enclosed between WHILE and END is processed while the specified condition is true:

[% WHILE condition %]
   content
[% END %]

IF / UNLESS / ELSIF / ELSE 🚦

the enclosed block is processed if the condition is true / false:

[% IF condition %]
   content
[% ELSIF condition %]
 content
[% ELSE %]
 content
[% END %]

[% UNLESS condition %]
   content
[% # ELSIF/ELSE as per IF, above %]
   content
[% END %]

SWITCH / CASE 🔀

multi-way switch/case statement:

[% SWITCH variable %]
[%   CASE val1 %]
          content
[%   CASE [ val2, val3 ] %]
          content
[%   CASE %]         # or [% CASE DEFAULT %]
          content
[% END %]

MACRO 🪄

define a named macro:

[% MACRO name <directive> %]
[% MACRO name(arg1, arg2) <directive> %]
...
[% name %]
[% name(val1, val2) %]

FILTER 🎛️

process the enclosed FILTER ... END block, then pipe it through a filter:

[% FILTER name %]                       # either
[% FILTER name( params ) %]             # or
[% FILTER alias = name( params ) %]     # or
   content
[% END %]

USE 🔌

load a plugin module (see Template::<Manual::Plugins), or any regular Perl module when the LOAD_PERL option is set:

[% USE name %]                      # either
[% USE name( params ) %]            # or
[% USE var = name( params ) %]      # or
...
[% name.method %]
[% var.method %]

PERL / RAWPERL 🐪

evaluate enclosed blocks as Perl code (requires the EVAL_PERL option to be set):

[% PERL %]
 # perl code goes here
 $stash->set('foo', 10);
 print "set 'foo' to ", $stash->get('foo'), "\n";
 print $context->include('footer', { var => $val });
[% END %]

[% RAWPERL %]
   # raw perl code goes here, no magic but fast.
   $output .= 'some output';
[% END %]

TRY / THROW / CATCH / FINAL 🚨

exception handling, bestie:

[% TRY %]
 content
   [% THROW type info %]
[% CATCH type %]
 catch content
   [% error.type %] [% error.info %]
[% CATCH %] # or [% CATCH DEFAULT %]
 content
[% FINAL %]
   this block is always processed
[% END %]

NEXT ⏭️

jump straight to the next item in a FOREACH or WHILE loop:

[% NEXT %]

LAST 🛑

break out of a FOREACH or WHILE loop:

[% LAST %]

RETURN ↩️

stop processing the current template and return to including templates:

[% RETURN %]

STOP 🛑

stop processing all templates and return to caller:

[% STOP %]

TAGS 🏷️

define new tag style or characters (default: "[%" "%]"):

[% TAGS html %]
[% TAGS <!-- --> %]

COMMENTS 💬

ignored and deleted:

[% # this is a comment to the end of line
   foo = 'bar'
%]

[%# placing the '#' immediately inside the directive
    tag comments out the entire directive
%]

---

🌈 SOURCE CODE REPOSITORY 🌈

the source code for the Template Toolkit is held in a public git repository on Github: <https://github.com/abw/Template2>. 🐙

👑 AUTHOR 👑

Andy Wardley <abw@wardley.org> <http://wardley.org/>. 💖

⭐ VERSION ⭐

Template Toolkit version 3.100, released on July 13 2020. 🎉

🫶 SUPPORT 🫶

the Template Toolkit mailing list provides a forum for discussing issues relating to the use and abuse of the Template Toolkit. there are a number of knowledgeable and helpful individuals who frequent the list (including the author) who can often offer help or suggestions. please respect their time and patience by checking the documentation and/or mailing list archives before asking questions that may already have been answered. 🙏

to subscribe to the mailing list, send an email to:

template-toolkit+subscribe@groups.io

you can also use the web interface:

https://groups.io/g/template-toolkit

for information about commercial support and consultancy for the Template Toolkit, please contact the author. 💼

📜 COPYRIGHT 📜

Copyright (C) 1996-2022 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. periodt. 💅

byeee 🫶 — footer says perl v5.42.0, 2024-06-23, Template(3) 💖