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

   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.

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

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