File Coverage

blib/lib/Template/Swig.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

package Template::Swig;

use strict;
use warnings;

use Carp;

our $VERSION = '0.05';

use File::Slurp qw(read_file);
use JavaScript::V8;
use JSON::XS;

sub new {

	my ($class, %params) = @_;

	my $self = bless {}, $class;

	$self->{context} = JavaScript::V8::Context->new();
	$self->{json} = JSON::XS->new->allow_nonref;
	$self->{json}->canonical(1); # Make sure that a given struct is always encoded the same way
	$self->{extends_callback} = $params{extends_callback};
	$self->{template_dir} = $params{template_dir};

	$self->{template_names} = {};

	$self->_load_swig;

	return $self;
}

sub _load_swig {

	my ($self) = @_;

	if ( my $cb = $self->{extends_callback} ) {
		$self->{context}->eval(<
			var fs = {
				readFileSync: function(file, encoding){
					return perl_callback(file, encoding);
				}
			};
EOT
		$self->{context}->bind('perl_callback' => sub {
			my ($filename, $encoding) = @_;
			my $template;
			my $error = do {
				local $@;
				eval {
					$filename = join('/',$self->{template_dir}, $filename) if $self->{template_dir};
					$template = $cb->($filename, $encoding);
				};
				$@;
			};
			carp $error if $error;
			return $template;
		});
	}

	local $/ = undef;
	my $swig_source = ;

	$self->{context}->eval($swig_source);
	confess $@ if $@;
}

sub compileFromFile {

	my ($self, $f) = @_;
	my $filename = ref($f) ? $f->{filename} : $f;
	$filename = join('/',$self->{template_dir}, $filename) if $self->{template_dir};
	if ( -e $filename ) {
		my $template = read_file($filename);
		$self->compile($f, $template);
	} else {
		die "Unable to locate $filename";
	}
}

sub compile {

	my ($self, $template_name, $template_string) = @_;

	die "need a template_string" unless $template_string;
	my $template_string_json = $self->{json}->encode($template_string);

	die "need a template_name" unless $template_name;
	my $template_name_json = $self->{json}->encode($template_name);

	if (ref $template_name) {
		$template_name_json =~ s/'/\\'/g;
		$template_name_json = "'$template_name_json'";
	}

	$self->{context}->eval(<
	var template_string = $template_string_json;
	var template = swig.compile(template_string, { filename: $template_name_json });
	templates[$template_name_json] = template;

	false;
EOT
	confess $@ if $@;

	$self->{is_compiled}{$template_name_json} = 1;
}

sub render {

	my ($self, $template_name, $data) = @_;

	die "need a template_name" unless $template_name;
	my $template_name_json = $self->{json}->encode($template_name);
	if (ref $template_name) {
		$template_name_json =~ s/'/\\'/g;
		$template_name_json = "'$template_name_json'";
	}

	die "couldn't find template: $template_name" unless $self->{is_compiled}{$template_name_json};

	my $data_json = $self->{json}->encode($data);

	my $output = $self->{context}->eval(<
	var output = templates[$template_name_json]($data_json);

	output;
EOT
	confess $@ if $@;
	return $output;
}

1;

=pod

=head1 NAME

Template::Swig - Perl interface to Django-inspired Swig templating engine.

=head1 SYNOPSIS

  my $swig = Template::Swig->new;

  # Compile and render an inline template:
  $swig->compile('message', 'Welcome, {{name}}');
  my $output = $swig->render('message', { name => 'Arthur' });

  # Compile and render a file:
  $swig->compileFromFile('path/to/file.html');
  my $output = $swig->render('path/to/file.html', { some_param => 'foo' });

=head1 DESCRIPTION

Template::Swig uses L and L templating engine to provide fast Django-inspired templating in a Perl context.  Templates are compiled to JavaScript functions and stored in memory, then executed each time they're rendered.

Swig's feature list includes multiple inheritance, formatter and helper functions, macros, auto-escaping, and custom tags.  See the L for more.

=head1 METHODS

=head2 new( template_dir => $path, extends_callback => sub { } )

Initialize a swig instance, given the following parameters

=head3 template_dir

Optional path where templates live

=head3 extends_callback

Optional callback to be run when Swig encounters an extends tag; receives filename and its encoding as parameters

=head2 compile($template_name, $swig_source)

Compile a template given, given a template name and swig template source as a string.

=head2 compileFromFile($f)

Will compile a file from the filesystem. C<$f> may be either a scalar filename,
or a reference to a hash with at least one key, C.

=head2 compile($string)

Will compile data supplied in the scalar C<$string>.

=head2 render($template_name, $data)

Render a template, given a name and a reference to a hash of data to interpolate.

=head1 TEMPLATE EXAMPLES

Iterate through a list:

  {% for image in images %}

  {% else %}
      No images to show
  {% endfor %}

Custom helpers / filters:

  {{ created|date('r') }}

=head3 Inheritance:

In main.html:

  {% block 'greeting' %}
      Hi, there.
  {% endblock %}

In custom.html:

  {% extends 'main.html' %}

  {% block 'greeting' %}
      Welcome, {{ name }}
  {% endblock %}

=head1 SEE ALSO

L, L, L

=head1 COPYRIGHT AND LICENSE

Copyright (c) 2012, David Chester

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

=cut

__DATA__