Python moteur de template

Il y a beaucoup de puissants modèles langues prises en charge par Python. Je préfère Jinja2. Jetez aussi un oeil à Mako et Genshi.

Mako est le plus rapide parmi les trois, mais c'est l'idéologie qui permet d'avoir un code complexe logique de droit dans le modèle de provoquer MVC principes violation de temps à autre.

Genshi a une excellente conception, particulièrement puissante fonctionnalité est inversée l'héritage de template. Mais il est plus lent chez les trois et comme le montre la pratique de toutes ses fonctionnalités sont souvent surdimensionnés en projet réel.

Jinja2 d'or est un milieu dans mon opinion personnelle. Il est facilement extensible, très rapide et familier à de nombreux puisqu'il utiliser une syntaxe similaire aux modèles Django et Liquide modèle de langue.

OriginalL'auteur nkrkv

Bien, quand je décide de jouer comme vous l'avez fait, TDD est toujours une bonne façon d'aller.

alors, pourquoi ne pas lui donner un aller?

par exemple, créez un fichier appelé jturo_template.py et d'écrire:

import re
import unittest
class JTuroTemplate(object):
u"""JTuro's template engine core class"""
variable_regex = r'\$\{((.*)(%s)([^}]*))*\}'
def __init__(self, string):
self.string = string
def __repr__(self):
pieces = self.string.split()
if len(pieces) > 3:
head = "%s ..." % " ".join(pieces[:3])
else:
head = " ".join(pieces)
return u'<JTuroTemplate: "%s">' % (head)
def render(self, context):
new = unicode(self.string)
for key, value in context.items():
variable_name = re.escape(key)
regex = re.compile(self.variable_regex % variable_name)
for match in regex.findall(new):
if match[0]:
replacement = match[0].replace(key, repr(value))
new = new.replace('${%s}' % match[0], unicode(eval(replacement)))
return new
class TestJTuroTemplate(unittest.TestCase):
def test_repr(self):
"a instance will be nicely represented"
jt = JTuroTemplate('my template')
self.assertEquals(repr(jt), '<JTuroTemplate: "my template">')
def test_repr_truncated(self):
"the python representation is truncated after 3 words"
jt = JTuroTemplate('such a long string template')
self.assertEquals(repr(jt), '<JTuroTemplate: "such a long ...">')
def test_solves_simple_variables(self):
"it solves simple variables"
jt = JTuroTemplate('my variable is ${var} == 4')
self.assertEquals(jt.render({'var': '4'}), 'my variable is 4 == 4')
def test_solves_variables_with_python_code(self):
"it solves variables with python code"
jt = JTuroTemplate('my variable is ${var + var} == 44')
self.assertEquals(jt.render({'var': '4'}), 'my variable is 44 == 44')
if __name__ == '__main__':
unittest.main()

Désolé pour le long post, mais je pense que vous pouvez essayer ce flux de travail:

1. test d'écriture qui ne
2. exécuter et de le regarder à l'échec
3. écrire du code pour faire le test pass
4. exécuter à nouveau et de le regarder passer

OriginalL'auteur Gabriel Falcão