[%# # IMPORTANT NOTE # This documentation is generated automatically from source # templates. Any changes you make here may be lost. # # The 'docsrc' documentation source bundle is available for download # from http://www.template-toolkit.org/docs.html and contains all # the source templates, XML files, scripts, etc., from which the # documentation for the Template Toolkit is built. -%] [% META book = 'Modules' page = 'Template' %] [% WRAPPER toc; PROCESS tocitem title ="SYNOPSIS " subs = []; PROCESS tocitem title ="DESCRIPTION" subs = []; PROCESS tocitem title ="METHODS" subs = [ "new(\\%config)", "process(\$template, \\%vars, \$output, %options)", "error()", "service()", "context()" ]; PROCESS tocitem title ="CONFIGURATION SUMMARY" subs = [ "Template Style and Parsing Options", "Template Files and Blocks", "Template Variables", "Runtime Processing Options", "Caching and Compiling Options", "Plugins and Filters", "Compatibility, Customisation and Extension" ]; PROCESS tocitem title ="DIRECTIVE SUMMARY" subs = []; PROCESS tocitem title ="AUTHOR" subs = []; PROCESS tocitem title ="VERSION" subs = []; PROCESS tocitem title ="COPYRIGHT" subs = []; END %] [% WRAPPER section title="SYNOPSIS " -%]

      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();

[%- END %] [% WRAPPER section title="DESCRIPTION" -%]

This documentation describes the Template module which is the direct Perl interface into the Template Toolkit. It covers the use of the module and gives a brief summary of configuration options and template directives. Please see [% ttlink('Template::Manual') -%] for the complete reference manual which goes into much greater depth about the features and use of the Template Toolkit. The [% ttlink('Template::Tutorial') -%] is also available as an introductory guide to using the Template Toolkit.

[%- END %] [% WRAPPER section title="METHODS" -%][% WRAPPER subsection title = "new(\\%config)" -%]

The new() constructor method (implemented by the Template::Base base class) instantiates a new Template object. A reference to a hash array of configuration items may be passed 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 the latter case, the error message can be retrieved by calling error() as a class method (e.g. `'Template->error()'`) or by examining the $ERROR package variable directly (e.g. `'$Template::ERROR'`).

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

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

For convenience, configuration items may also be specified as a list of items instead of a hash array reference. These are automatically folded into a hash array by the constructor.

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

[%- END %] [% WRAPPER subsection title = "process(\$template, \\%vars, \$output, %options)" -%]

The process() method is called to process a template. The first parameter indicates the input template as one of: a filename relative to INCLUDE_PATH, if defined; a reference to a text string containing the template text; or a file handle reference (e.g. IO::Handle or sub-class) or GLOB (e.g. \*STDIN), from which the template can be read. A reference to a hash array may be passed as the second parameter, containing definitions of template variables.

        $text = "[% tt_start_tag %] INCLUDE header [% tt_end_tag %]\nHello world!\n[% tt_start_tag %] INCLUDE footer [% tt_end_tag %]";

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

        # text reference
        $tt->process(\$text)
            || die $tt->error(), "\n";

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

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

By default, the processed template output is printed to STDOUT. The process() method then returns 1 to indicate success. A third parameter may be passed to the process() method to specify a different output location. This value may 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; or 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:

        # 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;

            ...

    	# 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 can come an optional reference to a hash or a list of (name, value) pairs providing further options for the output. The only option currently supported is "binmode" which, when set to any true value will ensure that files created (but not any existing file handles passed) will be 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. The OUTPUT_PATH specifies a directory which 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 latter case can be retrieved by calling the error() method. See also [% ttlink('CONFIGURATION SUMMARY') -%] which describes how error handling may be further customised.

[%- END %] [% WRAPPER subsection title = "error()" -%]

When called as a class method, it returns the value of the $ERROR package variable. Thus, the following are equivalent.

        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 the error() method can be called to return an object of this class. The type() and info() methods can 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";
        };

[%- END %] [% WRAPPER subsection title = "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.

[%- END %] [% WRAPPER subsection title = "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();

[%- END %] [%- END %] [% WRAPPER section title="CONFIGURATION SUMMARY" -%]

The following list gives a short summary of each Template Toolkit configuration option. See [% ttlink('Template::Manual::Config') -%] for full details.

[% WRAPPER subsection title = "Template Style and Parsing Options" -%]

- START_TAG, END_TAG

  Define tokens that indicate start and end of directives (default: '[% tt_start_tag %]' and '[% tt_end_tag %]').

- TAG_STYLE

  Set START_TAG and END_TAG according to a pre-defined style (default: 'template', as above).

- PRE_CHOMP, POST_CHOMP

  Remove whitespace before/after directives (default: 0/0).

- TRIM

  Remove leading and trailing whitespace from template output (default: 0).

- INTERPOLATE

  Interpolate variables embedded like $this or ${this} (default: 0).

- ANYCASE

  Allow directive keywords in lower case (default: 0 - UPPER only).

[%- END %] [% WRAPPER subsection title = "Template Files and Blocks" -%]

- INCLUDE_PATH

  One or more directories to search for templates.

- DELIMITER

  Delimiter for separating paths in INCLUDE_PATH (default: ':').

- ABSOLUTE

  Allow absolute file names, e.g. /foo/bar.html (default: 0).

- RELATIVE

  Allow relative filenames, e.g. ../foo/bar.html (default: 0).

- DEFAULT

  Default template to use when another not 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 to allow BLOCK definitions to persist.

- RECURSION

  Flag to permit recursion into templates (default: 0).

[%- END %] [% WRAPPER subsection title = "Template Variables" -%]

- VARIABLES, PRE_DEFINE

  Hash array of variables and values to pre-define in the stash.

[%- END %] [% WRAPPER subsection title = "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 main template.

- PROCESS

  Name of template(s) to process instead of main template.

- ERROR

  Name of error template or reference to hash array mapping error types to templates.

- OUTPUT

  Default output location or handler.

- OUTPUT_PATH

  Directory into which output files can be written.

- DEBUG

  Enable debugging messages.

[%- END %] [% WRAPPER subsection title = "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).

[%- END %] [% WRAPPER subsection title = "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.

[%- END %] [% WRAPPER subsection title = "Compatibility, Customisation and Extension" -%]

- V1DOLLAR

  Backwards compatibility flag enabling version 1.* handling (i.e. ignore it) of leading '$' on variables (default: 0 - '$' indicates interpolation).

- LOAD_TEMPLATES

  List of template providers.

- LOAD_PLUGINS

  List of plugin providers.

- LOAD_FILTERS

  List of filter providers.

- TOLERANT

  Set 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).

[%- END %] [%- END %] [% WRAPPER section title="DIRECTIVE SUMMARY" -%]

The following list gives a short summary of each Template Toolkit directive. See [% ttlink('Template::Manual::Directives') -%] for full details.

- GET

  Evaluate and print a variable or value.

          [% tt_start_tag %]   GET variable [% tt_end_tag %]    # 'GET' keyword is optional

          [% tt_start_tag %]       variable [% tt_end_tag %]
          [% tt_start_tag %]       hash.key [% tt_end_tag %]
          [% tt_start_tag %]         list.n [% tt_end_tag %]
          [% tt_start_tag %]     code(args) [% tt_end_tag %]
          [% tt_start_tag %] obj.meth(args) [% tt_end_tag %]
          [% tt_start_tag %]  "value: $var" [% tt_end_tag %]

- CALL

  As per GET but without printing result (e.g. call code)

          [% tt_start_tag %]  CALL variable [% tt_end_tag %]

- SET

  Assign a values to variables.

          [% tt_start_tag %] SET variable = value [% tt_end_tag %]    # 'SET' also optional

          [% tt_start_tag %]     variable = other_variable
          	   variable = 'literal text @ $100'
          	   variable = "interpolated text: $var"
          	   list     = [ val, val, val, val, ... ]
          	   list     = [ val..val ]
          	   hash     = { var => val, var => val, ... }
          [% tt_end_tag %]

- DEFAULT

  Like SET above, but variables are only set if currently unset (i.e. have no true value).

          [% tt_start_tag %] DEFAULT variable = value [% tt_end_tag %]

- INSERT

  Insert a file without any processing performed on the contents.

          [% tt_start_tag %] INSERT legalese.txt [% tt_end_tag %]

- INCLUDE

  Process another template file or block and include the output. Variables are localised.

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

- PROCESS

  As INCLUDE above, but without localising variables.

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

- WRAPPER

  Process the enclosed block WRAPPER ... END block then INCLUDE the named template, passing the block output in the 'content' variable.

          [% tt_start_tag %] WRAPPER template [% tt_end_tag %]
             content...
          [% tt_start_tag %] END [% tt_end_tag %]

- BLOCK

  Define a named template block for subsequent INCLUDE, PROCESS, etc.,

          [% tt_start_tag %] BLOCK template [% tt_end_tag %]
             content
          [% tt_start_tag %] END [% tt_end_tag %]

- FOREACH

  Repeat the enclosed FOREACH ... END block for each value in the list.

          [% tt_start_tag %] FOREACH variable = [ val, val, val ] [% tt_end_tag %]	  # either
          [% tt_start_tag %] FOREACH variable = list [% tt_end_tag %]                 # or
          [% tt_start_tag %] FOREACH list [% tt_end_tag %]                            # or
             content...
             [% tt_start_tag %] variable [% tt_end_tag %]
          [% tt_start_tag %] END [% tt_end_tag %]

- WHILE

  Enclosed WHILE ... END block is processed while condition is true.

          [% tt_start_tag %] WHILE condition [% tt_end_tag %]
             content
          [% tt_start_tag %] END [% tt_end_tag %]

- IF / UNLESS / ELSIF / ELSE

  Enclosed block is processed if the condition is true / false.

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

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

- SWITCH / CASE

  Multi-way switch/case statement.

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

- MACRO

  Define a named macro.

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

- FILTER

  Process enclosed FILTER ... END block then pipe through a filter.

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

- USE

  Load a "plugin" module, or any regular Perl module if LOAD_PERL option is set.

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

- PERL / RAWPERL

  Evaluate enclosed blocks as Perl code (requires EVAL_PERL option to be set).

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

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

- TRY / THROW / CATCH / FINAL

  Exception handling.

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

- NEXT

  Jump straight to the next item in a FOREACH/WHILE loop.

          [% tt_start_tag %] NEXT [% tt_end_tag %]

- LAST

  Break out of FOREACH/WHILE loop.

          [% tt_start_tag %] LAST [% tt_end_tag %]

- RETURN

  Stop processing current template and return to including templates.

          [% tt_start_tag %] RETURN [% tt_end_tag %]

- STOP

  Stop processing all templates and return to caller.

          [% tt_start_tag %] STOP [% tt_end_tag %]

- TAGS

  Define new tag style or characters (default: [% tt_start_tag %] [% tt_end_tag %]).

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

- COMMENTS

  Ignored and deleted.

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

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

[%- END %] [% WRAPPER section title="AUTHOR" -%]

Andy Wardley <abw@andywardley.com>

[% ttlink('http://www.andywardley.com/', 'http://www.andywardley.com/') -%]

[%- END %] [% WRAPPER section title="VERSION" -%]

Template Toolkit version 2.14, released on 04 October 2004.

[%- END %] [% WRAPPER section title="COPYRIGHT" -%]

      Copyright (C) 1996-2004 Andy Wardley.  All Rights Reserved.
      Copyright (C) 1998-2002 Canon Research Centre Europe Ltd.

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

[%- END %]