File Coverage

blib/lib/DTL/Fast/Template.pm

Criterion	Covered	Total	%
statement	95	98	96.9
branch	17	20	85.0
condition	9	13	69.2
subroutine	14	14	100.0
pod	0	4	0.0
total	135	149	90.6

package DTL::Fast::Template;
use parent 'DTL::Fast::Parser';
use strict;
use utf8;
use warnings FATAL => 'all';

use DTL::Fast qw(get_template);
use DTL::Fast::Context;
use DTL::Fast::Tags;
use DTL::Fast::Filters;
use Scalar::Util qw/weaken/;

our $CURRENT_TEMPLATE;      # global variable for linking  modules
our $CURRENT_TEMPLATE_LINE; # global variable for source line number

#@Override
sub new
{
    my( $proto, $template, %kwargs ) = @_;
    $template //= '';

    $kwargs{'raw_chunks'} = _get_raw_chunks($template);
    $kwargs{'dirs'} //= [];             # optional dirs to look up for includes or parents
    $kwargs{'file_path'} //= 'inline';
    $kwargs{'perl'} = $];
    $kwargs{'blocks'} = {};
    $kwargs{'modules'} //= {
        'DTL::Fast' => $DTL::Fast::VERSION,
    };

    my $self = $proto->SUPER::new(%kwargs);

    return $self;
}

#@Override self-linking
sub remember_template
{
    my ($self) = @_;

    $self->{'_template'} = $self;
    $self->{'_template_line'} = 1;
    weaken $self->{'_template'};

    return $self;
}

#@Override
sub parse_chunks
{
    my( $self ) = @_;

    my( $current_template_backup, $current_template_line_backup ) = ($CURRENT_TEMPLATE, $CURRENT_TEMPLATE_LINE);
    ($CURRENT_TEMPLATE, $CURRENT_TEMPLATE_LINE) = ($self, 1);

    $self->SUPER::parse_chunks();

    ($CURRENT_TEMPLATE, $CURRENT_TEMPLATE_LINE) = ($current_template_backup, $current_template_line_backup);
    return $self;
}

my $reg = qr/(
     \{\#.+?\#\}
    |\{\%.+?\%\}
    |\{\{.+?\}\}
)/xs;

sub _get_raw_chunks
{
    my( $template ) = @_;

    my $result = [split $reg, $template];

    return $result;
}

#@Override
sub render
{
    my( $self, $context ) = @_;

    $context //= {};

    if( ref $context eq 'HASH' )
    {
        $context = DTL::Fast::Context->new($context);
    }
    elsif(
        defined $context
        and ref $context ne 'DTL::Fast::Context'
    )
    {
        die  "Context must be a DTL::Fast::Context object or a HASH reference";
    }

    $context->push_scope();

    $context->{'ns'}->[-1]->{'_dtl_ssi_dirs'} = $self->{'ssi_dirs'} if $self->{'ssi_dirs'};
    $context->{'ns'}->[-1]->{'_dtl_url_source'} = $self->{'url_source'} if $self->{'url_source'};

    my $template_path = $self->{'file_path'};

    if( not exists $context->{'ns'}->[-1]->{'_dtl_include_path'} )  # entry point
    {
        $context->{'ns'}->[-1]->{'_dtl_include_path'} = [];
        $context->{'ns'}->[-1]->{'_dtl_include_files'} = {};
    }
    else    # check for recursion, shouldn't this be in the include tag?
    {
        if( exists $context->{'ns'}->[-1]->{'_dtl_include_files'}->{$template_path} )
        {
            # recursive inclusion
            die sprintf("Recursive inclusion detected:\n%s\n"
                , join( "\n includes ", @{$context->{'ns'}->[-1]->{'_dtl_include_path'}}, $template_path)
            );
        }
    }

    $context->{'ns'}->[-1]->{'_dtl_include_files'}->{$template_path} = 1;
    push @{$context->{'ns'}->[-1]->{'_dtl_include_path'}}, $template_path;

    my $result;
    if ( $self->{'extends'} ) # has parent template
    {
        my @descendants = ();
        my $current_descendant = $self;
        my %inheritance = ();

        while( $current_descendant->{'extends'} )
        {
            push @descendants, $current_descendant;
            $inheritance{$current_descendant->{'file_path'}} = 1;

            my $parent_template_name = $current_descendant->{'extends'}->render($context);

            die sprintf(
                "Unable to resolve parent template name for %s"
                , $current_descendant->{'file_path'}
            ) if not $parent_template_name;

            $current_descendant = get_template(
                $parent_template_name
                , 'dirs' => $self->{'dirs'}
            );

            if ( defined $current_descendant )
            {
                if ( $inheritance{$current_descendant->{'file_path'}} )
                {
                    die  sprintf(
                        "Recursive inheritance detected:\n%s\n"
                        , join(
                            "\n inherited from ",
                            (map {$_->{'file_path'}} @descendants),
                            $current_descendant->{'file_path'}
                        )
                    );
                }
            }
            else
            {
                die  sprintf( "Couldn't found a parent template: %s in one of the following directories: %s"
                    , $parent_template_name
                    , join( ', ', @{$self->{'dirs'}})
                );
            }
        }

        push @descendants, $current_descendant;
        $context->{'ns'}->[-1]->{'_dtl_descendants'} = \@descendants;
        $context->{'ns'}->[-1]->{'_dtl_rendering_template'} = $current_descendant;
        $result = $current_descendant->SUPER::render($context);

    }
    else
    {
        delete $context->{'ns'}->[-1]->{'_dtl_descendants'};
        $context->{'ns'}->[-1]->{'_dtl_rendering_template'} = $self;
        $result = $self->SUPER::render($context);
    }

    pop @{$context->{'ns'}->[-1]->{'_dtl_include_path'}};
    delete $context->{'ns'}->[-1]->{'_dtl_include_files'}->{$template_path};

    $context->pop_scope();

    return $result;
}

1;