Mojolicious::Renderer − Generate dynamic content
use
Mojolicious::Renderer;
my $renderer = Mojolicious::Renderer−>new;
push @{$renderer−>classes},
'MyApp::Controller::Foo';
push @{$renderer−>paths},
'/home/sri/templates';
Mojolicious::Renderer is the standard Mojolicious renderer.
See Mojolicious::Guides::Rendering for more.
Mojolicious::Renderer implements the following attributes.
my $cache =
$renderer−>cache;
$renderer =
$renderer−>cache(Mojo::Cache−>new);
Renderer cache, defaults to a Mojo::Cache object.
my $classes =
$renderer−>classes;
$renderer = $renderer−>classes(['main']);
Classes to use for finding templates in "DATA" sections with Mojo::Loader, first one has the highest precedence, defaults to "main". Only files with exactly two extensions will be used, like "index.html.ep". Note that for templates to be detected, these classes need to have already been loaded and added before "warmup" is called, which usually happens automatically during application startup.
# Add another
class with templates in DATA section
push @{$renderer−>classes},
'Mojolicious::Plugin::Fun';
# Add another class with templates in DATA section and
higher precedence
unshift @{$renderer−>classes},
'Mojolicious::Plugin::MoreFun';
my $bool =
$renderer−>compress;
$renderer = $renderer−>compress($bool);
Try to negotiate compression for dynamically generated response content and "gzip" compress it automatically, defaults to true.
my $default =
$renderer−>default_format;
$renderer = $renderer−>default_format('html');
The default format to render if "format" is not set in the stash, defaults to "html". Note that changing the default away from "html" is not recommended, as it has the potential to break, for example, plugins with bundled templates.
my $default =
$renderer−>default_handler;
$renderer = $renderer−>default_handler('ep');
The default template handler to use for rendering in cases where auto-detection doesn’t work, like for "inline" templates.
my $encoding =
$renderer−>encoding;
$renderer =
$renderer−>encoding('koi8−r');
Will encode generated content if set, defaults to "UTF−8". Note that many renderers such as Mojolicious::Plugin::EPRenderer also use this value to determine if template files should be decoded before processing.
my $handlers =
$renderer−>handlers;
$renderer = $renderer−>handlers({epl => sub
{...}});
Registered handlers.
my $helpers =
$renderer−>helpers;
$renderer = $renderer−>helpers({url_for => sub
{...}});
Registered helpers.
my $size =
$renderer−>min_compress_size;
$renderer = $renderer−>min_compress_size(1024);
Minimum output size in bytes required for compression to be used if enabled, defaults to 860.
my $paths =
$renderer−>paths;
$renderer =
$renderer−>paths(['/home/sri/templates']);
Directories to look for templates in, first one has the highest precedence.
# Add another
"templates" directory
push @{$renderer−>paths}, '/home/sri/templates';
# Add another "templates" directory with higher
precedence
unshift @{$renderer−>paths},
'/home/sri/themes/blue/templates';
Mojolicious::Renderer inherits all methods from Mojo::Base and implements the following new ones.
my $all =
$renderer−>accepts(Mojolicious::Controller−>new);
my $best =
$renderer−>accepts(Mojolicious::Controller−>new,
'html', 'json');
Select best possible representation for Mojolicious::Controller object from "format" "GET"/"POST" parameter, "format" stash value, or "Accept" request header, defaults to returning the first extension if no preference could be detected.
$renderer = $renderer−>add_handler(epl => sub {...});
Register a handler.
$renderer−>add_handler(foo
=> sub ($renderer, $c, $output, $options) {
...
$$output = 'Hello World!';
});
$renderer = $renderer−>add_helper(url_for => sub {...});
Register a helper.
$renderer−>add_helper(foo
=> sub ($c, @args) {
...
});
my $template =
$renderer−>get_data_template({
template => 'foo/bar',
format => 'html',
handler => 'epl'
});
Return a "DATA" section template from "classes" for an options hash reference with "template", "format", "variant" and "handler" values, or "undef" if no template could be found, usually used by handlers.
my $helper = $renderer−>get_helper('url_for');
Get a helper by full name, generate a helper dynamically for a prefix, or return "undef" if no helper or prefix could be found. Generated helpers return a proxy object containing the current controller object and on which nested helpers can be called.
my ($output, $format) = $renderer−>render(Mojolicious::Controller−>new);
Render output through one of the renderers. See "render" in Mojolicious::Controller for a more user-friendly interface.
my $bool =
$renderer−>respond(Mojolicious::Controller−>new,
$output, $format);
my $bool = $renderer−>respond(
Mojolicious::Controller−>new, $output, $format,
$status);
Finalize dynamically generated response content and "compress" it if possible.
my $name = $renderer−>template_for(Mojolicious::Controller−>new);
Return default template name for Mojolicious::Controller object, or "undef" if no name could be generated.
my $handler =
$renderer−>template_handler({
template => 'foo/bar',
format => 'html'
});
Return handler for an options hash reference with "template", "format" and "variant" values, or "undef" if no handler could be found.
my $template =
$renderer−>template_name({
template => 'foo/bar',
format => 'html',
handler => 'epl'
});
Return a template name for an options hash reference with "template", "format", "variant" and "handler" values, or "undef" if no template could be found, usually used by handlers.
my $path =
$renderer−>template_path({
template => 'foo/bar',
format => 'html',
handler => 'epl'
});
Return the full template path for an options hash reference with "template", "format", "variant" and "handler" values, or "undef" if the file does not exist in "paths", usually used by handlers.
$renderer−>warmup;
Prepare templates from "classes" for future use.
Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.