Mojolicious::Renderer(3)

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 these classes need to have already been loaded and added during application startup for templates to be detected.

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

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

  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, by default only "data", "text" and "json" are already defined.

  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 "Accept" request header, "format" stash value or "format" "GET"/"POST" parameter, defaults to returning the first extension if no preference could be detected. Since browsers often don't really know what they actually want, unspecific "Accept" request headers with more than one MIME type will be ignored, unless the "X-Requested-With" header is set to the value "XMLHttpRequest".

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

Register a new handler.

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

Register a new helper.

  get_data_template
  my $template = $renderer->get_data_template({
    template       => 'foo/bar',
    format         => 'html',
    handler        => 'epl'
  });

Get a "DATA" section template by name, 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.

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

Generate default template name for Mojolicious::Controller object.

  template_handler
  my $handler = $renderer->template_handler({
    template => 'foo/bar',
    format   => 'html'
  });

Detect handler based on an options hash reference with "template" and "format".

  template_name
  my $template = $renderer->template_name({
    template => 'foo/bar',
    format   => 'html',
    handler  => 'epl'
  });

Builds a template name based on an options hash reference with "template", "format" and "handler", usually used by handlers.

  template_path
  my $path = $renderer->template_path({
    template => 'foo/bar',
    format   => 'html',
    handler  => 'epl'
  });

Builds a full template path based on an options hash reference with "template", "format" and "handler", usually used by handlers.

SEE ALSO
Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.