Template Toolkit Cache

[avo]

Hi, I am using some templates that I keep in my program instead of a file (using process with a ref to my scalar). Is there a way I can catch a compiled cache version of the template and store it for further use instead of processing every time. My processing time is quite expensive. I know TT2 does that in a file with extension provided by me (COMPILE_EXT) when I am using file instead. Thanks for your help.

[LanX]

Can't answer this for TT2, but If you are looking for maximum speed you may want to consider HTML::Template::Compiled

[ikegami]

I just had a peek at the source. The relevant code is in Template::Provider. The compiled template cache code is highly dependent on the presence of a file name.

Your best bet might be to subclass Template::Provider, overriding _template_modified($path) and _template_content($path) to fetch the template from memory instead of fetching the template from disk. That will allow you to use a file name to fetch the template (albeit to a virtual file), which will allow TT2 to cache the compiled template.

Update: Subclassing would look something like:

use strict;
use warnings;


BEGIN {
   package Template::Provider::Memory;

   use Template::Provider qw( );

   BEGIN { our @ISA = 'Template::Provider'; }

   sub _init {
      my ($self, $params) = @_;
      $self->{ MEM_DRIVE } = $params->{ MEM_DRIVE };
      $self->SUPER::_init($params);
   }

   sub _template_modified {
      my ($self, $path) = @_;
      if (!exists( $self->{ MEM_DRIVE }{ $path } )) {
         return undef;
      }

      return $self->{ MEM_DRIVE }{ $path }[0];
   }

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

      my $data;
      my $mod_date;
      my $error;

      if (exists( $self->{ MEM_DRIVE }{ $path } )) {
         $mod_date = $self->{ MEM_DRIVE }{ $path }[0];
         $data     = $self->{ MEM_DRIVE }{ $path }[1];
      } else {
         $error = "$path: Not found";
      }

      return (wantarray
         ? ( $data, $error, $mod_date )
         : $data
      );
   }

   $INC{'Template/Provider/Memory.pm'} = 1;
}


use Template                   qw( );
use Template::Provider::Memory qw( );

my %mem_drive = (
   'index.tt2' => [ time(), 'Hello World!' ],
);

my $tt = Template->new({
   LOAD_TEMPLATES => [
      Template::Provider::Memory->new({ MEM_DRIVE => \%mem_drive }),
      Template::Provider->new(),
   ],
   COMPILE_DIR => '/tmp/ttc',
   COMPILE_EXT => '.ttc',
});

$tt->process('index.tt2')
   or die($tt->error(), "\n");

That was tough to decipher! Runs, but it doesn't create the compiled file.

[Anonymous Monk]

Is there a way I can catch a compiled cache version of the template and store it for further use instead of processing every time.
Simples solution is create the files if they don't exist, so you only have to do it once.

Or you could try Template::Provider::MD5.

[wrinkles]

I can't answer your question directly but here are two other good Template resources:

http://template-toolkit.org/docs/manual/Config.html#section_Caching_and_Compiling_Options

http://mail.template-toolkit.org/mailman/listinfo/templates