File Coverage

blib/lib/App/ZofCMS/Template.pm

Criterion	Covered	Total	%
statement	12	151	7.9
branch	0	62	0.0
condition	0	27	0.0
subroutine	4	20	20.0
pod	1	14	7.1
total	17	274	6.2

package App::ZofCMS::Template;

use strict;
use warnings;

our $VERSION = '1.001006'; # VERSION

use HTML::Template;

require File::Spec;
use Carp;


sub new {
    my $class = shift;
    my $config = shift;
    my $self = bless {}, $class;
    $self->config( $config );
    $self->conf( $config->conf );
    $self->query( $config->query );

    return $self;
}

sub load {
    my $self = shift;

    my $conf = $self->conf;
    my $query = $self->query;

    my $template_file = File::Spec->catfile(
        $conf->{templates},
        $query->{dir},
        $query->{page} . $conf->{zcms_template_extension},
    );

    my $template = do $template_file
        or croak "Failed to load template file [$template_file] ($!) ($@)";

    return $self->template( $template );
}

sub prepare_defaults {
    my $self = shift;

    my $template = $self->template;
    my $conf = $self->conf;
    my $query = $self->query;

    my $dir_defaults = $conf->{dir_defaults}{ $query->{dir} } || {};

    %$template = ( %$dir_defaults, %$template );
    %$template = ( %{ $conf->{template_defaults} || {} }, %$template );

    %{ $template->{conf} } = (
        %{ $conf->{template_defaults}{conf} || {} },
        %{ $dir_defaults->{conf} || {} },
        %{ $template->{conf} || {} },
    );

    %{ $template->{t} } = (
        %{ $conf->{template_defaults}{t} || {} },
        %{ $dir_defaults->{t} || {} },
        %{ $template->{t} || {} },
    );

    %{ $template->{d} } = (
        %{ $conf->{template_defaults}{d} || {} },
        %{ $dir_defaults->{d} || {} },
        %{ $template->{d} || {} },
    );

    my @plug_keys = map /(\d+)/, grep /^plugins\d+$/,
        keys %$template,
        keys %{ $conf->{template_defaults} || {} },
        keys %$dir_defaults;

    my %unique_plug_keys;
    @unique_plug_keys{ @plug_keys } = ();
    @plug_keys = sort { $a <=> $b } keys %unique_plug_keys;

    unshift @plug_keys, ''; # add this for 'plugins' key that doesn't have a number
    $self->unique_plug_keys( \@plug_keys );

    for ( @plug_keys ) {
        $template->{ "plugins$_" }  = $self->sort_plugins(
            ( $conf->{template_defaults}{ "plugins$_" } || [] ),
            ( $dir_defaults->{ "plugins$_" } || [] ),
            ( $template->{ "plugins$_" } || [] ),
        );
    }
}

sub assemble {
    my $self = shift;

    my $template = $self->template;
    my $conf = $self->conf;
    my $query = $self->query;

    my $html_template = HTML::Template->new(
        filename => File::Spec->catfile(
            $conf->{data_store},
            $template->{conf}{base},
        ),
        die_on_bad_params => $template->{conf}{die_on_bad_params} || 0,
    );

    my $data_store = $conf->{data_store};

    $self->_exec_plugins;

    $html_template->param( %{ $template->{t} } );

    while ( my ($key, $value) = each %$template ) {
        next
            if $key eq 'conf'
                or $key eq 't'
                or $key eq 'plugins'
                or $key eq 'd';

        if ( ref $value eq 'SCALAR' ) {
            my $file = File::Spec->catfile( $data_store, $$value );
            if ( substr( $file, -5) eq '.tmpl' ) {
                my $sub_html_template
                = HTML::Template->new(
                    filename => $file,
                    die_on_bad_params
                    => $template->{conf}{die_on_bad_params} || 0,
                );

                $sub_html_template->param( %{ $template->{t} } );

                $html_template->param( $key => $sub_html_template->output );
            }
            else {
                open my $fh, '<', $file
                   or croak "Failed to open file [$file] for reading ($!)";

                $html_template->param( $key => do { local $/; <$fh>; } );
                close $fh;
            }
        }
        else {
            $html_template->param( $key => $value );
        }
    }

    return $self->html_template( $html_template );
}

sub execute_before {
    return shift->_execute('before');
}
sub execute {
    return shift->_execute;
}

sub _execute {
    my $self = shift;
    my $is_before = shift;
    my $template = $self->template;
    my $conf = $self->conf;
    my $query = $self->query;

    my $conf_key = $is_before ? 'exec_before' : 'exec';

    if ( ref $template->{conf}{ $conf_key } eq 'CODE' ) {
        return $template->{conf}{ $conf_key }->(
            $query,
            $self->template,
            $self->config,
            $self->html_template,
        );
    }
    elsif ( defined $template->{conf}{ $conf_key }
        and length $template->{conf}{ $conf_key }
    ) {
        my $package = 'App::ZofCMS::Execs::' . $template->{conf}{ $conf_key };
        eval "use $package;";
        $@ and croak "Failed to use() module specified by the template "
            . "[$package] Error: $@";

        return $package->new->execute(
            $query,
            $self->template,
            $self->config,
            $self->html_template,
        );
    }

    return 1;
}


sub _exec_plugins {
    my $self = shift;
    my $template = $self->template;
    my $query    = $self->query;
    my $config   = $self->config;

    for my $plug_key ( @{ $self->unique_plug_keys } ) {
        for ( @{ $template->{ "plugins$plug_key" } || [] } ) {
            my $plugin = "App::ZofCMS::Plugin::$_";
            eval "use $plugin";
            $@ and croak "Failed to use() plugin $plugin: $@";
            $plugin->new->process( $template, $query, $config );
        }
    }

    return;
}

sub sort_plugins {
    my $self = shift;
    my ( $conf_plugins, $dir_defaults_plugins, $template_plugins, ) = @_;

    for my $plugs (
        $template_plugins , $dir_defaults_plugins, $conf_plugins
    ) {

        for ( @$plugs ) {

            unless ( ref ) {
                $_ = { name => $_,  priority => 10000, };
                next;
            }

            @{ $_={} }{ qw/name priority/ } = %$_
                if ref eq 'HASH' and 1 == keys %$_;
        }
    }

    my $r  = [
        map $_->{name},
        sort {
            $a->{priority}
            <=>
            $b->{priority}
        }
        $self->uniq_plugins(
            @$template_plugins,
            @$dir_defaults_plugins,
            @$conf_plugins,
        )
    ];
    return $r;
}

sub uniq_plugins {
    my $self = shift;
    my %h;
    return map { $h{ $_->{name} }++ == 0 ? $_ : () } @_;
}


sub html_template {
    my $self = shift;
    if ( @_ ) {
        $self->{ html_template } = shift;
    }
    return $self->{ html_template };
}


sub template {
    my $self = shift;
    if ( @_ ) {
        $self->{ template } = shift;
    }
    return $self->{ template };
}


sub query {
    my $self = shift;
    if ( @_ ) {
        $self->{ query } = shift;
    }
    return $self->{ query };
}


sub config {
    my $self = shift;
    if ( @_ ) {
        $self->{ config } = shift;
    }
    return $self->{ config };
}


sub conf {
    my $self = shift;
    if ( @_ ) {
        $self->{ conf } = shift;
    }
    return $self->{ conf };
}


sub unique_plug_keys {
    my $self = shift;
    if ( @_ ) {
        $self->{UNIQUE_PLUG_KEYS} = shift;
    }
    return $self->{UNIQUE_PLUG_KEYS};
}

1;
__END__