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

   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.

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

   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, <http://mojolicious.org>.