[SP-pm] Mason, Template Toolkit ou HML::Template

[breno]

2010/5/1 Thiago Glauco <thiagoglauco em yahoo.com.br>:
> Sages,
> como eu disse uns dias passados estou indo além do CGI e o catalyst é o caminho. Mas, qual o melhor template para se trabalhar. Partindo do princípio que nunca usei nenhum. O catalyst tem plug-ins para os 3 templates
> Mason, Template Toolkit ou HML::Template. Como eu vou ter que desprender esforços em aprender um template, qual é o recomendado pela lista?
>

O recomendado é o que melhor atende o seu jeito de pensar :-)

TT é disparado o mais usado, costuma ser considerado muito simples de
aprender, possui vários filtros e extensões e é o que vc vai encontrar
mais suporte. Código do template fica em blocos, por padrão [% e %].
Exemplo:

---------------8<------------------
[% foo = 'bar' %]
a variavel foo tem valor "[% foo %]".

[% IF baz > 42 %]
   isso eh um bloco
[% ELSIF baz == 42 %]
   outro bloco
[% ELSE %]
    mooooo
[% END %]
--------------->8------------------

HTML::Template me parece um pouco desatualizado (última versão de
2007, e site indicado na documentação oficial como "tutorial"
simplesmente não existe). Código do template fica entre tags <>
tradicionais, propositadamente imitando HTML, e precisa de um rótulo
específico de declaração para cada variável ou bloco. Você também pode
colocar suas tags como comentários <!-- --> para garantir que o
template passe por validações antes de ser processado. Outra
característica... interessante... do HTML::Template é que ele se
esforça ao máximo para realmente remover toda a lógica de dentro do
seu template. O mesmo código acima, versão HTML::Template, não poderia
ser realizado - ou pelo menos não sem uma interação maior com o
controller do lado de fora do template. Teriamos, no template:

---------------8<------------------
a variavel foo tem valor "<TMPL_VAR NAME="foo">".

<TMPL_IF BAZ_TEST_1>
   isso eh um bloco
<TMPL_ELSE>
   <TMPL_IF BAZ_TEST_2>
   outro bloco
   <TMPL_ELSE>
    mooooo
   </TMPL_IF>
</TMPL_IF>
--------------->8------------------

E precisaríamos colocar os resultados booleanos dos testes dentro do
controller, passados como variáveis ao template. No caso, seria algo
como:

$template->param(foo => 'bar', BAZ_TEST_1 => ($baz > 42), BAZ_TEST_2
=> ($baz == 42) );

Algumas pessoas tiram vantagem dessa estrutura limitada e refatoram
seus templates para que sejam apenas interpolação de variáveis, o que
é ideal. Infelizmente não vivemos em um mundo ideal e, na minha
percepção (YMMV), a complexidade e necessidades específicas de
determinados sites fazem com que esse formato exija uma sincronização
controller-template muito custosa de manter.

Finalmente, o HTML::Mason é um formato de template extremamente
simplista e, exatamente por isso, extremamente poderoso. Trata-se de
um sistema de template que não trabalha com micro-linguagem
específica. Generalizando um pouco (mas não muito), ele possui a
seguinte regra: linhas começando com '%' são Perl. Você pode colocar
código inline através de tags <% %> também. Vejamos o exemplo:

---------------8<------------------
% my $foo = 'bar';
a variavel foo tem valor "<% $foo %>".

% if ( $baz > 42) {
   isso eh um bloco
% } elsif ( $baz == 42 ) {
   outro bloco
% } else {
    mooooo
% }
--------------->8------------------

(obs: o framework Mojolicious utiliza um mecanismo padrão de template
bastante parecido, deliberadamente "emprestado" do Mason)
Fica bem fácil de entender para quem sabe Perl, mas eu acho menos
legível por ser muito diferente de um documento baseado apenas em
tags. Ele traz consigo todo o poder e flexibilidade do Perl, o que
pode assustar um pouco - especialmente se o responsável pelo template
não for alguém com conhecimento de Perl.

Em minha opinião, o HTML::Mason é imediato para quem usa Perl no dia a
dia, mas é mais "sujo" de ver em relação a uma micro-linguagem
puramente baseada em tags, e pode ser um problema para equipes em que
o responsável pelo template não conhece Perl. O HTML::Template, por
outro lado, é extremamente purista e focado em casos em que fazemos
apenas interpolação de variáveis, e a lógica está toda - toda mesmo -
do lado do controller, o que na prática acaba não acontecendo ou
exigindo muito cuidado de manutenção para acontecer da forma correta.
O Template::Toolkit, por sua vez, é um bom balanço entre os dois
mundos, oferecendo uma sintaxe de fácil utilização e compreensão, tags
limpos e a vantagem de permitir colocar certa lógica no template sem
grandes malabarismos (lembrando que muita lógica no template nunca é
bom). Seria minha escolha.

Mas, termino o email com a mesma frase do início: o recomendado é o
que melhor atende o seu jeito de pensar :-)

[]s

-b