MojoX::Renderer::TT - Template Toolkit renderer for Mojo

    sub startup {
        ...

        # Via mojolicious plugin
        $self->plugin(tt_renderer => {template_options => {FILTERS => [ ... ]}});

        # Or manually
        use MojoX::Renderer::TT;

        my $tt = MojoX::Renderer::TT->build(
            mojo => $self,
            template_options => {
                PROCESS  => 'tpl/wrapper',
                FILTERS  => [ ... ],
                UNICODE  => 1,
                ENCODING => 'UTF-8',
            }
        );

        $self->renderer->add_handler( tt => $tt );
    }

    __DATA__

    @@ welcome.html.tt
    Welcome, [% user.name %]!

    $self->render(inline => '[% 1 + 1 %]', handler => 'tt');

    [% h.url_for('index') %]

   * Better support non-Mojolicious frameworks
   * Move the default template cache directory?
   * Better way to pass parameters to the templates? (stash)
   * More sophisticated default search path?

    perldoc MojoX::Renderer::TT

package MojoX::Renderer::TT;
BEGIN {
  $MojoX::Renderer::TT::VERSION = '1.13';
}

use warnings;
use strict;

use base 'Mojo::Base';

use File::Spec ();
use Mojo::ByteStream 'b';
use Template ();
use Cwd qw/abs_path/;

__PACKAGE__->attr('tt');

sub build {
    my $self = shift->SUPER::new(@_);
    $self->_init(@_);
    return sub { $self->_render(@_) }
}

sub _init {
    my $self = shift;
    my %args = @_;

    #$Template::Parser::DEBUG = 1;

    my $app = delete $args{mojo} || delete $args{app};

    my $dir = $app && $app->home->rel_dir('tmp/ctpl');

    # TODO
    #   take and process options :-)

    my %config = (
        ($app ? (INCLUDE_PATH => abs_path($app->home->rel_dir('templates'))) : ()),
        COMPILE_EXT => '.ttc',
        COMPILE_DIR => ($dir || abs_path(File::Spec->tmpdir)),
        UNICODE     => 1,
        ENCODING    => 'utf-8',
        CACHE_SIZE  => 128,
        RELATIVE    => 1,
        %{$args{template_options} || {}},
    );

    $config{LOAD_TEMPLATES} =
      [MojoX::Renderer::TT::Provider->new(%config, renderer => $app->renderer)]
      unless $config{LOAD_TEMPLATES};

    $self->tt(Template->new(\%config))
      or Carp::croak "Could not initialize Template object: $Template::ERROR";

    return $self;
}

sub _render {
    my ($self, $renderer, $c, $output, $options) = @_;

    # Inline
    my $inline = $options->{inline};

    # Template
    my $t = $renderer->template_name($options);
    $t = 'inline' if defined $inline;
    return unless $t;


    my $helper = MojoX::Renderer::TT::Helper->new(ctx => $c);

    # Purge previous result
    $$output = '';

    my @params = ({%{$c->stash}, c => $c, h => $helper}, $output, {binmode => ':utf8'});
    $self->tt->{SERVICE}->{CONTEXT}->{LOAD_TEMPLATES}->[0]->ctx($c);

    my $ok = $self->tt->process(defined $inline ? \$inline : $t, @params);

    # Error
    unless ($ok) {

        my $e = Mojo::Exception->new(
            $self->tt->error.'',
            $self->tt->service->process(defined $inline ? \$inline : $t));
        $$output = '';
        $c->app->log->error(qq/Template error in "$t": $e/);
        $c->render_exception($e);
        $self->tt->error('');
        return 0;
    }

    return 1;
}

1;    # End of MojoX::Renderer::TT

package
  MojoX::Renderer::TT::Helper;

use strict;
use warnings;

use base 'Mojo::Base';

our $AUTOLOAD;

__PACKAGE__->attr('ctx');

sub AUTOLOAD {
    my $self = shift;

    my $method = $AUTOLOAD;

    return if $method =~ /^[A-Z]+?$/;
    return if $method =~ /^_/;
    return if $method =~ /(?:\:*?)DESTROY$/;

    $method = (split '::' => $method)[-1];

    die qq/Unknown helper: $method/ unless $self->ctx->app->renderer->helpers->{$method};

    return $self->ctx->$method(@_);
}

1;

package
  MojoX::Renderer::TT::Provider;

use strict;
use warnings;

use base 'Template::Provider';

sub new {
    my $class = shift;
    my %params = @_;

    my $renderer = delete $params{renderer};

    my $self = $class->SUPER::new(%params);
    $self->renderer($renderer);
    return $self;
}

sub renderer      { @_ > 1 ? $_[0]->{renderer}      = $_[1] : $_[0]->{renderer} }
sub ctx           { @_ > 1 ? $_[0]->{ctx}           = $_[1] : $_[0]->{ctx} }

sub _template_modified {1}

sub _template_content {
    my $self = shift;
    my ($path) = @_;

    # Convert backslashes to forward slashes to make inline templates work on Windows
    $path =~ s/\\/\//g;
    my ($t) = ($path =~ m{templates\/(.*)$});

    if (-r $path) {
        return $self->SUPER::_template_content(@_);
    }

    # Try DATA section
    elsif (my $d = $self->renderer->get_data_template($self->ctx, $t)) {
        return wantarray ? ($d, '', time) : $d;
    }

    my $data = '';
    my $error = "$path: not found";
    my $mod_date = time;
    return wantarray ? ($data, $error, $mod_date) : $data;
}

1;

__END__