Selecionando um idioma

Por angelobeck
, em 9 dezembro de 2013 às 18:49

Tutoriais

Um documento possui vários campos, tais como título, subtítulo, conteúdo, etc. Estes campos precisam ser guardados separadamente para que possam ser inseridos no local adequado do modelo.

Mas um documento também pode estar traduzido em diversos idiomas. Se quisermos guardar cada tradução como um documento separado, teremos como resultado uma tremenda confusão de páginas e mais confuso ainda será administrá-las.

Vamos guardar todas as traduções de um documento em um mesmo local. Para isto, cada campo do documento será um arranjo (array) onde poderemos guardar os conteúdos em cada idioma separadamente. Isto facilita encontrarmos um texto alternativo quando não houver um conteúdo no idioma do documento.

Vejamos: cada documento possui um conjunto de campos. Cada campo é um conjunto com um ou mais idiomas. E cada idioma é também um conjunto de dados onde consta o conteúdo e outras informações.

Normalmente, os campos de um documento são:

$caption: uma legenda que representa o documento no menu de seções
$title: o título do documento
$subtitle: um subtítulo
$description: uma descrição, que poderá ser utilizada no cabeçalho HTML ou para descrever o documento em uma lista
$content: o conteúdo
$secondcontent: o conteúdo inferior – normalmente abaixo da lista da seção ou de uma foto

Os idiomas são duas letras representando o idioma, como “pt“, “en“, “fr“, “de“, etc.

Um conteúdo é um arranjo que poderá conter os seguintes campos:

1 => TEXT_CONTENT: O conteúdo propriamente dito
2 => TEXT_CHARSET: o conjunto de caractéres no qual o conteúdo está codificado. Se 1, ISO-8859-1; se omitido, UTF-8.
3 => TEXT_LANG: quando um idioma foi selecionado, este campo conterá o nome do idioma (‘pt‘, ‘en‘, etc).
4 => TEXT_FORMAT: se 1, indica que o conteúdo deverá ser formatado; se omitido, não.
5 => TEXT_HTML: se 1, permite HTML de forma filtrada; se 2, permite qualquer código HTML; se omitido (por padrão), nenhum código HTML é permitido.
6 => TEXT_ECOLABORE: se 1, processa as marcações entre colchetes; se omitido (por padrão), elas serão escapadas.

O exemplo que daremos agora nos servirá para testes posteriores. Por isto, vamos salvá-lo em um arquivo – chamaremos de “content.txt”.

'caption'={
     'pt'={
          1='Documento teste'
          2=1
      }
      'en'={
           1='Testing document'
           2=1
       }
    }
    'title'={
        'pt'={
             1='Documento teste'
             2=1
         }
        'en'={
            1='Testing document'
            2=1
         }
     }
 'description'={
     'pt'={
         1='Este documento somente serve para testar nossa técnica'
         2=1
     }
}
    'content'={
        'pt'={
            1='Este documento tem por finalidade testar nosso conhecimento.


Vamos testar tudo o que fizemos até aqui:

     1.??Se conseguimos guardar diversos campos em um arquivo de texto,
     2.se o conteúdo é colocado corretamente no modelo,
     3.se o idioma é selecionado corretamente,
     4.se o conteúdo é formatado como esperamos e
     5.se marcações <s>HTML</s> serão <i>filtradas</i> ou <a href="">rejeitadas</a>.

'
       2=1
       4=1
       5=1
       6=1
    }
}

Para testarmos, vamos criar um modelo. Coloquemo-lo no arquivo “template.txt“, com o seguinte conteúdo:

<html lang="[$lang]">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=[$charset]">
        <meta name="title" content="[text:title]">
            [if:description]
                 <meta name="description" content="[text:description]">
            [/if]
        <title>[text:title]</title>
    </head>
    <body>
        [if:title]
            <h1>[text:title]</h1>
        [/if]
        [text:content]
    </body>
</html>

Agora, vamos à nossa função. Para que [text:title] ou [text:content] sejam capazes de realizar alguma coisa, precisamos criar uma função tag_text(), que será chamada no momento adequado.

// Para facilitar a identificação dos campos
define ('TEXT_CONTENT', 1);
define ('TEXT_CHARSET', 2);
define ('TEXT_LANG', 3);
define ('TEXT_FORMAT', 4);
define ('TEXT_HTML', 5);
define ('TEXT_ECOLABORE', 6);

function tag_text ($render, $array, $index)
    { // tag text

        // Os conjuntos de caractéres
        static $cs = array (0=>'UTF-8', 1=>'ISO-8859-1');

        // Vamos encontrar o nome do campo selecionado
        $field_name = $array[$index]['arguments'];
        if ($field_name[0] == '$')
            $field_name = substr ($field_name, 1); // remove "$" do início do nome

            // Se não houver um argumento
        if (!strlen ($field_name))
            $field_name = 'caption';

            // Se o campo não existir
        if (!is_array ($render['scope'][$field_name]))
            return;

            // O campo encontrado
            $field = $render['scope'][$field_name];
            // O idioma do documento
            $lang = $render['scope']['lang'];
            // A codificação do documento
            $charset = $render['scope']['charset'];

            // Vamos procurar o conteúdo no idioma do documento
        if (isset ($field[$lang]))
            { // document lang
                $content = $field[$lang];
            } // document lang

        // Se não for encontrado, qualquer outro idioma serve
        else
            { // try other
                $temp = each ($field);
                $content = $temp[1];
            } // try other

           // Se não for especificada uma codificação
        if (!isset ($content[TEXT_CHARSET])) $content[TEXT_CHARSET] = 0; // UTF-8
            // Se não for especificado como o HTML deve ser filtrado
        if (!isset ($content[TEXT_HTML])) $content[TEXT_HTML] = 0; // HTML não permitido

            // Se o conteúdo estiver em uma codificação diferente da do documento
        if ($cs[$content[TEXT_CHARSET]] != $charset)
            $content[TEXT_CONTENT] = mb_convert_encoding ($content[TEXT_CONTENT], $charset,         $cs[$content[TEXT_CHARSET]]);

             // O texto precisará ser formatado?
         if (isset ($content[TEXT_FORMAT]))
             $result = text2html ($content[TEXT_CONTENT], $content[TEXT_HTML]);

             // Se não precisar ser formatado, vamos filtrar o HTML
         else
             $result = filter_html ($content[TEXT_CONTENT], $content[TEXT_HTML]);

             // Se precisarmos avaliar as marcações ecolabore
         if (isset ($content[TEXT_ECOLABORE]))
             render_tags ($result, $render);

             // outro caso, adicionaremos o resultado ao buffer
         else
             $render['buffer'] .= $result;
     } // tag text

Para testar, vamos reunir todo o conhecimento acumulado até aqui. Quero dizer que utilizaremos todas as funções que criamos nos capítulos anteriores. Para facilitar, coloque cada função em um arquivo separado. Recomendo nomear o arquivo com o nome da função. Agora vamos criar um arquivo, o “index.php”, onde realizaremos o grande teste! ?

<?php

    // Vamos incluir as funções que criamos desde o início
    include_once 'string2array.php';
    include_once 'filter_html.php';
    include_once 'text2html.php';
    include_once 'render_tags.php';
    include_once 'condition.php';
    include_once 'tag_text.php';

    // Onde o documento será criado
    $render['buffer'] = '';

    // Vamos abrir o nosso arquivo de dados
    $string = file_get_contents ('content.txt');
    $render['scope'] = string2array ($string);
    // O idioma do documento
    $render['scope']['lang'] = 'pt';
    // A codificação do documento
    $render['scope']['charset'] = 'ISO-8859-1';

    // Vamos abrir o modelo
    $template = file_get_contents ('template.txt');

    // Vamos à grande prova!
    render_tags ($template, $render);

    // Vamos enviar o documento criado
    print $render['buffer'];

?>

Se tudo der certo, você verá um belo documento no seu navegador.

Experimente alterar o idioma e/ou a codificação do documento:

// O idioma do documento
$render['scope']['lang'] = 'en';
// A codificação do documento
$render['scope']['charset'] = 'UTF-8';

Se você tem instinto aventureiro, já deve estar pensando como será fácil criar modelos e editar o conteúdo dos documentos do seu site com estas funções.

Mas vamos com calma. Na verdade, deixaremos tudo isto de lado, pois precisamos aprender a programação orientada a objeto. Não se desespere! Não vamos descartar tudo isto que aprendemos até aqui. Apenas vamos utilizar todo este conhecimento de uma outra forma.

Uma grande parte do trabalho que nosso gerenciador de conteúdos irá realizar consiste em processar o documento de uma forma bastante semelhante à esta que acabamos de construir. É claro que futuramente iremos extender as capacidades das nossas marcações “ecolabore”, mas agora, precisamos passar para uma outra tarefa também importante: encontrar qual o conteúdo que o usuário deseja ver.

Claro! Todo este trabalho só será justificado se ele puder ser utilizado em diversas situações. Mas o que conseguimos até agora foi abrir um conteúdo e um modelo e construir um documento baseado nestes dois arquivos. Precisamos de um mecanismo fácil para abrir diversos conteúdos e modelos. Melhor ainda se tivermos ferramentas para criar, editar e apagar as páginas do nosso site.

Faremos tudo isto e muito, muito mais! Se segura porque a aventura vai começar!