---
name: "Rex::Template"
section: "3pm"
platform: "linux"
package: "rex"
version: "1.16.0-1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Rex::Template"
---

# Rex::Template(3pm)

simple template engine

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