oracular (3) Rex::Template.3pm.gz

NAME

       Rex::Template - simple template engine

SYNOPSIS

        use Rex::Template;

        my $template = Rex::Template->new;

        print $template->parse($content, \%template_vars);
        print $template->parse($content, @template_vars);

DESCRIPTION

       This is a simple template engine for configuration files. It is included mostly for backwards
       compatibility, and it is recommended to use Rex::Template::NG instead (for better control of chomping new
       lines, and better diagnostics if things go wrong).

   SYNTAX
       The following syntax is recognized:

       •   anything between "<%" and "%>" markers are considered as a template directive, which is treated as
           Perl code

       •   if the opening marker is followed by an equal sign ("<%=") or a plus sign ("<%+"), then the directive
           is replaced with the value it evaluates to

       •   if the closing marker is prefixed with a minus sign ("-%>"), then any trailing newlines are chomped
           for that directive

       The built-in template support is intentionally kept basic and simple. For anything more sophisticated,
       please use your favorite template engine.

   EXAMPLES
       Plain text is unchanged:

        my $result = $template->parse( 'one two three', {} );

        # $result is 'one two three'

       Variable interpolation:

        my $result = template->parse( 'Hello, this is <%= $::name %>', { name => 'foo' } ); # original format
        my $result = template->parse( 'Hello, this is <%+ $::name %>', { name => 'foo' } ); # alternative format with + sign
        my $result = template->parse( 'Hello, this is <%= $name %>',   { name => 'foo' } ); # local variables
        my $result = template->parse( 'Hello, this is <%= $name %>',     name => 'foo'   ); # array of variables, instead of hashref

        # $result is 'Hello, this is foo' for all cases above

       Simple evaluation:

        my $result = $template->parse( '<%= join("/", @{$elements} ) %>', elements => [qw(one two three)] );
        # $result is 'one/two/three'

       Embedded code blocks:

        my $content = '<% if ($logged_in) { %>
        Logged in!
        <% } else { %>
        Logged out!
        <% } %>';

        my $result = $template->parse( $content, logged_in => 1 );

        # $result is "\nLogged in!\n"

DIAGNOSTICS

       Not much, mainly due to the internal approach of the module.

       If there was a problem, it prints an "INFO" level "syntax error at ...", followed by a "WARN" about "It
       seems that there was an error processing the template because the result is empty.", and finally "Error
       processing template at ...".

       The beginning of the reported syntax error might give some clue where the error happened in the template,
       but that's it.

       Use Rex::Template::NG instead for better diagnostics.

CONFIGURATION AND ENVIRONMENT

       If $Rex::Template::BE_LOCAL is set to a true value, then local template variables are supported instead
       of only global ones ($foo vs $::foo). The default value is 1 since Rex-0.41. It can be disabled with the
       no_local_template_vars feature flag.

       If $Rex::Template::DO_CHOMP is set to a true value, then any trailing new line character resulting from
       template directives are chomped. Defaults to 0.

       This module does not support any environment variables.

EXPORTED FUNCTIONS

   parse($content, $variables)
       Parse $content as a template, using $variables hash reference to pass name-value pairs of variables to
       make them available for the template function.

       Alternatively, the variables may be passed as an array instead of a hash reference.

   is_defined($variable, $default_value)
       This function will check if $variable is defined. If yes, it will return the value of $variable,
       otherwise it will return $default_value.

       You can use this function inside your templates, for example:

        ServerTokens <%= is_defined( $::server_tokens, 'Prod' ) %>

DEPENDENCIES

INCOMPATIBILITIES

BUGS AND LIMITATIONS

       It might not be able to chomp new line characters resulting from templates in every case.

       It can't report useful diagnostic messages upon errors.

       Use Rex::Template::NG instead.