Linguagem de template YATL

py4web usa Python para os seus templates, controladores e pontos de vista, embora ele usa uma sintaxe Python ligeiramente modificada nas vistas para permitir que o código mais legível, sem impor quaisquer restrições sobre o uso adequado Python.

usos py4web `` [[…]] `` para escapar código Python embutido em HTML. A vantagem de usar colchetes em vez de colchetes é que é transparente para todos os editores comum HTML. Isso permite que o desenvolvedor usar esses editores para criar visualizações py4web.

Desde o desenvolvedor está incorporação de código Python em HTML, o documento deve ser recuado de acordo com as regras HTML, e não regras Python. Portanto, permitimos que sem recuo Python dentro das `` [[…]] `` tags. Desde Python normalmente usa recuo para delimitar blocos de código, precisamos de uma maneira diferente para delimitá-los; é por isso que as marcas de linguagem template py4web usar da palavra-chave Python `` pass``.

Um bloco de código é iniciado com uma linha que termina com dois pontos e as extremidades com uma linha que se inicia com `` pass``. A palavra-chave `` pass`` não é necessário quando o fim do bloco é óbvio a partir do contexto.

Aqui está um exemplo:

[[
if i == 0:
response.write('i is 0')
else:
response.write('i is not 0')
pass
]]

Note que `` pass`` é uma palavra-chave Python, não uma palavra-chave py4web. Alguns editores Python, como Emacs, use a palavra-chave `` pass`` para significar a divisão de blocos e usá-lo para o código re-indent automaticamente.

O linguagem de template py4web faz exatamente a mesma. Quando encontra algo como:

<html><body>
[[for x in range(10):]][[=x]]hello<br />[[pass]]
</body></html>

que traduz em um programa:

response.write("""<html><body>""", escape=False)
for x in range(10):
    response.write(x)
    response.write("""hello<br />""", escape=False)
response.write("""</body></html>""", escape=False)

`` Response.write`` escreve para o `` response.body``.

Quando há um erro em uma visão py4web, o relatório de erro mostra o código gerado vista, e não o ponto de vista real como escrito pelo desenvolvedor. Isso ajuda o desenvolvedor de depuração do código, destacando o código real que é executado (que é algo que pode ser depurado com um editor de HTML ou o inspetor DOM do navegador).

Observe também que:

[[=x]]

gera

response.write(x)

Variáveis ​​injetadas no HTML desta forma são escapou por padrão. O escape é ignorado se `` x`` é um objeto `` XML``, mesmo que escape é definida como `` True``.

Aqui está um exemplo que introduz o `` H1`` helper:

[[=H1(i)]]

que é traduzido para:

response.write(H1(i))

mediante avaliação, o objeto `` H1`` e seus componentes são recursivamente serializados, escapou e escrita para o corpo da resposta. As tags gerados pelo `` H1`` e HTML interior não escapamos. Este mecanismo garante que todo o texto - e somente texto - exibido na página web é sempre escaparam, evitando assim vulnerabilidades XSS. Ao mesmo tempo, o código é simples e fácil de depurar.

O método `` response.write (obj, escapar = True) `` recebe dois argumentos, o objeto a ser escrito e se ele tem que ser escapado (definido como `` True`` por padrão). Se `` obj`` tem um `` .xml () `` método, ele é chamado e o resultado escrito para o corpo da resposta (o argumento `` escape`` é ignorado). Caso contrário, ele usa `` __str__`` o método do objeto para serializar-lo e, se o argumento fuga é `` True``, lhe escapa. Todos os built-in helper objetos ( `` H1`` no exemplo) são objetos que sabem como serializar-se através do `` .xml () `` método.

Isso tudo é feito de forma transparente. Você nunca precisa (e não deve) chamar o método response.write` explicitamente.

Sintaxe básica

O linguagem de template py4web suporta todas as estruturas de controle Python. Aqui nós fornecemos alguns exemplos de cada um deles. Eles podem ser aninhados de acordo com a prática de programação habitual.

`` Para … in``

Em templates você pode fazer um loop sobre qualquer objeto iterável:

[[items = ['a', 'b', 'c']]]
<ul>
[[for item in items:]]<li>[[=item]]</li>[[pass]]
</ul>

que produz:

<ul>
<li>a</li>
<li>b</li>
<li>c</li>
</ul>

Aqui `` items`` é qualquer objeto iterável como uma lista Python, Python tupla, ou linhas objeto, ou qualquer objeto que é implementado como um iterador. Os elementos apresentados são primeiro serializado e escapou.

`` While``

Você pode criar um loop usando a palavra-chave, enquanto:

[[k = 3]]
<ul>
[[while k > 0:]]<li>[[=k]][[k = k - 1]]</li>[[pass]]
</ul>

que produz:

<ul>
<li>3</li>
<li>2</li>
<li>1</li>
</ul>

`` If … elif … else``

Você pode usar cláusulas condicionais:

[[
import random
k = random.randint(0, 100)
]]
<h2>
[[=k]]
[[if k % 2:]]is odd[[else:]]is even[[pass]]
</h2>

que produz:

<h2>
45 is odd
</h2>

Uma vez que é óbvio que `` else`` encerra a primeira `` if`` bloco, não há necessidade de um `` declaração pass``, e usando um seria incorreto. No entanto, você deve fechar explicitamente a opção `` bloco else`` com um `` pass``.

Lembre-se que, em Python “else if” está escrito `` elif`` como no exemplo a seguir:

[[
import random
k = random.randint(0, 100)
]]
<h2>
[[=k]]
[[if k % 4 == 0:]]is divisible by 4
[[elif k % 2 == 0:]]is even
[[else:]]is odd
[[pass]]
</h2>

Produz:

<h2>
64 is divisible by 4
</h2>

`` Tentar … exceto … else … finally``

Também é possível usar `` tentar … declarações except`` nas vistas com uma ressalva. Considere o seguinte exemplo:

[[try:]]
Hello [[= 1 / 0]]
[[except:]]
division by zero
[[else:]]
no division by zero
[[finally:]]
<br />
[[pass]]

Ela irá produzir o seguinte resultado:

Hello division by zero
<br />

Este exemplo ilustra que todas as saídas gerado antes de ocorrer uma exceção é processado (incluindo a saída que precedeu a excepção) no interior do bloco de teste. “Olá” é escrito porque precede a exceção.

`` Def … return``

O linguagem de template py4web permite ao desenvolvedor definir e implementar funções que podem retornar qualquer objeto Python ou uma cadeia de texto / html. Aqui, consideramos dois exemplos:

[[def itemize1(link): return LI(A(link, _href="http://" + link))]]
<ul>
[[=itemize1('www.google.com')]]
</ul>

produz o seguinte resultado:

<ul>
<li><a href="http:/www.google.com">www.google.com</a></li>
</ul>

A função `` itemize1`` devolve um objecto auxiliar que é inserido no local em que a função é chamada.

Considere agora o seguinte código:

[[def itemize2(link):]]
<li><a href="http://[[=link]]">[[=link]]</a></li>
[[return]]
<ul>
[[itemize2('www.google.com')]]
</ul>

Ela produz exactamente o mesmo resultado como acima. Neste caso, a função `` itemize2`` representa um pedaço de HTML que vai substituir a tag py4web onde a função é chamada. Observe que não existe ‘=’ na frente da chamada para `` itemize2``, já que a função não retornar o texto, mas escreve-lo diretamente para a resposta.

Há uma ressalva: funções definidas dentro de uma visão deve terminar com uma declaração `` return``, ou o recuo automático falhará.