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