NAME

Text::Xslate::Syntax::Kolon - The default template syntax

SYNOPSIS

use Text::Xslate;
my $tx = Text::Xslate->new(
    syntax => 'Kolon',                         # This is the default
    string => 'Hello, <: $dialect :> world!',
);

print $tx->render({ dialect => 'Kolon' });

DESCRIPTION

Kolon is the default syntax, using <: ... :> tags and : ... line code.

EXAMPLES

Variable access

<: $var :>
<: $var.0 :>
<: $var.field :>
<: $var.accessor :>

<: $var["field"] :>
<: $var[0] :>

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

If $var is an object instance, you can call its methods.

<: $var.foo() :>
<: $var.foo(1, 2, 3) :>

Loops

There are for and while loops.

: # $data must be an ARRAY reference
: for $data -> $item {
    [<: $item.field :>]
: }

: # $obj must be an iteratable object
: while $obj.fetch -> $item {
    [<: $item.field :>]
: }

Conditional statements

if-then-else statement:

: 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

switch statement (not yet implemented):

: given $var -> $it {
:   when "foo" {
        it is foo.
:   }
:   when $it == "bar" or $it == "baz" {
        it is bar or baz.
:   }
:   default {
        it is not foo nor bar.
    }
:

Expressions

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

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

Note that == and != are similar to Perl's eq and ne except that $var == nil is true iff $var is uninitialized, while other relational operators are numerical operators.

Arithmetic operators (+ - * / % min max>>):

: $var * 10_000
: ($var % 10) == 0
: 10 min 20 min 30 # 10
: 10 max 20 max 30 # 30

Logical operators (! && || // not and or>>)

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

String operators (~)

: "[" ~ $var ~ "]" # concatination

Operator precedence is the same as Perl's:

. () []
* / %
+ - ~
< <= > >=
== !=
|
&&
|| // min max
?:
not
and
or

Functions and filters

Once you have registered functions, you can call them with () or |.

: f()        # without args
: f(1, 2, 3) # with args
: 42 | f     # the same as f(42)

Dynamic functions/filters:

# code
sub mk_indent {
    my($prefix) = @_;
    return sub {
        my($str) = @_;
        $str =~ s/^/$prefix/xmsg;
        return $str;
    }
}
my $tx = Text::Xslate->new(
    function => {
        indent => \&mk_indent,
    },
);

:# template
: $value | indent("> ")
: indent("> ")($value)

Template inclusion

: include "foo.tx"

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

Template cascading

You can extend templates with block modifiers.

Base templates mytmpl/base.tx:

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

: block body -> {;} # without default

Another derived template mytmpl/foo.tx:

: # cascade "mytmpl/base.tx" is also okey
: cascade mytmpl::base
: # use default title
: around body -> {
    My template body!
: }

Yet another derived template mytmpl/bar.tx:

: cascade mytmpl::foo
: around title -> {
    --------------
    : super
    --------------
: }
: 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 tody!
After body!

This is also called as template inheritance.

Macro blocks

: macro add ->($x, $y) {
:   $x + $y;
: }
: add(10, 20)

: macro signeture -> {
    This is foo version <: $VERSION :>
: }
: signeture()

Note that return values of macros are values that their routines renders. That is, macros themselves output nothing.

SEE ALSO

Text::Xslate

cpanm Text::Xslate

perl -MCPAN -e shell
install Text::Xslate