Concluimos con nuestra serie sobre Smarty en donde hemos abordado los temas sobre, Smarty: razones para utilizar plantillas en mis proyectos, Smarty: requerimientos, instalación y aprende a programar, Smarty: a nivel avanzado y ahora hablaremos de sus alternativas.

Sistemas de Plantillas en PHP

Savant:

El proyecto Savant es un sistema de plantillas que me ha parecido bastante interesante. Savant está basado en el paquete PEAR. A diferencia de Smarty el archivo de plantilla no es un archivo con una sintáxis diferente sino otro archivo PHP.

Una ventaja en cuando a rendimiento, aunque definitivamente podría generar problemas en especial si lo utilizamos en un proyecto donde el encargado de la integración con HTML no es conocedor de lenguaje PHP.

Tiene varias similitudes con Smarty en cuanto a convención de nombre de funciones del objeto y al manejo de concepto de carpeta de plantillas. El hecho de que la plantilla final sea PHP permite que pueda utilizar las variables y funciones de nuestro script original, pero a mi parecer también genera una gran vulnerabilidad.

Ejemplo: Script PHP 

<?php
//  this gets the template output from the template search path.
$output = $tpl->fetch('template.tpl.php'); 
// this would display another template from a subdirectory
// in the template search path. 
$output = $tpl->fetch('subdir/anotheryawiki_storelate.tpl.php'); 
// an alternative method: set the default template
// and then return the default script output.
$tpl->setTemplate('template.tpl.php');
$output = $tpl->fetch(); 
?>

Plantilla:

<html>
      <!-- template source -->
      <?php include $this->loadTemplate('header.tpl.php') ?> 
      <h2>Main Content</h2> 
      <p>Your name is <?php echo $this->name ?>, right?</p> 
      <?php include $this->loadTemplate('footer.tpl.php') ?> 
</html>

Sistemas de plantillas para Ruby

Canny:

Esta fantástica implementación del motor de plantillas Smarty para lenguaje Ruby. Los desarrolladores del proyecto han cuidado que la aplicación sea igual en cuanto ha implementación de lógica de programación y sobre todo que las plantillas que han sido creadas para Smarty puedan utilizar Canny como motor de compilación.

Aunque hay algunas variantes a nivel de plantilla sobre todo por el manejo que se le da a los tipos de datos. Realmente un gran proyecto.

Ejemplo: Script Ruby 

#!/usr/bin/env ruby 
require "Canny" 
# Inicia el objeto Canny y asigna los directorios de plantilla
C = Canny.new
C.template_dir = 'templates'
C.compile_dir  = 'templates_c' 
name = 'Canny user' 
people = [
          {'name' => 'John Doe', 'city' => 'New York', 'zip' => '10000'},
          {'name' => 'Jane Doe', 'city' => 'Los Angeles', 'zip' => '90000'},
      ] 
fruits = ['Apple', 'Orange', 'Banana', 'Strawberry', 'Cherry', 'Lemon', 'Lime'] 
def my_modifier(str, params=[])
     if params[0] == 'pie'
          str += " Pie"
     elsif params[0] == "smoothie"
          str += " Smoothie"
     else
          str
     end
end 
Canny.register_modifier('my_modifier', 'my_modifier') 
C.assign('name', name)
C.assign('people', people)
C.assign('fruits', fruits) 
C.display('example.tpl')

Ejemplo: Plantilla (prácticamente es la misma sintáxis que Smarty). 

Hello { $name }. 
<br />
<br /> 
{ foreach from=$fruits item=fruit }
     { if $fruit == "Apple" or $fruit == "Cherry" }
          { $fruit|my_modifier:"pie" }
     {else}
          { $fruit|my_modifier:"smoothie" }
     {/if} 
     <br />
{/foreach} 
{ foreach name=people from=$people item=person }
     { $canny.foreach.people.iterator } { $person.name|upper } lives in { $person.city|upper }.
     <br />
{/foreach} 
<br />
<br /> 
{ include file="example_show_total.tpl" total=$canny.foreach.people.total }

XTemplate:

Esta es otra alternativa en lenguaje Ruby, XTemplate es un sistema de plantillas basado en XML. Su funcionamiento en bastante interesante aunque, por lo que he visto en cuanto al modo de funcionamiento y su sintáxis es viable en proyectos robustos y con un grupo de profesionales en manejo de estructuras con XML.

Los ejemplos que he consultado para hacer esta pequeña reseña no dan muestras de ser un sistema que separe las plantillas en archivos aparte, aunque si es muy seguro que se logre emular esta opción mediante inclusiones de scripts.

Ejemplo: Ruby

require 'xtemplate' 
data = {
  'members' => [
    {"name" => "name1", "age" => 20},
    {"name" => "name2", "age" => 23},
    {"name" => "name3", "age" => 30},
  ],
  'operators' => [
    {"name" => "op1", "age" => 28},
    {"name" => "op2", "age" => 32},
    {"name" => "op3", "age" => 24},
  ],
}

Ejemplo: de la Plantilla (dentro del mismo script) 

text = <<EOF
<?xml version="1.0" encoding="UTF-8"?>
<members xmlns:xt="http://xtemplate.sourceforge.net/xtemplate">
  <member xt:id="/members{push(stack1)}|/operators{pop(stack1);sort(age)}/name">
  </member> 
  <xt:value-of id="/members{push(stack2)}" />
  <xt:value-of id="/members{push(stack2)}" />
  <member xt:id="/operators{pop_all(stack2)}/name">
  </member> 
  <xt:value-of id="/members{push(stack3)}" />
  <xt:value-of id="/members{clear_stack(stack3)}" />
  <member xt:id="/operators{pop_all(stack3)}/name">
  </member>
</members>
EOF 
t = XTemplate::XMLTemplate.new(text)
print(t.expand(data))

Ejemplo: salida 

<?xml version="1.0" encoding="UTF-8"?>
<members>
  <member>name&</member>
  <member>name&</member>
  <member>name&</member>
</members>

En cuanto al manejo de sintáxis lo veo bastante interesante, con fuertes tendencias a la generación de archivos XML o con marcado. Una característica es que la plantilla puede utilizar marcado XML o YAML (recordemos que Ruby viene con un Parser integrado de YAML).

Motores de plantillas en lenguaje Java

Velocity:

Proyecto impulsado por The Apache Foundation Software. Velocity es un sistema basado en Java que permite a los diseñadores importar métodos en lenguaje Java a la plantilla para generar documentos HTML, SQL, PostScripts, etc.

FreeMaker:

FreeMaker, es otro sistema de plantillas para Java que permite generar documentos en formato HTML, RTF, PostScript, TeX, etc) y que permite ser integrado con Java Servlets, XML, Python y otras tecnologías.

ASP.Net y Joel.Net, plantillas free open-source

Joel.Net es un sistema bastante interesante de plantillas para ASP.Net. Actualmente trabaja en VB.Net y C#. Este software es lanzado bajo licencia JPL. La instalación del componente es bastante sencilla y muy parecida a la instalación de otros módulos en Visual Studio.Net aunque tambíen puede ser instalado como módulo independiente.

Ejemplo: 

<!-- template.html -->
<HTML>
  <HEAD><TITLE>No Title</TITLE></HEAD>
  <BODY bgcolor="#FFFFFF">
    <TABLE border="0">
      <TR>
        <TD><tem:navigation>navigation</tem:navigation></TD>
        <TD><tem:main /></TD>
      </TR>
      <TR><TD colspan="2">
        <tem:footer>Copyright joel.net 2003.</tem:footer>
      </TD></TR>
    </TABLE>
    <BR><BR>
  </BODY>
</HTML> 
<!-- page.aspx -->
<%@ Register TagPrefix="cc1" NameSpace="template" Assembly="template" %>
<cc1:template id="Template1" runat="server" path="./template.html" /> 
<asp:Panel id="tem_main" runat="server">
  <B>This should go in the main section!</B>
</asp:Panel>

Conclusiones

Hemos visto sólo algunos de la gran diversidad de proyectos similares a Smarty en diversos lenguajes. La mayoría emplean una sintáxis similar de plantillas y otros como el caso de Java que utiliza XML para definir la plantilla (que en modo particular me a parecido bastante interesante).

También, vale la pena mencionar a Joel.Net que es un sistema bastante sencillo de utilizar para desarrolladores en ASP.Net y cuyo punto a favor es el ser libre y código abierto. Cada uno de los desarrollos en distinto y las alternativas vistas aquí son válidas.

En modo muy personal optaría por Smarty en desarrollo con PHP pues a demostrado ser un sistema muy bueno y con grandes prestaciones. Igualmente, su proyecto en Ruby, Canny merece ser considerado para desarrolladores en este lenguaje.

Cada grupo deberá escoger el que más considere adecuado para su proyecto. Incluso, muchos optarán por no utilizar ningún sistema de plantillas. Eso queda muy a discreción del grupo de programadores. Aunque el proyecto sea algo pequeño, siempre es una buena práctica utilizar plantillas para separar la lógica de programación y el diseño.