Mojolicious::Renderer

Section: User Contributed Perl Documentation (3)
Updated: 2018-11-22
Page Index
 

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 false. Note that this attribute is EXPERIMENTAL and might change without warning!  

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.  

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 {
    my ($renderer, $c, $output, $options) = @_;
    ...
    $$output = 'Hello World!';
  });

 

add_helper

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

Register a helper.

  $renderer->add_helper(foo => sub {
    my ($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, {
    template => 'foo/bar',
    foo      => 'bar'
  });

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. Note that this method is EXPERIMENTAL and might change without warning!  

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


 

Index

NAME
SYNOPSIS
DESCRIPTION
ATTRIBUTES
cache
classes
compress
default_format
default_handler
encoding
handlers
helpers
paths
METHODS
accepts
add_handler
add_helper
get_data_template
get_helper
render
respond
template_for
template_handler
template_name
template_path
warmup
SEE ALSO
LinuxReviews : manual page archive : man3pm