Diego Jeronymo

Continuando do post passado, agora vou tratar de assuntos mais específicos do Smarty: arquivos de configuração e algo sobre cache. Aqui usarei a mesma classe e index utilizados no post passado.

Arquivos de Configuração

São arquivos úteis normalmente para que o designer possa setar variáveis globais para os templates, como por exemplo o título da página ou as cores de fundo. No post passado, registrei a pasta ‘configs’ para isso.

Para começar, um exemplo bem simples:

# arquivo my.conf
pageTitle = "Teste Smarty"

[Test]
pageTitle = "Artigo Smarty"

[Production]
pageTitle = "Tutorial Smarty"

Temos aí grande parte das regras dos arquivos configuração:

1. na primeira linha temos um comentário, que deve sempre ser feito com o #;
2. na linha seguinte, temos o nome da nossa variável(pageTitle) e um valor para ela, que poderia estar tanto sem quanto com aspas ou mesmo com apóstrofos. Se tivesse mais de uma linha, o valor deveria ter 3 aspas como delimitador;
3. e as chamadas seções, que são strings entre colchetes []. No meu exemplo, temos 2 seções, e suas variáveis são carregadas apenas quando chamamos a seção em específico. Tudo o que vem antes das seções faz parte das variáveis globais, que são sempre chamadas quando o arquivo de configuração é setado no smarty. Quando uma variável global possui o mesmo nome de uma variável de seção, o valor usado pelo smarty é sempre o da seção.

Para ver o funcionamento do arquivo de configuração, precisamos chamá-la pelo smarty. Podemos fazer isso de 2 maneiras:
ou no próprio php:

// com base na classe criada no primeiro passo, usamos o $this
// mas se não for o $this, será a variável que representa o objeto do smarty
// na função, colocamos o nome do arquivo e, opcionalmente, a seção
$this->config_load('my.conf', 'Test');

ou direto no tpl:

{config_load file="my.conf" section="Test"}

Feito isso, podemos chamar a variável no tpl com 2 sintaxes diferentes:

{#pageTitle#}
ou
{$smarty.config.pageTitle}

Executando de qualquer uma dessas maneiras, teremos como resultado Artigo Smarty no tpl, pois o valor da variável da seção substituiu o da variável global.
Bem, sobre arquivos de configuração é isso: dei um exemplo de arquivo que é normalmente usado em back-end, de configurações para diferentes níveis de uso (Teste e Produção), mas para o smarty é mais usado para diferenciar páginas (index, cadastro, login, etc).

Caching

Outra importante funcionalidade do Smarty é o seu sistema de caching: em geral, o cache é um local de armazenamento temporário na qual dados que são frequentemente acessados possam ser armazenados para rápido acesso. Uma vez que esse dado esteja em cache, ele pode ser acessado diretamente ao invés de refazer todo o processo que gerou os mesmos dados anteriormente.

O Smarty faz exatamente isso: quando habilitamos o cache e ele executa o display(), é criado um arquivo em puro html e pronto para ser retornado. Dessa maneira, conteúdos que não mudam constantemente podem ser recuperados rapidamente. Porém, como estamos lidando com php, e consequentemente teremos conteúdos dinâmicos (principalmente quanto a banco de dados), precisamos controlar o cache para conseguir tornar o conteúdo dinâmico e de rápido acesso.

Caching Simples

Para habilitar o cache no Smarty, vamos alterar a nossa classe usada no post anterior:

// lembrando que o $this se refere ao objeto da classe Smarty
$this->caching = true;

Dessa maneira, o nosso cache estará habilitado e o arquivo será gerado novamente a cada hora na pasta ‘cache’, conforme definimos no post passado. Podemos alterar o tempo de geração com outra variável do Smarty:

$this->cache_lifetime = 10;

Setamos portanto, 10 segundos para que a página seja gerada novamente. Claro que esse tempo depende de que conteúdo estamos lidando e qual a necessidade de tê-lo sempre atualizado.
Vamos então a um exemplo prático… no nosso php, vamos setar um valor randômico entre 0 e 100, que a cada execução geraria um número diferente:

$smarty->assign('random', mt_rand(0, 100));

Chamando a variável {$random} no Smarty, podemos observar que o valor randômico permanece o mesmo durante 10 segundos e depois se altera novamente. Mas tem um detalhe: o cache está funcionando, mas de qualquer forma, dentro do php, o nosso conteúdo dinâmico ainda está sendo executando, tornando o cache do Smarty ainda não muito eficiente. Para isso, o Smarty nos proporciona a função is_cached(), que poderíamos chamar na nossa index:

if( !$smarty->is_cached('index.tpl') ) {
    $smarty->assign('random', mt_rand(0, 100));
}

Dessa forma, podemos verificar se o arquivo tpl já está em cache ou não… se não estiver, então mandamos executar o conteúdo dinâmico, mas se já estiver ele só lerá o arquivo gravado em cache e exibirá ao usuário.

Cachings múltiplos

Pode acontecer de precisarmos ter mais de um arquivo de cache para cada página: imagine que temos um site artigos, e que temos vários usuários que podem cadastrar artigos. Se tivermos uma página que retorna todos os artigos do usuário, precisaremos de um arquivo de cache para cada usuário, uma vez que a mesma página poderá ter vários conteúdos diferentes.

Para tornarmos isso útil, usaremos o segundo parâmetro do display():

// para não fugir do tema, vamos considerar que só usuários logados acessam a página
// e vamos considerar que $_SESSION['id_usuario'] sempre retornará um valor válido
$id_usuario = $_SESSION['id_usuario'];
// verificamos se já existe o arquivo em cache para esse usuário
if( !$smarty->is_cached('arquivo.tpl', $id_usuario) ) {
    // como não existe, vamos ao banco em busca dos artigos
    $contents = get_database_contents($id_usuario);
    $smarty->assign('contents', $contents);
}
$smarty->display('arquivo.tpl', $id_usuario);

O que acontece é que se não existir conteúdo em cache, o php vai pegar os dados do banco e quando chegar no display(), o arquivo cache será criado para o usuário testado. Se já existir o cache, então o display apenas retornará o arquivo em cache.

Observação: é preciso ter cuidado com múltiplos caches! Use-o apenas quando realmente precisa ter vários tipos de conteúdos em uma mesma página, como no exemplo. Colocar IDs em caches significa gerar mais arquivos, e se não for corretamente usado, pode ocupar um espaço desnecessariamente grande no servidor. No exemplo passado, se for um site grande, podemos ter milhares de arquivos, mas em compensação, evitaríamos acessos desnecessários ao banco que poderiam prejudicar a visita dos usuários. Já no caso de um site que não terá um fluxo de visitas suficientemente grande, aplicar essa técnica não traria uma vantagem significativa.

Desistindo do cache

Para finalizar, se por acaso quisermos parar de usar o cache, basta setar:

$this->caching = false;

podemos limpar todos os arquivos do cache com:

$smarty->clear_all_cache();

ou então, para limpar individualmente:

$smarty->clear_cache('arquivo.tpl');

Concluindo

Chegamos ao fim de mais um artigo: vimos ao longo dele 2 funcionalidades que tornam o Smarty um excelente sistema de templates, facilitando e melhorando o nosso site. Talvez depois eu faça uma terceira parte sobre a criação de plugins no Smarty.

Já demonstrei em tópicos anteriores que o Zend_View é um ótimo componente para facilitar a nossa camada view de um projeto MVC. Porém, ela não é a única: de fato, esse tipo de sistema é o que não falta para PHP, e o Smarty é uma das que se destaca.

O Smarty é uma biblioteca de template que facilita a aplicação do modelo MVC, que permite a separação do HTML e do PHP, facilitando o trabalho dos designers, que não precisam conhecer a linguagem para poder alterar o visual do site. Outras vantagens do Smarty:

• É rápido: evita o overhead que muitos sistemas de template têm, pois compila apenas uma vez
• É facilmente configurável: com pouco código podemos especificar onde estão as pastas necessárias para o funcionamento, as tags delimitadores (por padrão são “{}”), etc.
• É extensível: podemos facilmente criar plugins, e portanto, podemos adequá-lo ao nosso projeto

Primeiros Passos

1. Baixe a última versão estável do Smarty e extraia para uma pasta separada.
2. Crie uma pasta separada para o nosso projeto, e detro dela crie uma pasta chamada Smarty
3. Da pasta extraída, copie o que está dentro da pasta lib/ para a pasta Smarty do nosso projeto
4. Na pasta do projeto, crie as pastas ‘templates’, ‘templates_c’, ‘configs’ e ‘cache’
5. Crie um arquivo index.php, ainda sem nada
6. Crie um arquivo index.tpl, também sem nada

Deve ficar assim:

Apenas lembrando: eu estou usando essa estrutura apenas para facilitar as chamadas, tanto que não é recomendável deixar essas pastas na raíz. Eu poderia ter chamado o Smarty de fora do projeto, ter outros nomes de pastas auxiliares e deixá-los em outros lugares também, mas deixei assim mesmo porque a minha intenção era apenas simplificar a explicação.

Entendendo

Temos a pasta ‘Smarty’, que possui todos os arquivos da biblioteca, e temos outras 4 pastas que são usadas pelo Smarty com diferentes objetivos:

• cache: pasta usada pelo Smarty para armazenar os arquivos usados quando a opção de cache está habilitada
• configs: pasta que deve conter os arquivos de configuração ‘.conf’
• templates: pasta em que devem estar os arquivos ‘.tpl’, onde ficam os códigos html e do próprio smarty
• templates_c: pasta usada pelo Smarty para armazenar as páginas compiladas

Lembrando que eu uso esses nomes porque são ‘padrões’ de quem usa o Smarty, mas podemos muito bem alterar os nomes na hora de configurá-lo.

Mãos à obra

Vamos então fazer um pouco de código: primeiro temos que chamar o Smarty e configurá-lo, e farei isso em uma classe isolada, apenas para não precisar fazer isso em todas as páginas que usaremos o Smarty:

<?php

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

class Meu_Smarty extends Smarty {

    public function Meu_Smarty()
    {

        $this->Smarty();

        $this->template_dir    = 'templates';
        $this->compile_dir     = 'templates_c';
        $this->cache_dir       = 'cache';
        $this->config_dir      = 'configs';

        $this->left_delimiter  = '{{';
        $this->right_delimiter = '}}';

    }

}

Agora, a página index.php, que fazemos a chamada à classe e configuramos uma variável que chamaremos no tpl:

<?php

require('smarty.php');
$smarty = new Meu_Smarty();
// aqui dizemos que quermos uma variável chamada 'name' com o valor 'World'
$smarty->assign('name', 'World');
// especificamos o nome do tpl que será usado
$smarty->display('index.tpl');

?>

E finalmente o arquivo .tpl:

<html>
<head>
<title>Tutorial Smarty - Index
</head>
<body>

Hello {{$name}}!

</body>
</html>

Nada de muito trabalhoso: no index.php ‘dizemos’ ao Smarty para reconhecer uma variável chamada $nome, e no tpl chamamos-a.

Dificultando o nosso exemplo

Vamos a um processo mais difícil, mas também mais comum: queremos pegar dados de um banco de dados. Eu não vou entrar no mérito de conectar ao banco e tudo mais, mas normalmente quando fazemos isso, recebemos um array e usamos ele para mostrar os dados… então farei apenas isso, sem mudar o foco para o banco.

No index.php, teremos:

$resultado_banco = array(
    array(
        'id' => 1,
        'name' => 'Diego'
    ),
    array(
        'id' => 2,
        'name' => 'Tiago'
    ),
    array(
        'id' => 3,
        'name' => 'Paulo'
    )
);

$smarty->assign('resultado', $resultado_banco);

e no index.tpl:

<table>
    <tr>
        <th>ID</th>
        <th>Nome</th>
    </tr>
    {{section name="i" loop=$resultado}}
    <tr>
        <td>{{$resultado[i].id}}</td>
        <td>{{$resultado[i].name}}</td>
    </tr>
    {{/section}}
</table>

A grande diferença foi que usamos um comando pronto do Smarty, o {section}. Ele faz a função do loop no template, de forma que houve a iteração na variável $resultado, que era o array de resultados.
Uma coisa que precisa ser observada é a regra dos arrays no tpl, que no nosso exemplo foi o “{{$resultado[i].name}}”. A primeira vez que vi isso me perguntei “por que não {{$resultado[i]['name']}}, ou {{$resultado.i.name}}??”, mas bastou notar que ele trata índices numéricos com os conchetes e índices não numéricos com o ponto: aquele ‘i’ não é uma variável de fato, apenas um identificador de qual índice do array está sendo iterado no momento, enquanto que o ‘nome’ é o nome do índice que queremos pegar.

Conclusão

Acaba por aqui a primeira parte sobre o Smarty. Mostrei o básico, para quem não conhece, de como usar um ótimo sistema de templates para facilitar o uso das suas views, de maneira a desenvolver sem ficar aquele amontoado de código php junto do html.
Futuramente devo falar sobre coisas mais específicas do Smarty, como o uso do cache, arquivos de configuração e como criar plugins, recurso importantíssimo para estender o smarty com funcionalidades mais específicas.

Até a próxima!