Diego Jeronymo

Neste primeiro post de 2010 dedico a atender um pedido feito em um comentário de post passado de mostrar como integrar o Smarty (funcionando tanto com o 2.6.26 quanto com o 3.0b5) nas versões mais novas do Zend Framework. A base usada para fazer ele foi da Documentação Oficial do Zend Framework, fiz poucas alterações na classe que eles criaram.

Em versões anteriores, era necessário explicitamente trocar o Zend_View pelo Smarty no index. Agora, temos a opção de criar uma classe que transforme outro sistema de templates em uma instância da Zend_View, e o melhor: de maneira simples e sem contar com eventuais gambiarras para ‘mascarar’ alguns problemas que dava quando substituíamos.

Optando pelo Smarty

Antes de começar a mexer com Smarty, temos que usar o Autoloader do Zend para poder rodar tudo sem precisar dar includes em todas as páginas, em especial o Bootstrap. Para isso, coloque dentro da sua index, antes de instanciar o Zend_Application:

require_once 'Zend/Loader/Autoloader.php';

$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->registerNamespace('My_');

Esse código basicamente tornará todas as classes dentro da pasta library/My visíveis, usando o mesmo esquema de nomeação do Zend. Por exemplo, eu coloquei a classe de integração com o Smarty (que mostrarei mais abaixo) dentro de My/View/Smarty.php, e portanto, devo chamá-la de My_View_Smarty.

Ok, vamos lá: baixe o Smarty e descompacte-o dentro da pasta library.

Altere o Bootstrap, adicionando o método:

protected function _initView()
    {

        // aqui podemos passar quaisquer parâmetros que sejam atributos do objeto smarty
        // se quisermos habilitar o cache, por exemplo:
        $params = array(
                      'caching'        => true,
                      'cache_lifetime' => 60
                  );

        $view = new My_View_Smarty('../application/views/smarty/', $params);
        $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer();
        $viewRenderer->setView($view)
                     ->setViewBasePathSpec($view->getEngine()->template_dir)
                     ->setViewScriptPathSpec(':controller/:action.:suffix')
                     ->setViewScriptPathNoControllerSpec(':action.:suffix')
                     ->setViewSuffix('tpl');
        Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);

    }

Crie o arquivo de implementação do Smarty:

<?php

require_once('Smarty/Smarty.class.php');

class My_View_Smarty implements Zend_View_Interface
{

    /**
     * Smarty object
     * @var Smarty
     */
    protected $_smarty;

    /**
     * Constructor
     *
     * @param string $tmplPath
     * @param array $extraParams
     * @return void
     */
    public function __construct($tmplPath = null, $extraParams = array())
    {
        $this->_smarty = new Smarty();

        if (null !== $tmplPath) {
            $this->setScriptPath($tmplPath);
        }

        foreach ($extraParams as $key => $value) {
            $this->_smarty->$key = $value;
        }
    }

    /**
     * Return the template engine object
     *
     * @return Smarty
     */
    public function getEngine()
    {
        return $this->_smarty;
    }

    /**
     * Set the path to the templates
     *
     * @param string $path The directory to set as the path.
     * @return void
     */
    public function setScriptPath($path)
    {

        if (is_readable($path)) {
            $this->_smarty->template_dir = $path."templates";
            $this->_smarty->compile_dir  = $path."templates_c";
            $this->_smarty->cache_dir    = $path."cache";
            $this->_smarty->config_dir   = $path."config";
            return;
        }

        throw new Exception('Invalid path provided');
    }

    /**
     * Retrieve the current template directory
     *
     * @return string
     */
    public function getScriptPaths()
    {
        return array($this->_smarty->template_dir);
    }

    /**
     * Alias for setScriptPath
     *
     * @param string $path
     * @param string $prefix Unused
     * @return void
     */
    public function setBasePath($path, $prefix = 'Zend_View')
    {
        return $this->setScriptPath($path);
    }

    /**
     * Alias for setScriptPath
     *
     * @param string $path
     * @param string $prefix Unused
     * @return void
     */
    public function addBasePath($path, $prefix = 'Zend_View')
    {
        return $this->setScriptPath($path);
    }

    /**
     * Assign a variable to the template
     *
     * @param string $key The variable name.
     * @param mixed $val The variable value.
     * @return void
     */
    public function __set($key, $val)
    {
        $this->_smarty->assign($key, $val);
    }

    /**
     * Allows testing with empty() and isset() to work
     *
     * @param string $key
     * @return boolean
     */
    public function __isset($key)
    {
        return (null !== $this->_smarty->get_template_vars($key));
    }

    /**
     * Allows unset() on object properties to work
     *
     * @param string $key
     * @return void
     */
    public function __unset($key)
    {
        $this->_smarty->clear_assign($key);
    }

    /**
     * Assign variables to the template
     *
     * Allows setting a specific key to the specified value, OR passing
     * an array of key => value pairs to set en masse.
     *
     * @see __set()
     * @param string|array $spec The assignment strategy to use (key or
     * array of key => value pairs)
     * @param mixed $value (Optional) If assigning a named variable,
     * use this as the value.
     * @return void
     */
    public function assign($spec, $value = null)
    {
        if (is_array($spec)) {
            $this->_smarty->assign($spec);
            return;
        }

        $this->_smarty->assign($spec, $value);
    }

    /**
     * Clear all assigned variables
     *
     * Clears all variables assigned to Zend_View either via
     * {@link assign()} or property overloading
     * ({@link __get()}/{@link __set()}).
     *
     * @return void
     */
    public function clearVars()
    {
        $this->_smarty->clear_all_assign();
    }

    /**
     * Processes a template and returns the output.
     *
     * @param string $name The template to process.
     * @return string The output.
     */
    public function render($name)
    {
        return $this->_smarty->fetch($name);
    }

}

Para funcionar, basta criar as pastas de templates, cache e configs usadas pelo Smarty.

Exemplo de execução

O controller não fica muito diferente do que já era com o Zend_View comum… usando o controller index por exemplo:

    public function indexAction()
    {
        // cria algumas variáveis
        $valor1 = mt_rand(0,100);
        $valor2 = array(
            array('id' => '1', 'titulo' => 'Teste 1'),
            array('id' => '2', 'titulo' => 'Teste 2'),
            array('id' => '3', 'titulo' => 'Teste 3')
        );
        // inclui as variáveis na view
        $this->view->assign('valor1', $valor1);
        $this->view->assign('valor2', $valor2);
    }

No arquivo views/smarty/index/index.tpl, teríamos:

<p>{$valor1}</p>
<table>
    <tr>
        <th>Código</th>
        <th>Título</th>
    </tr>
    {foreach from=$valor2 item=registro}
    <tr style="background-color: {cycle values="#ff0000,#00ff00"}">
        <td>{$registro.id}</td>
        <td>{$registro.titulo}</td>
    </tr>
    {/foreach}
</table>

Espero que tenham gostado do tutorial e que tenha facilitado a vida dos amantes de Smarty e ZF!