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 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, treated as "<%# line =%>" %% 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.
<%= Mojo::ByteStream->new('<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 work just like Perl subs (actually they get compiled to a Perl sub internally). That means you can access arguments simply via @_.
@_
% my ($foo, $bar) = @_; % my $x = shift; test 123 <%= $foo %>
Templates get compiled to Perl code internally, this 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 XML escaping.
append
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.
capture_end
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 %>
capture_start
my $start = $mt->capture_start; $mt = $mt->capture_start('begin');
Keyword indicating the start of a capture block, defaults to begin.
code
my $code = $mt->code; $mt = $mt->code($code);
Template code.
comment_mark
my $mark = $mt->comment_mark; $mt = $mt->comment_mark('#');
Character indicating the start of a comment, defaults to #.
#
<%# This is a comment %>
compiled
my $compiled = $mt->compiled; $mt = $mt->compiled($compiled);
Compiled template code.
encoding
my $encoding = $mt->encoding; $mt = $mt->encoding('UTF-8');
Encoding used for template files.
escape_mark
my $mark = $mt->escape_mark; $mt = $mt->escape_mark('=');
Character indicating the start of an escaped expression, defaults to =.
=
<%== $foo %>
expression_mark
my $mark = $mt->expression_mark; $mt = $mt->expression_mark('=');
Character indicating the start of an expression, defaults to =.
<%= $foo %>
line_start
my $start = $mt->line_start; $mt = $mt->line_start('%');
Character indicating the start of a code line, defaults to %.
%
% $foo = 23;
name
my $name = $mt->name; $mt = $mt->name('foo.mt');
Name of template currently being processed, defaults to template. Note that this method is attribute and might change without warning!
template
namespace
my $namespace = $mt->namespace; $mt = $mt->namespace('main');
Namespace used to compile templates, defaults to Mojo::Template::SandBox.
Mojo::Template::SandBox
prepend
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.
replace_mark
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; %>
tag_start
my $start = $mt->tag_start; $mt = $mt->tag_start('<%');
Characters indicating the start of a tag, defaults to <%.
<%
<% $foo = 23; %>
tag_end
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.
tree
my $tree = $mt->tree; $mt = $mt->tree($tree);
Parsed tree.
trim_mark
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.
new
my $mt = Mojo::Template->new;
Construct a new Mojo::Template object.
build
$mt = $mt->build;
Build template.
compile
my $exception = $mt->compile;
Compile template.
interpret
my $output = $mt->interpret; my $output = $mt->interpret(@args);
Interpret template.
# Reuse template say $mt->render('Hello <%= $_[0] %>!', 'Bender'); say $mt->interpret('Fry'); say $mt->interpret('Leela');
parse
$mt = $mt->parse($template);
Parse template.
render
my $output = $mt->render($template); my $output = $mt->render($template, @args);
Render template.
say $mt->render('Hello <%= $_[0] %>!', 'Bender');
render_file
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.
MOJO_TEMPLATE_DEBUG
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.