Mojolicious::Renderer(User Contributed Perl DocumentaMojolicious::Renderer(3p)



NAME
       Mojolicious::Renderer - MIME Type Based Renderer

SYNOPSIS
         use Mojolicious::Renderer;

         my $renderer = Mojolicious::Renderer->new;

DESCRIPTION
       Mojolicious::Renderer is the standard Mojolicious renderer.  It turns
       your stashed data structures into content.  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, by default a Mojo::Cache object.  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.  The
       renderer will use Mojolicious::Types to look up the content MIME type.

   "default_handler"
         my $default = $renderer->default_handler;
         $renderer   = $renderer->default_handler('epl');

       The default template handler to use for rendering in cases where auto
       detection doesn't work, like for "inline" templates.

       epl
         "Embedded Perl Lite" handled by Mojolicious::Plugin::EplRenderer.

       ep
         "Embedded Perl" handled by Mojolicious::Plugin::EpRenderer.

   "default_template_class"
         my $default = $renderer->default_template_class;
         $renderer   = $renderer->default_template_class('main');

       The renderer will use this class to look for templates in the "DATA"
       section.

   "detect_templates"
         my $detect = $renderer->detect_templates;
         $renderer  = $renderer->detect_templates(1);

       Template auto detection, the renderer will try to select the right
       template and renderer automatically.

   "encoding"
         my $encoding = $renderer->encoding;
         $renderer    = $renderer->encoding('koi8-r');

       Will encode the content if set, defaults to "UTF-8".

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

   "layout_prefix"
         my $prefix = $renderer->layout_prefix;
         $renderer  = $renderer->layout_prefix('layouts');

       Directory to look for layouts in, defaults to "layouts".

   "root"
         my $root  = $renderer->root;
         $renderer = $renderer->root('/foo/bar/templates');

       Directory to look for templates in.

METHODS
       Mojolicious::Renderer inherits all methods from Mojo::Base and
       implements the following ones.

   "new"
         my $renderer = Mojolicious::Renderer->new;

       Construct a new renderer.

   "add_handler"
         $renderer = $renderer->add_handler(epl => sub {...});

       Add a new handler to the renderer.  See Mojolicious::Plugin::EpRenderer
       for a sample renderer.

   "add_helper"
         $renderer = $renderer->add_helper(url_for => sub {...});

       Add a new helper to the renderer.  See Mojolicious::Plugin::EpRenderer
       for sample helpers.

   "get_inline_template"
         my $template = $renderer->get_inline_template({
           template       => 'foo/bar',
           format         => 'html',
           handler        => 'epl'
           template_class => 'main'
         }, 'foo.html.ep');

       Get an inline template by name, usually used by handlers.

   "render"
         my ($output, $type) = $renderer->render($c);
         my ($output, $type) = $renderer->render($c, $args);

       Render output through one of the Mojo renderers.  This renderer
       requires some configuration, at the very least you will need to have a
       default "format" and a default "handler" as well as a "template" or
       "text"/"json".  See Mojolicious::Controller for a more user friendly
       interface.

   "template_name"
         my $template = $renderer->template_name({
           template => 'foo/bar',
           format   => 'html',
           handler  => 'epl'
         });

       Builds a template name based on an options hash with "template",
       "format" and "handler".

   "template_path"
         my $path = $renderer->template_path({
           template => 'foo/bar',
           format   => 'html',
           handler  => 'epl'
         });

       Builds a full template path based on an options hash with "template",
       "format" and "handler".

SEE ALSO
       Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.



perl v5.12.2                      2011-03-16         Mojolicious::Renderer(3p)
