File Coverage

blib/lib/Text/Handlebars.pm

Criterion	Covered	Total	%
statement	83	83	100.0
branch	8	8	100.0
condition	2	3	66.6
subroutine	21	21	100.0
pod	2	6	33.3
total	116	121	95.8

package Text::Handlebars;
BEGIN {
  $Text::Handlebars::AUTHORITY = 'cpan:DOY';
}
$Text::Handlebars::VERSION = '0.04';
use strict;
use warnings;
# ABSTRACT: http://handlebarsjs.com/ for Text::Xslate

use Text::Xslate 2.0000;
use base 'Text::Xslate';

use Scalar::Util 'weaken';
use Try::Tiny;


sub default_helpers {
    my $class = shift;
    return {
        with => sub {
            my ($context, $new_context, $options) = @_;
            return $options->{fn}->($new_context);
        },
        each => sub {
            my ($context, $list, $options) = @_;
            return join '', map { $options->{fn}->($_) } @$list;
        },
        if => sub {
            my ($context, $conditional, $options) = @_;
            return $conditional
                ? $options->{fn}->($context)
                : $options->{inverse}->($context);
        },
        unless => sub {
            my ($context, $conditional, $options) = @_;
            return $conditional
                ? $options->{inverse}->($context)
                : $options->{fn}->($context);
        },
    };
}

sub default_functions {
    my $class = shift;
    return {
        %{ $class->SUPER::default_functions(@_) },
        %{ $class->default_helpers },
    };
}

sub options {
    my $class = shift;

    my $options = $class->SUPER::options(@_);

    $options->{compiler} = 'Text::Handlebars::Compiler';
    $options->{helpers} = {};

    return $options;
}

sub _register_builtin_methods {
    my $self = shift;
    my ($funcs) = @_;

    weaken(my $weakself = $self);
    $funcs->{'(render_string)'} = sub {
        my ($to_render, $vars) = @_;
        return $weakself->render_string($to_render, $vars);
    };
    $funcs->{'(make_block_helper)'} = sub {
        my ($vars, $code, $raw_text, $else_raw_text, $hash) = @_;

        my $options = {};
        $options->{fn} = sub {
            my ($new_vars) = @_;
            $new_vars = {
                %{ canonicalize_vars($new_vars) },
                '..' => $vars,
            };
            return $weakself->render_string($raw_text, $new_vars);
        };
        $options->{inverse} = sub {
            my ($new_vars) = @_;
            $new_vars = {
                %{ canonicalize_vars($new_vars) },
                '..' => $vars,
            };
            return $weakself->render_string($else_raw_text, $new_vars);
        };
        $options->{hash} = $hash;

        return sub { $code->(@_, $options); };
    };

    for my $helper (keys %{ $self->{helpers} }) {
        $funcs->{$helper} = $self->{helpers}{$helper};
    }
}

sub _compiler {
    my $self = shift;

    if (!ref($self->{compiler})) {
        my $compiler = $self->SUPER::_compiler(@_);
        $compiler->define_helper(keys %{ $self->{helpers} });
        $compiler->define_helper(keys %{ $self->default_helpers });
        return $compiler;
    }
    else {
        return $self->SUPER::_compiler(@_);
    }
}

sub render_string {
    my $self = shift;
    my ($string, $vars) = @_;

    return $self->SUPER::render_string($string, canonicalize_vars($vars));
}

sub render {
    my $self = shift;
    my ($name, $vars) = @_;

    return $self->SUPER::render($name, canonicalize_vars($vars));
}

sub canonicalize_vars {
    my ($vars) = @_;
    if (ref($vars) && ref($vars) eq 'HASH') {
        return $vars;
    }
    else {
        return { '.' => $vars };
    }
}


1;

__END__