The Perl and Raku Conference 2025: Greenville, South Carolina - June 27-29 Learn more

 / 
Mojolicious-9.39
River stage four • 1014 direct dependents • 1136 total dependents
/ Mojolicious::Renderer

NAME

Mojolicious::Renderer - Generate dynamic content

SYNOPSIS


            

              
              
use Mojolicious::Renderer;
my $renderer = Mojolicious::Renderer->new;
push @{$renderer->classes}, 'MyApp::Controller::Foo';
push @{$renderer->paths}, '/home/sri/templates';

DESCRIPTION

Mojolicious::Renderer is the standard Mojolicious renderer.

See Mojolicious::Guides::Rendering for more.

ATTRIBUTES

Mojolicious::Renderer implements the following attributes.

cache


            

              
              
my $cache = $renderer->cache;
$renderer = $renderer->cache(Mojo::Cache->new);

Renderer cache, defaults to a Mojo::Cache object.

classes


            

              
              
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';

compress


            

              
              
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.

default_format


            

              
              
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.

default_handler


            

              
              
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.

encoding


            

              
              
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.

handlers


            

              
              
my $handlers = $renderer->handlers;
$renderer    = $renderer->handlers({epl => sub {...}});

Registered handlers.

helpers


            

              
              
my $helpers = $renderer->helpers;
$renderer   = $renderer->helpers({url_for => sub {...}});

Registered helpers.

min_compress_size


            

              
              
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.

paths


            

              
              
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';

METHODS

Mojolicious::Renderer inherits all methods from Mojo::Base and implements the following new ones.

accepts


            

              
              
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.

add_handler


            

              
              
$renderer = $renderer->add_handler(epl => sub {...});

Register a handler.


            

              
              
$renderer->add_handler(foo => sub ($renderer, $c, $output, $options) {
  ...
  $$output = 'Hello World!';
});

add_helper


            

              
              
$renderer = $renderer->add_helper(url_for => sub {...});

Register a helper.


            

              
              
$renderer->add_helper(foo => sub ($c, @args) {
  ...
});

get_data_template


            

              
              
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.

get_helper


            

              
              
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.

render


            

              
              
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.

respond


            

              
              
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.

template_for


            

              
              
my $name = $renderer->template_for(Mojolicious::Controller->new);

Return default template name for Mojolicious::Controller object, or undef if no name could be generated.

template_handler


            

              
              
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.

template_name


            

              
              
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.

template_path


            

              
              
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.

warmup


            

              
              
$renderer->warmup;

Prepare templates from "classes" for future use.

SEE ALSO

Mojolicious, Mojolicious::Guides, https://mojolicious.org.