Image

head

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6;
use NativeCall;


constant dl = 'TemplateNestDll.dll';

sub get_dll_name()
{

    return %?RESOURCES<libraries/templatenest>;

     if $*VM.osname eq 'linux' {
        return 'templatenest';
     }
     else
     {
      return dl;
     }
}






class TemplateNestClass is repr('CPointer') { }


# templatenest_init(void** object)
sub templatenest_init(Pointer is rw) is native(get_dll_name) { * }

#void templatenest_set_parameters(void* object, char* template_dir, char* template_ext, char* defaults_namespace_char, char** comment_delims,
#	char** token_delims, int64_t show_labels, char* name_label, int64_t fixed_indent, int64_t die_on_bad_params, char* escape_char);


sub templatenest_set_parameters(Pointer $object, Str $template_dir, Str $template_ext, Str $defaults_namespace_char, CArray[Str] $comment_delims,
	CArray[Str] $token_delims, int64 $show_labels, Str $name_label, int64 $fixed_indent, int64 $die_on_bad_params, Str $escape_char) is native(get_dll_name) { * }

# void templatenest_render(void * object,char* data,char ** err)

sub templatenest_render(Pointer,Str is encoded('utf8'),Pointer[Str] is rw  ,Pointer[Str] is rw   ) is native(get_dll_name) { * }


# void templatenest_destroy(void* object)
sub  templatenest_destroy(Pointer) is native(get_dll_name) { * }

#void get_error(int64_t object,char** text)
sub  get_error(Pointer,Pointer[Str] is rw) is native(get_dll_name) { * }



class Template::Nest::XS:ver<0.1.1> {
    has Str $.template_dir is rw;
    has Str $.template_ext is rw = '.html';
    has %.template_hash is rw;
    has %.defaults is rw;

    subset Char of Str where .chars == 1 || .chars == 0;

    has Char $.defaults_namespace_char is rw = '.';

    my @comment_delims_defaults[2] = '';
    has Str @.comment_delims[2] is rw;

    my @token_delims_defaults[2] = '<%', '%>';
    has Str @.token_delims[2] is rw;

    has Bool $.show_labels is rw = False;
    has Str $.name_label is rw = 'TEMPLATE';
    has Bool $.fixed_indent is rw = False;
    has Bool $.die_on_bad_params is rw = False;
    has Char $.escape_char is rw = '\\';

    has Pointer $class_pointer = Pointer.new();

    submethod TWEAK(){
        self.comment_delims = @comment_delims_defaults unless grep {$_}, @!comment_delims;
        self.token_delims = @token_delims_defaults unless grep {$_}, @!token_delims;
        templatenest_init($class_pointer);
    }

    method render ( $comp ){

        my @comment_delims := CArray[Str].new;
	    @comment_delims[0]  = $.comment_delims[0];
	    @comment_delims[1]  = $.comment_delims[1];

        my @token_delims := CArray[Str].new;
	    @token_delims[0]  = $.token_delims[0];
	    @token_delims[1]  = $.token_delims[1];
        templatenest_set_parameters($class_pointer, $.template_dir, $.template_ext, $.defaults_namespace_char, @comment_delims,
	        $@token_delims, $.show_labels, $.name_label, $.fixed_indent, $.die_on_bad_params, $.escape_char);

        my Pointer[Str] $html = Pointer[Str].new();
        my Pointer[Str] $err = Pointer[Str].new();
      
        templatenest_render($class_pointer,$comp.raku,$html,$err);
	    if $err.deref {
          die "there is an error in dynamic library:{$err.deref}";
        }
        #if !$html.deref || $html.deref=="" {
           my Pointer[Str] $err2 = Pointer[Str].new();
           get_error($class_pointer,$err2);
           if ($err2.deref)
	       {
	          die "there is an error during execution:{$err2.deref}";
	       }
        #}
        return $html.deref;
    }


    submethod DESTROY {
	    templatenest_destroy($class_pointer);

    }



}

Template::Nest - manipulate a generic template structure via a Raku hash


page.html:
<html>
	<head>
		<style>
			div {
				padding: 20px;
				margin: 20px;
				background-color: yellow;
			}
		</style>
	</head>


my $page = {
	NAME => 'page',
	contents => [{
		NAME => 'box',
		title => 'First nested box'
	}]
};


push @{$page->{contents}},{
	NAME => 'box',
	title => 'Second nested box'
};


my $nest = Template::Nest->new(
	template_dir => '/html/templates/dir',
       fixed_indent => 1
);


<html>
 <head>
  <style>
   div {
    padding: 20px;
    margin: 20px;
    background-color: yellow;
   }
  </style>
 </head>


<body>
       <div>
        First nested box
       </div>
       <div>
        Second nested box
       </div>
</body>
</html>


This is a native Raku version of my Perl5 L<Template::Nest> module. This means there are now Perl5, Python3 and Raku versions of L<Template::Nest> so the same templates can be used with any of the 3 languages. (If e.g. you were upgrading a Perl5 project that used L<Template::Nest> there would be no overhead converting templates since you could use exactly the same ones.)


At the time of writing there is currently very little difference between (latest) versions - they include (almost) the same methods which have near-identical functionality. Again I did this primarily for my own benefit; I have Perl5 and Python projects which use a certain set of templates, and I plan to keep using them now I am moving into Raku. To me, this is the only templating philosophy that makes any sense.


The usage instructions below are adapted from the original Perl5 documentation.


There are a wide number of templating options out there, and many are far more longstanding than L<Template::Nest>. However, his module takes a different approach to many other systems, and in the author's opinion this results in a better separation of "control" from "view".


The philosophy behind this module is simple: don't allow any processing of any kind in the template. Treat templates as dumb pieces of text which only have holes to be filled in. No template loops, no template ifs etc. Regard ifs and loops as control processing, which should be in your main code and not in your templates.


Lets say you have a template for a letter (if you can remember what that is!), and a template for an address. Using L<HTML::Template> you might do something like this:


However, in L<Template::Nest> there's no such thing as a C<TMPL_INCLUDE>, there are only tokens to fill in, so you would have


I specify that I want to use C<address.html> when I fill out the template, thus:


my %letter =
    NAME => 'letter',
    username => 'billy',
    address => {
        NAME => 'address', # this specifies "address.html"
                           # provided template_ext=".html"


This is much better, because now C<letter.html> is not hard-coded to use C<address.html>. You can decide to use a different address template without needing to change the letter template.


Commonly used template structures can be labelled (C<main_page> etc.) stored in your code in subs, hashes, Moose attributes or whatever method seems the most convenient.


=begin code

    # table.html:

    <table>
        <tr>
            <th>Name</th><th>Job</th>
        </tr>

        

    </table>


    # table_row.html:

    <tr>
        <td></td>
        <td></td>
    </tr>


    # and in the Raku:

    my %table =
        NAME => 'table',
        rows => [{
            NAME => 'table_row',
            name => 'Sam',
            job => 'programmer'
        }, {
            NAME => 'table_row',
            name => 'Steve',
            job => 'soda jerk'
        }];

    my $nest = Template::Nest.new(
        token_delims => ['']
    );

    say $nest.render( $table );

To fill this in:

    my @rows;

    for @data -> $item {

        @rows.push: {
            NAME => 'table_row',
            name => $item->name,
            job => $item->job
        };

    }

    my %table =
        NAME => 'table',
        rows => $rows;

    my $nest = Template::Nest.new(
        token_delims => ['']
    );

    say $nest.render( %table );

=end code

Use this in conjunction with show_labels. Get/set the delimiters used to define comment labels. Expects a 2 element arrayref. E.g. if you were templating javascript you could do:


/* BEGIN my_js_file */
...
/* END my_js_file */


grammar Template::Mojo::Grammar {
    token TOP {
        ^ <expression>* $
    }

    token expression {
        || <perlline>
        || <perlcapture-begin>
        || <perlcapture-end>
        || <perlexpr>
        || <characters>
    }

    token perlline {
        ^^ \h* '%' $<get-result>=['=']? $<expr>=[ <-[\n]>* ] [\n | $]
    }

    rule perlcapture-begin {
        '<%' 'my' $<name>=<var> '=' 'begin' '%>'
    }

    rule perlcapture-end {
        '<%' 'end' '%>'
    }

    token perlexpr {
        '<%' $<get-result>=['=']? $<expr>=[ [ <!before '%>' > . ]* ] '%>'
    }

    token var {
        <sigil> [ \w+ ]
    }

    token sigil {
        '&' | '$'
    }

    token characters {
        \n | [ <!before '<%' || \n > . ]+ \n?
    }
}

class Template::Mojo::Actions {
    method TOP($/) {
        my @exprs = $<expression>».ast;
        @exprs.unshift: 'my $_M = "";';
        @exprs.push: ';return $_M;';
        my $code = 'sub ' ~ $*TMPLNAME ~ ' { ' ~ @exprs.join ~ '}';
        make $code;
    }

    method expression($/) {
        if $<perlline> {
            make $<perlline>.ast
        }
        elsif $<perlcapture-begin> {
            make $<perlcapture-begin>.ast
        }
        elsif $<perlcapture-end> {
            make $<perlcapture-end>.ast
        }
        elsif $<perlexpr> {
            make $<perlexpr>.ast
        }
        else {
            make sprintf q[;$_M ~= '%s';],
                         $<characters>.Str.subst(/"'"/, "\\'", :g)
        }
    }

    method perlline($/) {
        make expr($/) ~ "\n"
    }

    method perlcapture-begin($/) {
        make 'my ' ~ $<name> ~ ' = sub {temp $_M = "";';
    }

    method perlcapture-end($/) {
        make ';return $_M};';
    }

    method perlexpr($/) {
        make expr($/)
    }

    sub expr($/) {
        if $<expr> ne '' {
            if $<get-result> ne '' {
                return ';$_M ~= ' ~ $<expr> ~ ';'
            }
            else {
                return $<expr>.Str
            }
        }
        else {
            return ''
        }
    }
}

class X::Template::Mojo::ParseError is Exception {
}

my $*TMPLNAME = "anon";

class Template::Mojo {
    has &.code;

    method from-file(Str $filename) {
        my $tmpl = $filename.IO.slurp;
        self.new($tmpl, name => $filename.IO.basename.split(".")[0]);
    }

    method new(Str $tmpl, :$name = "anon") {
        my $*TMPLNAME = $name;
        my $m = Template::Mojo::Grammar.parse(
            $tmpl, :actions(Template::Mojo::Actions.new)
        );
        unless $m {
            die X::Template::Mojo::ParseError.new(message => "Failed to parse the template")
        }
        self.bless: :code($m.ast.EVAL)
    }

    method render(*@a, *%a) {
        &.code.(|@a, |%a)
    }
}



TITLE

A templating system modeled after the Perl's L<https://metacpan.org/module/Mojo::Template>


my $t = Template::Mojo.new($tmpl);
$t.render()


my $ot = Template::Mojo.from-file('eg/template.tm');


my $tmpl = slurp 'eg/template.tm';
my $t = Template::Mojo.new($tmpl);
$t.render()


See, on the first row of the template we accept a parameter as if this was a generic function call. Then we use the veriable in two different ways.


The value to that subroutione can be passed in the render call:


my $tmpl = slurp 'eg/template.tm';
my $t = Template::Mojo.new($tmpl);
$t.render(5)


Fname: <%= $x<fname> %>
Lname: <%= $x<lname> %>


my %params = (
  fname => 'Foo',
  lname => 'Bar',
);


my $tmpl = slurp 'eg/template.tm';
my $t = Template::Mojo.new($tmpl);
$t.render(%params)


<ul>
% for %h<pages>.values -> $p {
  <li><a href="<%= $p<url> %>"><%= $p<title> %></a></li>
% }
</ul>


my %params = (
   title => "Perl 6 Links",
   pages => [
      {
        "title" => "Rakudo",
        "url"   => "http://rakudo.org/",
      },
      {
        title   => 'Perl 6',
        url     => 'http://perl6.org/',
      }
   ],
);


<ul>
  <li><a href="http://rakudo.org/">Rakudo</a></li>
  <li><a href="http://perl6.org/">Perl 6</a></li>
</ul>


class Template::Mojo


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

TITLE

SYNOPSIS

EXAMPLES

Loop

Template

Code

Output

Parameters

Template

Code

Output:

Passing hash

Template

Code

Output

Complex examples

Template

Code

Output

AUTHOR

COPYRIGHT AND LICENSE

CONTRIBUTORS

Template::Mojo v0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation