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