focal (3) Mojolicious::Renderer.3pm.gz

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.

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

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