++ed by:
KEEDI ADAMJS PERLANCAR KOVENSKY RSIMOES

32 PAUSE users
16 non-PAUSE users.

藤 吾郎
and 1 contributors

NAME

Text::Xslate - High performance template engine (ALPHA)

VERSION

This document describes Text::Xslate version 0.001_06.

SYNOPSIS

    use Text::Xslate;
    use FindBin qw($Bin);

    my %vars = (
        title => 'A list of books',
        books => [
            { title => 'Islands in the stream' },
            { title => 'Programming Perl'      },
            { title => 'River out of Eden'     },
            { title => 'Beautiful code'        },
        ],
    );

    # for multiple files
    my $tx = Text::Xslate->new();
    print $tx->render_file('hello.tx', \%vars);

    # for strings
    my $template = q{
        <h1><:= $title :></h1>
        <ul>
        : for $books ->($book) {
            <li><:= $book.title :></li>
        : } # for
        </ul>
    };

    $tx = Text::Xslate->new(
        string => $template,
    );

    print $tx->render(\%vars);

DESCRIPTION

Text::Xslate is a template engine tuned for persistent applications. This engine introduces virtual machines. That is, templates are compiled into xslate opcodes, and then executed by the xslate virtual machine just like as Perl does.

This software is under development. Any interfaces will be changed.

INTERFACE

Methods

Text::Xslate->new(%options) -> TX

Creates a new xslate template code.

Options:

string => $template_string
file => $template_file | \@template_files
path => \@path // ["$FindBin::Bin/../template"]
function => \%functions
cache => $bool // true

$tx->render($name, \%vars) -> Str

Renders a template with variables, and returns the result.

TEMPLATE SYNTAX

TODO

EXAMPLES

Variable access

    <:= $var :>
    <:= $var.field :>
    <:= $var["field"] :>

Variables may be HASH references, ARRAY references, or objects.

Loop (for)

    : for $data ->($item) {
        [<:= $item.field =>]
    : }

Iterating data may be ARRAY references.

Conditional statement (if)

    : if $var == nil {
        $var is nil.
    : }
    : else if $var != "foo" {
        $var is not nil nor "foo".
    : }
    : else {
        $var is "foo".
    : }

    : if( $var >= 1 && $var <= 10 ) {
        $var is 1 .. 10
    : }

    := $var.value == nil ? "nil" : $var.value

Expressions

Relational operators (== != < <= > >=):

    := $var == 10 ? "10"     : "not 10"
    := $var != 10 ? "not 10" : "10"

Arithmetic operators (+ - * / %):

    := $var + 10
    := ($var % 10) == 0

Logical operators (|| && //)

    := $var >= 0 && $var <= 10 ? "ok" : "too smaller or too larger"
    := $var // "foo" # as a default value

Operator precedence:

    (TODO)

Template inclusion

    ? include "foo.tx"

Xslate templates may be recursively included, but including depth is limited to 100.

Template inheritance

(NOT YET IMPLEMENTED)

Base templates mytmpl/base.tx:

    : block title -> { # with default
        [My Template!]
    : }

    : block body is abstract # without default

Derived templates mytmpl/foo.tx:

    : extends base
    : # use default title
    : override body {
        My Template Body!
    : }

Derived templates mytmpl/bar.tx:

    : extends foo
    : # use default title
    : before body {
        Before body!
    : }
    : after body {
        After body!
    : }

Then, Perl code:

    my $tx = Text::Xslate->new( file => 'mytmpl/bar.tx' );
    $tx->render({});

Output:

        [My Template!]

        Before body!
        My Template Body!
        Before Body!

TODO

  • Documentation

  • Template inheritance (like Text::MicroTemplate::Extended)

  • Opcode-to-XS compiler

DEPENDENCIES

Perl 5.10.0 or later, and a C compiler.

BUGS

All complex software has bugs lurking in it, and this module is no exception. If you find a bug please either email me, or add the bug to cpan-RT.

SEE ALSO

Text::MicroTemplate

Text::ClearSilver

Template

HTML::Template

HTML::Template::Pro

AUTHOR

Goro Fuji (gfx) <gfuji(at)cpan.org>

LICENSE AND COPYRIGHT

Copyright (c) 2010, Goro Fuji (gfx). All rights reserved.

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