File Coverage

blib/lib/Plack/Middleware/TMT.pm

Criterion	Covered	Total	%
statement	68	70	97.1
branch	18	24	75.0
condition	7	11	63.6
subroutine	16	17	94.1
pod	3	3	100.0
total	112	125	89.6

package Plack::Middleware::TMT;
use strict;
use warnings;
BEGIN {
  $Plack::Middleware::TMT::VERSION = '0.04';
}
use Carp qw/croak/;
use parent 'Plack::Middleware';
use Text::MicroTemplate::File;
use Plack::Request;
use Data::Dumper;
use Plack::Util::Accessor qw/
    tmt
    include_path default_tmpl tmpl_extension
    use_cache
    content_type default_content_type
    macro package_name
    pass_through
/;

sub prepare_app {
    my $self = shift;

    $self->default_tmpl('index') if !$self->default_tmpl;
    $self->default_content_type('text/html') if !$self->default_content_type;
    $self->pass_through(0) if !$self->pass_through;

    $self->tmt(
        Text::MicroTemplate::File->new(
            include_path => $self->include_path,
            use_cache    => $self->use_cache,
            package_name => $self->package_name,
        )
    );

    $self->macro(+{}) if !$self->macro;
    warn 'macro "d" is reserved. it works as dumper.' if $self->macro->{d};
    $self->macro->{d} = sub {
        local $Data::Dumper::Terse    = 1;
        local $Data::Dumper::Indent   = 1;
        local $Data::Dumper::Sortkeys = 1;
        Data::Dumper::Dumper(shift);
    };

    for my $name (keys %{ $self->macro }) {
        unless ($name =~ /^[a-zA-Z_][a-zA-Z0-9_]*$/) {
            croak qq{Invalid macro key name: "$name"};
        }
        no strict 'refs'; ## no critic
        no warnings 'redefine';
        my $code = $self->{macro}{$name};
        *{ $self->tmt->package_name . "::$name" }
            = ref $code eq 'CODE' ? $code : sub {$code};
    }
}

sub call {
    my ( $self, $env ) = @_;

    my $res = $self->_handle_template($env);

    if ( $res && not( $self->pass_through and $res->[0] == 404 ) ) {
        return $res;
    }
    if ( $self->app ) {
        $res = $self->app->($env);
    }

    $res;
}

sub _handle_template {
    my ($self, $env) = @_;

    my $req = Plack::Request->new($env);

    my $tmpl = $req->path eq '/'
             ? $self->default_tmpl
             : $req->path =~ m!/$!
             ? $req->path. $self->default_tmpl
             : $req->path;
    $tmpl =~ s!^/!!;

    my $ext = $self->tmpl_extension || '';

    if (!-e $self->include_path. '/'. "$tmpl$ext") {
        return [404, ['Content-Type' => 'text/plain'], ['Not Found']];
    }

    $self->process_template(
        "$tmpl$ext",
        200,
        $req,
    );
}

sub process_template {
    my ( $self, $template, $status_code, $vars ) = @_;

    my $content_type = $self->content_type || $self->default_content_type;
    my $content = $self->tmt->render_file($template, $vars)->as_string;

    return [ $status_code, [ 'Content-Type' => $content_type ], [$content] ];
}

1;

__END__