File Coverage

blib/lib/Dancer2/Template/TextTemplate/FakeEngine.pm

Criterion	Covered	Total	%
statement	62	63	98.4
branch	26	32	81.2
condition	11	18	61.1
subroutine	15	15	100.0
pod	1	1	100.0
total	115	129	89.1

package Dancer2::Template::TextTemplate::FakeEngine;
# ABSTRACT: Fake Template::Toolkit-like, persistent engine around Text::Template.

use strict;
use warnings;

our $VERSION = '1.002'; # TRIAL VERSION

use Moo;
use MooX::Types::MooseLike::Base qw( InstanceOf Bool ArrayRef Int Str );
use Carp 'croak';
use Text::Template 1.46;
use CHI;
use Safe 2.26;
use Scalar::Util 'blessed';
use namespace::clean;



has _cache => (
    is      => 'rwp',
    isa     => InstanceOf['CHI::Driver'],
    lazy    => 1,
    builder => '_build_cache',
);

sub _build_cache {
    my $self = shift;
    return CHI->new(
        driver             => 'Memory',    # THIS should be generalized
        expires_on_backend => 1,
        global             => 1,           # CHI::Driver::Memory-specific
    );
}


has caching => (
    is      => 'rw',
    isa     => Bool,
    default => 1,
);


has expires => (
    is      => 'rw',
    isa     => Int,
    default => 3600,
);


has delimiters => (
    is      => 'rw',
    isa     => ArrayRef[Str],
    default => sub { [ '{', '}' ] },
);


has cache_stringrefs => (
    is      => 'rw',
    isa     => Bool,
    default => 1,
);


has prepend => (
    is => 'rw',
    isa => Str,
    default => <<'END',
        use strict;
        use warnings FATAL => 'all';
END
);

# Text::Template's HASH variables (as exclusively used by FakeEngine) are not
# installed in the template evaluation package in a "use strict"-compatible
# way, but we enforce "use strict" in PREPEND, so we need to declare ourselves
# these variables just after the PREPENDed code.
sub _declare_arg_variables {
    my $hash = shift;
    my @decls;
    while ( my ( $name, $value ) = each %$hash ) {
        next unless defined $value;
        push @decls, do {
            if    ( ref $value eq 'ARRAY' ) { '@' }
            elsif ( ref $value eq 'HASH' )  { '%' }
            else                            { '$' }
          }
          . $name;
    }
    return join "\n" => map { "our $_;" } @decls;
}


has safe => (
    is      => 'rw',
    isa     => Bool,
    default => 1,
);

has safe_opcodes => (
    is      => 'rw',
    isa     => ArrayRef[Str],
    default => sub { [qw[ :default require caller dofile ]] },
    trigger => sub {
        my $self = shift;
        $self->_safe->permit_only(@{ $_[0] });
    },
);

has safe_disposable => (
    is      => 'rw',
    isa     => Bool,
    default => 0,
    trigger => sub {
        my $self = shift;
        $self->_rebuild_safe if $_[0];
    },
);

has _safe => (
    is      => 'rw',
    isa     => InstanceOf['Safe'],
    lazy    => 1,
    builder => '_build_safe',
);

sub _build_safe {
    my $self = shift;
    my $safe = Safe->new;
    $safe->permit_only(@{ $self->safe_opcodes });
    return $safe;
}

sub _rebuild_safe {
    my $self = shift;
    $self->_safe($self->_build_safe) if $self->safe_disposable;
    return;
}


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

    defined $template
      && !blessed($template)
      && ( ref $template || -f $template )
      or croak "$template is not a regular file (name) or a string reference";

    my $tt = $self->caching
      ? $self->_cache->get( ref $template ? $$template : $template )
      : undef;
    unless ($tt) {    # either we don't cache or the cached instance expired
        $tt = Text::Template->new(
            TYPE   => ref $template ? 'STRING'   : 'FILE',
            SOURCE => ref $template ? $$template : $template,
            DELIMITERS => $self->delimiters,
        );
    }

    my $computed = $tt->fill_in(
        HASH    => $tokens,
        PREPEND => $self->prepend . _declare_arg_variables($tokens),
        $self->safe ? ( SAFE => $self->_safe ) : (),
    ) or our $ERROR = $Text::Template::ERROR;

    $self->_rebuild_safe if $self->safe && $self->safe_disposable;

    if ( defined $computed && $self->caching ) {
        if ( ref $template && $self->cache_stringrefs ) {
            $self->_cache->set( $$template, $tt, 'never' );
        }
        else {                    # filenames
            $self->_cache->set( $template, $tt,
                $self->expires > 0
                ? { expires_in => $self->expires }
                : 'never' );
        }
    }

    return $computed;
}

1;

__END__