File Coverage

blib/lib/Dancer/Template/TemplateSandbox.pm

Criterion	Covered	Total	%
statement	34	52	65.3
branch	10	30	33.3
condition	2	5	40.0
subroutine	7	7	100.0
pod	2	2	100.0
total	55	96	57.2

package Dancer::Template::TemplateSandbox;

use strict;
use warnings;
use Dancer::Config 'setting';
use Dancer::FileUtils 'path';

use base 'Dancer::Template::Abstract';

our $VERSION = '1.00';

my %_template_config;

sub init
{
    my ( $self ) = @_;

    die "Template::Sandbox is needed by Dancer::Template::TemplateSandbox"
        unless Dancer::ModuleLoader->load( 'Template::Sandbox' );

    %_template_config = (
        open_delimiter          => '<%',
        close_delimiter         => '%>',
        template_toolkit_compat => 1,
        %{$self->config},
        );

    $_template_config{ template_root } = setting( 'views' )
        if setting( 'views' );


    if( $_template_config{ cache } )
    {
        my ( $cache_type, $cache_dir );

        $cache_dir = delete $_template_config{ cache_dir }
            if $_template_config{ cache_dir };
        $cache_type = delete $_template_config{ cache_type }
            if $_template_config{ cache_type };
        $cache_type ||= 'memory';

        if( $_template_config{ cache } eq 'cache_factory' )
        {
            my ( %options );

            die "Unable to load chosen template caching module: " .
                "Cache::CacheFactory"
                unless Dancer::ModuleLoader->load( 'Cache::CacheFactory' );

            if( $cache_type eq 'file' )
            {
                %options = (
                    storage    => { 'file' => { cache_root => $cache_dir, }, },
                    );
            }
            else
            {
                %options = (
                    storage    => { $cache_type => {}, },
                    );
            }

            $_template_config{ cache } = Cache::CacheFactory->new( %options );
        }
        elsif( $_template_config{ cache } eq 'chi' )
        {
            my ( %options );

            die "Unable to load chosen template caching module: CHI"
                unless Dancer::ModuleLoader->load( 'CHI' );

            if( $cache_type eq 'file' )
            {
                %options = (
                    driver   => 'File',
                    root_dir => $cache_dir,
                    );
            }
            else
            {
                %options = (
                    driver => Dancer::ModuleLoader->class_from_setting(
                        $cache_type ),
                    );
            }

            $_template_config{ cache } = CHI->new( %options );
        }
        else
        {
            die "Unknown template caching module: $_template_config{ cache }";
        }
    }
}

sub render($$$)
{
    my ( $self, $template, $tokens ) = @_;
    my ( $ts );

    die "'$template' is not a regular file"
      if !ref($template) && (!-f $template);

    $ts = Template::Sandbox->new( %_template_config );
    $ts->add_vars( $tokens );

    if( ref( $template ) )
    {
        $ts->set_template_string( ${$template} );
    }
    else
    {
        $template =~ s~^\Q$_template_config{template_root}/\E~~
            if $_template_config{ template_root };
        $ts->set_template( $template );
    }

    my $contentref = $ts->run();
    return( $contentref ? ${$contentref} : undef );
}

1;
__END__