Data::Template - Generate data structures from templates

Data-Template documentation Contained in the Data-Template distribution.

Index

Code Index:

NAME

Top

Data::Template - Generate data structures from templates

SYNOPSIS

Top

    use Data::Template;

    $dt = Data::Template->new();
    $tt = {
        who => 'me',
        to => '${a}',
        subject => 'Important - trust me',
        body => <<'BODY',

            When I was ${b}, I realized that
            I had not ${c}. Do you?
    BODY
    };
    $data = $dt->process($tt, { a => 'someone', b => 'somewhere', c => '100$' });

DESCRIPTION

Top

Templates usually convert text templates to text. This module goes further by converting data structure templates to data structures.

Beyond that, nothing new. I am lazy and the Template Toolkit is here today - so I use it.

The current implementation handles hash refs, array refs and non-ref scalars (strings). The processing rules are:

(The implementation so far is so naïve that causes laughs. But laughing may be good.)

FUNCTIONS

new

A constructor. Wow!

process
    $data = $dt->process($tt, $vars)

Process the templates generating a new data structure. It dies on errors (or not - see constructor parameters to come soon).

process_s

For processing a scalar.

process_a

For processing an array.

process_h

For processing a hash.

EXAMPLES

Top

Soon.

SEE ALSO

Top

Template - as this is used to process the text templates.

Please reports bugs via CPAN RT, http://rt.cpan.org/NoAuth/Bugs.html?Dist=Data-Template

AUTHOR

Top

A. R. Ferreira, <ferreira@cpan.org>

COPYRIGHT AND LICENSE

Top

Copyright (C) 2006-2007 by A. R. Ferreira

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

Data-Template documentation Contained in the Data-Template distribution. 
package Data::Template;

use strict;
use warnings;

our $VERSION = '0.0005';

use base qw(Class::Accessor);
Data::Template->mk_accessors(qw(engine prefix));

use Template;

sub new {
    my $self = shift;
    my $TT = Template->new(INTERPOLATE => 1);
#    return $self->SUPER::new({engine => $TT, prefix => '=', @_});
    return $self->SUPER::new({engine => $TT, @_});
}

sub process {
    my $self = shift;
    my $tt = shift;
    my $vars = shift;

    if (!ref $tt) {
        return $self->process_s($tt, $vars);
    } elsif (ref $tt eq 'ARRAY') {
        return $self->process_a($tt, $vars);
    } elsif (ref $tt eq 'HASH') {
        return $self->process_h($tt, $vars);
    } else {
        die 'burp'
    }
}

sub process_h {
    my $self = shift;
    my $h = shift;
    my $vars = shift;

    my %ph = ();
    while (my ($k, $v) = each %$h) {
        $k = $self->process_s($k, $vars);
        $v = $self->process($v, $vars);
        $ph{$k} = $v;
    }
    return \%ph;
}

sub process_a {
    my $self = shift;
    my $a = shift;
    my $vars = shift;

    my @pa;
    foreach (@$a) {
        push @pa, $self->process($_, $vars);
    }
    return \@pa;
}


sub _split_scalar {
    my $self = shift;
    my $s = shift;
    my $prefix = $self->prefix;
    if ($prefix) {
        if ($s =~ s/^\Q$prefix\E//) { # it is a template
            return (undef, $s);
        } else {
            $s =~ s/^\\(\Q$prefix\E)/$1/; # chomp the leading escape
            return ($s, undef);
        }
    }
    # by now everything else looks like a template
    return (undef, $s);
}

sub process_s {
    my $self = shift;
    my $s = shift;
    my $vars = shift;

    my ($p, $t) = $self->_split_scalar($s);
    return $p if defined $p;

    my $ps;
    $self->engine->process(\$t, $vars, \$ps)
        or die $self->engine->error();
    return $ps;
 

}

1;

__END__