I may have complety missed the mark, but have you looked at the Text::Template module?

In particular, what your decribing made me think of the Philosophy section of Dominus' module.

Of the three templating modules I played with, the other two being HTML::Template, Template::Toolkit, it had the smallest learning curve and the (to my mind) greatest flexibility. Worth a look if you haven't already.

I work with an application that uses Text::Template and, having worked with the others as well, I must say that Text::Template is the worst templating module I've ever used. There is a ton of business code within the templates, logic that is just abysmal, and no separation of concerns.

While I understand the drive that Dominus had to build Text::Template, the amount of self-discipline required to successfully use it boggles the mind, especially when alternatives that help provide that discipline for you exist. I simply cannot recommend its usage in any application.

Being right, does not endow the right to be rude; politeness costs nothing.
Being unknowing, is not the same as being stupid.
Expressing a contrary opinion, whether to the individual or the group, is more often a sign of deeper thought than of cantankerous belligerence.
Do not mistake your goals as the only goals; your opinion as the only opinion; your confidence as correctness. Saying you know better is not the same as explaining you know better.

I think I might agree with you if your application is a web application where the drive to keep business logic out of the html is a priority, but reading Bart's OP, that did not seem to be the case here.

---

Examine what is said, not who speaks.

Silence betokens consent.

Love the truth but pardon error.

I gave a presentation at YAPC 2003 about generating Java with Perl. I strongly agree with Randal regarding the Template Toolkit, although even something like Text::Template would be good too.

While the presentation doesn't have a ton of Template Toolkit examples you might find it useful -- download the tarball and see for yourself. (The TT examples are 'extra' slides toward the end.)

[% FOREACH item IN items %]

    [% IF loop.first %]

      <ul> 

    [% END %]

        <li>[% item %] ([% loop.count %] of [% loop.size %])</li>

    [% IF loop.last %]

      </ul>

    [% END %]

[% END %]
[download]

... and of course, for the fans of that curious and little-known templating language "perl" ... (cheatsheet version, "readmore" section has the full version)

   ### --------------------------
    .q©
    // BEGIN©
    .sub{(@{$oDt})?"
        switch(x){"
        .sLp($oDt,sub{my $sBrk=($iCt++<$#{$oDt})?'break;':'';"
            case $_:
                // code for $_
                $sBrk"
            })."
        }"
        :''}->().
    q©
    // END
    ©;
    ### --------------------------
[download]

Your example would look something like:

[%- items = ['one', 'two', 'three'] -%]
# Output an array data structure in perl.
@array = (
[%- FOREACH item IN items -%]
[%- IF loop.last -%]
'[%- item -%]'
[%- ELSE -%]
'[%- item -%]',
[%- END -%]
[%- END -%]);
[download]

You can run this from the command line after you install Template using the tpage command. The extra '-' gets rid of whitespace from inside the template directives. If you want the code to look nice, you'll have to play with the spacing a bit.

Thank you. I don't know how I missed the "loop.last" property for the FOREACH directive, I clearly was looking at the wrong spot in the docs. It obviously is the right property to use to put text between items.

So, to answer my own question, for Template::Toolkit, this is a good way to do what I wanted in Template::Toolkit — though you're still free to suggest improvements :):

// BEGIN
[% IF list -%]
switch(x) {
[% FOREACH item IN list -%]
  case [% item %]:
    // code for [% item %]
[% UNLESS loop.last -%]
    break;
[% END -%]
[% END -%]
}
[% END -%]
// END
[download]

Run together with the following code:

#! perl -w
use Template;
my $tt = Template->new();
foreach my $data ([undef => undef], [ empty => []],
  ['("foo", "bar", "baz")' => [qw(foo bar baz)]]) {
    print "// List is $data->[0]:\n";
    $tt->process('tt2.tmpl', { list => $data->[1] });
    print "\n\n";
}
[download]

Read more... (927 Bytes)

Oh, and I feel that I had to tweak it quite a bit just to get the proper amount of whitespace, adding the hyphens just at the right spots (those -%] thingies). Either I'm missing something, or Template::Toolkit could use a touchup.

I'd also like to indent the loop control directives, without that the added leading whitespace shows up in the output. Can it be done? It seems like I have to choose between stripping all whitespace (including newlines) just in front or right after the directives, or no stripping at all. Can't I strip leading whitespace just up to, but excluding, the newline?

// BEGIN
[% IF list -%]
switch(x) {
[% FOREACH item IN list -%]
  case [% item %]:
    // code for [% item %]
[% UNLESS loop.last -%]
    break;
[% END -%]
[% END -%]
}
[% END -%]
// END
[download]

With loop.first and loop.last (which I sometimes wish Perl had), you can simplify this even further by getting rid of the outer "if":

[% FOREACH item IN list -%]
[% IF loop.first -%]
// BEGIN
switch(x) {
[% END %]
  case [% item %]:
    // code for [% item %]
[% UNLESS loop.last -%]
    break;
[% ELSE -%]
}
// END
[% END -%]
[download]

The loop won't be run if there are no elements, so you don't need to test if elements exist or not. Then, once in the loop, you put "ahead of first time" and "after last time" things inside the loop.first and loop.last conditionals. Nice pattern. In the abstract:

[% FOR item IN list %]
[% IF loop.first %]
... before first item ..
[% END %]
... each item ...
[% UNLESS loop.last %]
... between items ...
[% ELSE %]
... after last item ...
[% END; END %]
[download]

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Oh, and I feel that I had to tweak it quite a bit just to get the proper amount of whitespace, adding the hyphens just at the right spots (those -%] thingies). Either I'm missing something, or Template::Toolkit could use a touchup.

You can control this behavior in a more global manner with the chomping options PRE_CHOMP and POST_CHOMP which you can set when you create your Template object. You can find some details on the TT web site in the section on config options.

Nothing wrong with the other suggestions, but HTML::Template can do something similar:

//START
<tmpl_loop name="cases">
<tmpl_if name="__first__">
switch(x) {
</tmpl_if>
  case <tmpl_var name="case":
    // <tmpl_var name="case_code">
<tmpl_unless NAME="__last__">
       break;
<tmpl_else>   
}
</tmpl_unless>
//END
[download]

Loops have __first__, __last__, __inner__, __odd__ and __counter__.