Mojo::Template - Perl-ish templates!
use Mojo::Template; my $mt = Mojo::Template->new; # Simple my $output = $mt->render(<<'EOF'); % use Time::Piece; <!DOCTYPE html> <html> <head><title>Simple</title></head> % my $now = localtime; <body>Time: <%= $now->hms %></body> </html> EOF say $output; # More advanced my $output = $mt->render(<<'EOF', 23, 'foo bar'); % my ($number, $text) = @_; %= 5 * 5 <!DOCTYPE html> <html> <head><title>More advanced</title></head> <body> test 123 foo <% my $i = $number + 2; %> % for (1 .. 23) { * some text <%= $i++ %> % } </body> </html> EOF say $output;
Mojo::Template is a minimalistic and very Perl-ish template engine, designed specifically for all those small tasks that come up during big projects. Like preprocessing a configuration file, generating text from heredocs and stuff like that.
See Mojolicious::Guides::Rendering for information on how to generate content with the Mojolicious renderer.
For all templates strict, warnings, utf8 and Perl 5.10 features are automatically enabled.
<% Perl code %> <%= Perl expression, replaced with result %> <%== Perl expression, replaced with XML escaped result %> <%# Comment, useful for debugging %> <%% Replaced with "<%", useful for generating templates %> % Perl code line, treated as "<% line =%>" %= Perl expression line, treated as "<%= line %>" %== Perl expression line, treated as "<%== line %>" %# Comment line, useful for debugging %% Replaced with "%", useful for generating templates
Escaping behavior can be reversed with the auto_escape attribute, this is the default in Mojolicious .ep templates for example.
auto_escape
.ep
<%= Perl expression, replaced with XML escaped result %> <%== Perl expression, replaced with result %>
Mojo::ByteStream objects are always excluded from automatic escaping.
% use Mojo::ByteStream 'b'; <%= b('<div>excluded!</div>') %>
Newline characters can be escaped with a backslash.
This is <%= 1 + 1 %> a\ single line
And a backslash in front of a newline character can be escaped with another backslash.
This will <%= 1 + 1 %> result\\ in multiple\\ lines
Whitespace characters around tags can be trimmed with a special tag ending.
<%= All whitespace characters around this expression will be trimmed =%>
You can capture whole template blocks for reuse later with the begin and end keywords.
begin
end
<% my $block = begin %> <% my $name = shift; =%> Hello <%= $name %>. <% end %> <%= $block->('Baerbel') %> <%= $block->('Wolfgang') %>
Perl lines can also be indented freely.
% my $block = begin % my $name = shift; Hello <%= $name %>. % end %= $block->('Baerbel') %= $block->('Wolfgang')
Mojo::Template templates get compiled to a Perl subroutine, that means you can access arguments simply via @_.
@_
% my ($foo, $bar) = @_; % my $x = shift; test 123 <%= $foo %>
The compilation of templates to Perl code can make debugging a bit tricky, but Mojo::Template will return Mojo::Exception objects that stringify to error messages with context.
Bareword "xx" not allowed while "strict subs" in use at template line 4. 2: </head> 3: <body> 4: % my $i = 2; xx 5: %= $i * 2 6: </body>
Mojo::Template implements the following attributes.
my $escape = $mt->auto_escape; $mt = $mt->auto_escape(1);
Activate automatic escaping.
my $code = $mt->append; $mt = $mt->append('warn "Processed template"');
Append Perl code to compiled template. Note that this code should not contain newline characters, or line numbers in error messages might end up being wrong.
my $end = $mt->capture_end; $mt = $mt->capture_end('end');
Keyword indicating the end of a capture block, defaults to end.
<% my $block = begin %> Some data! <% end %>
my $start = $mt->capture_start; $mt = $mt->capture_start('begin');
Keyword indicating the start of a capture block, defaults to begin.
my $code = $mt->code; $mt = $mt->code($code);
Perl code for template.
my $mark = $mt->comment_mark; $mt = $mt->comment_mark('#');
Character indicating the start of a comment, defaults to #.
#
<%# This is a comment %>
my $compiled = $mt->compiled; $mt = $mt->compiled($compiled);
Compiled template code.
my $encoding = $mt->encoding; $mt = $mt->encoding('UTF-8');
Encoding used for template files.
my $cb = $mt->escape; $mt = $mt->escape(sub { reverse $_[0] });
A callback used to escape the results of escaped expressions, defaults to "xml_escape" in Mojo::Util.
my $mark = $mt->escape_mark; $mt = $mt->escape_mark('=');
Character indicating the start of an escaped expression, defaults to =.
=
<%== $foo %>
my $mark = $mt->expression_mark; $mt = $mt->expression_mark('=');
Character indicating the start of an expression, defaults to =.
<%= $foo %>
my $start = $mt->line_start; $mt = $mt->line_start('%');
Character indicating the start of a code line, defaults to %.
%
% $foo = 23;
my $name = $mt->name; $mt = $mt->name('foo.mt');
Name of template currently being processed, defaults to template. Note that this value should not contain quotes or newline characters, or error messages might end up being wrong.
template
my $namespace = $mt->namespace; $mt = $mt->namespace('main');
Namespace used to compile templates, defaults to Mojo::Template::SandBox. Note that namespaces should only be shared very carefully between templates, since functions and global variables will not be cleared automatically.
Mojo::Template::SandBox
my $code = $mt->prepend; $mt = $mt->prepend('my $self = shift;');
Prepend Perl code to compiled template. Note that this code should not contain newline characters, or line numbers in error messages might end up being wrong.
my $mark = $mt->replace_mark; $mt = $mt->replace_mark('%');
Character used for escaping the start of a tag or line, defaults to %.
<%% my $foo = 23; %>
my $start = $mt->tag_start; $mt = $mt->tag_start('<%');
Characters indicating the start of a tag, defaults to <%.
<%
<% $foo = 23; %>
my $end = $mt->tag_end; $mt = $mt->tag_end('%>');
Characters indicating the end of a tag, defaults to %>.
%>
my $template = $mt->template; $mt = $mt->template($template);
Raw template.
my $tree = $mt->tree; $mt = $mt->tree($tree);
Parsed tree.
my $mark = $mt->trim_mark; $mt = $mt->trim_mark('-');
Character activating automatic whitespace trimming, defaults to =.
<%= $foo =%>
Mojo::Template inherits all methods from Mojo::Base and implements the following new ones.
my $mt = Mojo::Template->new;
Construct a new Mojo::Template object.
$mt = $mt->build;
Build Perl code from tree.
my $exception = $mt->compile;
Compile Perl code for template.
my $output = $mt->interpret; my $output = $mt->interpret(@args);
Interpret compiled template code.
# Reuse template say $mt->render('Hello <%= $_[0] %>!', 'Bender'); say $mt->interpret('Fry'); say $mt->interpret('Leela');
$mt = $mt->parse($template);
Parse template into tree.
my $output = $mt->render($template); my $output = $mt->render($template, @args);
Render template.
say $mt->render('Hello <%= $_[0] %>!', 'Bender');
my $output = $mt->render_file('/tmp/foo.mt'); my $output = $mt->render_file('/tmp/foo.mt', @args);
Render template file.
You can set the MOJO_TEMPLATE_DEBUG environment variable to get some advanced diagnostics information printed to STDERR.
STDERR
MOJO_TEMPLATE_DEBUG=1
Mojolicious, Mojolicious::Guides, http://mojolicio.us.
To install Mojolicious, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Mojolicious
CPAN shell
perl -MCPAN -e shell install Mojolicious
For more information on module installation, please visit the detailed CPAN module installation guide.