def test_strict(self):
t = Template("""
% if x is UNDEFINED:
undefined
% else:
x: ${x}
% endif
""", strict_undefined=True)
assert result_lines(t.render(x=12)) == ['x: 12']
assert_raises(
NameError,
t.render, y=12
)
l = TemplateLookup(strict_undefined=True)
l.put_string("a", "some template")
l.put_string("b", """
<%namespace name='a' file='a' import='*'/>
% if x is UNDEFINED:
undefined
% else:
x: ${x}
% endif
""")
assert result_lines(t.render(x=12)) == ['x: 12']
assert_raises(
NameError,
t.render, y=12
)
def create_lookup():
lookup = TemplateLookup()
import mycartable.qrc
for file in QDir(":/templates").entryInfoList():
lookup.put_string(file.fileName(), read_qrc(file.absoluteFilePath()))
return lookup
def test_utf8_format_exceptions_pygments(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if util.py3k:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
else:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${u'привет' + foobar}""")
if util.py3k:
assert '<table class="error syntax-highlightedtable"><tr><td '\
'class="linenos"><div class="linenodiv"><pre>2</pre>'\
'</div></td><td class="code"><div class="error '\
'syntax-highlighted"><pre><span class="cp">${</span>'\
'<span class="s">'привет'</span> <span class="o">+</span> '\
'<span class="n">foobar</span><span class="cp">}</span>'\
'<span class="x"></span>' in \
result_lines(l.get_template("foo.html").render().decode('utf-8'))
else:
assert '<table class="error syntax-highlightedtable"><tr><td '\
'class="linenos"><div class="linenodiv"><pre>2</pre>'\
'</div></td><td class="code"><div class="error '\
'syntax-highlighted"><pre><span class="cp">${</span>'\
'<span class="s">u'прив'\
'ет'</span> <span class="o">+</span> '\
'<span class="n">foobar</span><span class="cp">}</span>'\
'<span class="x"></span>' in \
result_lines(l.get_template("foo.html").render().decode('utf-8'))
def test_inherited_block_nested_inner_only(self):
l = TemplateLookup()
l.put_string(
"index", """
<%inherit file="base"/>
<%block name="title">
index title
</%block>
""")
l.put_string(
"base", """
above
<%block name="header">
base header
<%block name="title">
the title
</%block>
</%block>
${next.body()}
below
""")
self._do_test(l.get_template("index"),
["above", "base header", "index title", "below"],
filters=result_lines)
def test_inherits(self):
lookup = TemplateLookup()
lookup.put_string(
"base.tmpl",
"""
<%page args="bar" />
${bar}
${pageargs['foo']}
${self.body(**pageargs)}
""",
)
lookup.put_string(
"index.tmpl",
"""
<%inherit file="base.tmpl" />
<%page args="variable" />
${variable}
""",
)
self._do_test(
lookup.get_template("index.tmpl"),
"bar foo var",
filters=flatten_result,
template_args={"variable": "var", "bar": "bar", "foo": "foo"},
)
def test_inherits(self):
lookup = TemplateLookup()
lookup.put_string(
"base.tmpl",
"""
<%page args="bar" />
${bar}
${pageargs['foo']}
${self.body(**pageargs)}
""",
)
lookup.put_string(
"index.tmpl",
"""
<%inherit file="base.tmpl" />
<%page args="variable" />
${variable}
""",
)
self._do_test(
lookup.get_template("index.tmpl"),
"bar foo var",
filters=flatten_result,
template_args={
"variable": "var",
"bar": "bar",
"foo": "foo"
},
)
def test_utf8_format_exceptions_pygments(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if compat.py3k:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
else:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${u'привет' + foobar}""")
if compat.py3k:
assert '<table class="error syntax-highlightedtable"><tr><td '\
'class="linenos"><div class="linenodiv"><pre>2</pre>'\
'</div></td><td class="code"><div class="error '\
'syntax-highlighted"><pre><span class="cp">${</span>'\
'<span class="s">'привет'</span> <span class="o">+</span> '\
'<span class="n">foobar</span><span class="cp">}</span>'\
'<span class="x"></span>' in \
result_lines(l.get_template("foo.html").render().decode('utf-8'))
else:
assert '<table class="error syntax-highlightedtable"><tr><td '\
'class="linenos"><div class="linenodiv"><pre>2</pre>'\
'</div></td><td class="code"><div class="error '\
'syntax-highlighted"><pre><span class="cp">${</span>'\
'<span class="s">u'прив'\
'ет'</span> <span class="o">+</span> '\
'<span class="n">foobar</span><span class="cp">}</span>'\
'<span class="x"></span>' in \
result_lines(l.get_template("foo.html").render().decode('utf-8'))
def test_utf8_format_exceptions_no_pygments(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if compat.py3k:
l.put_string(
"foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}"""
)
else:
l.put_string(
"foo.html",
"""# -*- coding: utf-8 -*-\n${u'привет' + foobar}""",
)
if compat.py3k:
assert (
'<div class="sourceline">${'привет' + foobar}</div>'
in result_lines(
l.get_template("foo.html").render().decode("utf-8")
)
)
else:
assert (
"${u'приве"
"т' + foobar}"
in result_lines(
l.get_template("foo.html").render().decode("utf-8")
)
)
def test_builtin_names_dont_clobber_defaults_in_includes(self):
lookup = TemplateLookup()
lookup.put_string(
"test.mako",
"""
<%include file="test1.mako"/>
""",
)
lookup.put_string(
"test1.mako",
"""
<%page args="id='foo'"/>
${id}
""",
)
for template in ("test.mako", "test1.mako"):
assert (flatten_result(
lookup.get_template(template).render()) == "foo")
assert (flatten_result(
lookup.get_template(template).render(id=5)) == "5")
assert (flatten_result(
lookup.get_template(template).render(
id=id)) == "<built-in function id>")
def test_def_overridden_by_block(self):
l = TemplateLookup()
l.put_string(
"index",
"""
<%inherit file="base"/>
<%block name="header">
inner header
</%block>
""",
)
l.put_string(
"base",
"""
above
${self.header()}
<%def name="header()">
the header
</%def>
${next.body()}
below
""",
)
self._do_test(
l.get_template("index"),
["above", "inner header", "below"],
filters=result_lines,
)
def test_no_conflict_nested_one(self):
l = TemplateLookup()
l.put_string(
"index",
"""
<%inherit file="base"/>
<%block>
<%block name="header">
inner header
</%block>
</%block>
""",
)
l.put_string(
"base",
"""
above
<%block name="header">
the header
</%block>
${next.body()}
below
""",
)
self._do_test(
l.get_template("index"),
["above", "inner header", "below"],
filters=result_lines,
)
def test_noninherited_block_no_render(self):
l = TemplateLookup()
l.put_string(
"index",
"""
<%inherit file="base"/>
<%block name="some_thing">
some thing
</%block>
""",
)
l.put_string(
"base",
"""
above
<%block name="header">
the header
</%block>
${next.body()}
below
""",
)
self._do_test(
l.get_template("index"),
["above", "the header", "some thing", "below"],
filters=result_lines,
)
def compile_template(template_dict, template_name):
"""Compile template."""
lookup = TemplateLookup(filesystem_checks=False)
for name, template in template_dict.items():
lookup.put_string(name, template)
compiled = lookup.get_template(template_name)
return compiled
def test_inherited_block_nested_inner_only(self):
l = TemplateLookup()
l.put_string("index",
"""
<%inherit file="base"/>
<%block name="title">
index title
</%block>
"""
)
l.put_string("base","""
above
<%block name="header">
base header
<%block name="title">
the title
</%block>
</%block>
${next.body()}
below
""")
self._do_test(l.get_template("index"),
["above", "base header", "index title", "below"],
filters=result_lines)
def test_lookup(self):
l = TemplateLookup(cache_impl='mock')
l.put_string("x", """
<%page cached="True" />
${y}
""")
t = l.get_template("x")
assert result_lines(t.render(y=5)) == ["5"]
assert result_lines(t.render(y=7)) == ["5"]
assert isinstance(t.cache.impl, MockCacheImpl)
def test_utf8_format_exceptions(self):
"""test that htmlentityreplace formatting is applied to exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html", """# -*- coding: utf-8 -*-
${u'привет' + foobar}
""")
assert '''<div class="highlight">2 ${u\'привет\' + foobar}</div>''' in result_lines(l.get_template("foo.html").render())
def test_utf8_format_exceptions_pygments(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html",
"""# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
assert "'привет'</span>" in l.get_template(
"foo.html").render().decode("utf-8")
def test_lookup(self):
l = TemplateLookup(cache_impl='mock')
l.put_string(
"x", """
<%page cached="True" />
${y}
""")
t = l.get_template("x")
assert result_lines(t.render(y=5)) == ["5"]
assert result_lines(t.render(y=7)) == ["5"]
assert isinstance(t.cache.impl, MockCacheImpl)
def test_basic(self):
lookup = TemplateLookup()
lookup.put_string("a", """
this is a
<%include file="b" args="a=3,b=4,c=5"/>
""")
lookup.put_string("b", """
<%page args="a,b,c"/>
this is b. ${a}, ${b}, ${c}
""")
assert flatten_result(lookup.get_template("a").render()) == "this is a this is b. 3, 4, 5"
def test_localargs(self):
lookup = TemplateLookup()
lookup.put_string("a", """
this is a
<%include file="b" args="a=a,b=b,c=5"/>
""")
lookup.put_string("b", """
<%page args="a,b,c"/>
this is b. ${a}, ${b}, ${c}
""")
assert flatten_result(lookup.get_template("a").render(a=7,b=8)) == "this is a this is b. 7, 8, 5"
def test_include_withargs(self):
lookup = TemplateLookup()
lookup.put_string("a", """
this is a
<%include file="${i}" args="c=5, **context.kwargs"/>
""")
lookup.put_string("b", """
<%page args="a,b,c"/>
this is b. ${a}, ${b}, ${c}
""")
assert flatten_result(lookup.get_template("a").render(a=7,b=8,i='b')) == "this is a this is b. 7, 8, 5"
def get_template_lookup():
try:
db_template = sqlm.EmailTemplate.query.all()
_lookup = TemplateLookup()
for template in db_template:
_lookup.put_string(template.name, template.template)
return _lookup
except IndexError:
return False
def test_loop_disabled_lookup(self):
l = TemplateLookup(enable_loop=False)
l.put_string("x", """
the loop: ${loop}
""")
self._do_test(
l.get_template("x"),
"the loop: hi",
template_args=dict(loop='hi'),
filters=flatten_result,
)
def test_format_exceptions(self):
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html", """
<%inherit file="base.html"/>
${foobar}
""")
l.put_string("base.html", """
${self.body()}
""")
assert '<div class="sourceline">${foobar}</div>' in result_lines(l.get_template("foo.html").render())
class MakoPlugin:
def __init__(self):
self.lookup = TemplateLookup(directories=['.'], output_encoding='utf-8', encoding_errors='replace')
def fill_template(self, template, bits, result):
self.lookup.put_string('actual', template)
t = self.lookup.get_template('actual')
try:
r = t.render_unicode(**bits)
except:
r = exceptions.html_error_template().render()
result.value = r
return False
def test_format_exceptions_pygments(self):
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html", """
<%inherit file="base.html"/>
${foobar}
""")
l.put_string("base.html", """
${self.body()}
""")
assert '<div class="sourceline"><table class="syntax-highlightedtable">' in \
l.get_template("foo.html").render_unicode()
def test_include_error_handler(self):
def handle(context, error):
context.write('include error')
return True
lookup = TemplateLookup(include_error_handler=handle)
lookup.put_string("a", """
this is a.
<%include file="b"/>
""")
lookup.put_string("b", """
this is b ${1/0} end.
""")
assert flatten_result(lookup.get_template("a").render()) == "this is a. this is b include error"
def test_include_error_handler(self):
def handle(context, error):
context.write('include error')
return True
lookup = TemplateLookup(include_error_handler=handle)
lookup.put_string("a", """
this is a.
<%include file="b"/>
""")
lookup.put_string("b", """
this is b ${1/0} end.
""")
assert flatten_result(lookup.get_template("a").render()) == "this is a. this is b include error"
def test_format_exceptions(self):
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html", """
<%inherit file="base.html"/>
${foobar}
""")
l.put_string("base.html", """
${self.body()}
""")
assert '<div class="sourceline">${foobar}</div>' in \
result_lines(l.get_template("foo.html").render_unicode())
def test_loop_disabled_lookup(self):
l = TemplateLookup(enable_loop=False)
l.put_string("x",
"""
the loop: ${loop}
"""
)
self._do_test(
l.get_template("x"),
"the loop: hi",
template_args=dict(loop='hi'),
filters=flatten_result,
)
class MakoBridge(TemplateBridge):
def init(self, builder, *args, **kw):
self.jinja2_fallback = BuiltinTemplateLoader()
self.jinja2_fallback.init(builder, *args, **kw)
builder.config.html_context['release_date'] = builder.config['release_date']
builder.config.html_context['site_base'] = builder.config['site_base']
self.lookup = TemplateLookup(directories=builder.config.templates_path,
#format_exceptions=True,
imports=[
"from builder import util"
]
)
if rtd:
# RTD layout, imported from sqlalchemy.org
import urllib2
template = urllib2.urlopen(builder.config['site_base'] + "/docs_adapter.mako").read()
self.lookup.put_string("docs_adapter.mako", template)
setup_ctx = urllib2.urlopen(builder.config['site_base'] + "/docs_adapter.py").read()
lcls = {}
exec(setup_ctx, lcls)
self.setup_ctx = lcls['setup_context']
def setup_ctx(self, context):
pass
def render(self, template, context):
template = template.replace(".html", ".mako")
context['prevtopic'] = context.pop('prev', None)
context['nexttopic'] = context.pop('next', None)
# local docs layout
context['rtd'] = False
context['toolbar'] = False
context['base'] = "static_base.mako"
# override context attributes
self.setup_ctx(context)
context.setdefault('_', lambda x: x)
return self.lookup.get_template(template).render_unicode(**context)
def render_string(self, template, context):
# this is used for .js, .css etc. and we don't have
# local copies of that stuff here so use the jinja render.
return self.jinja2_fallback.render_string(template, context)
class MakoPlugin:
def __init__(self):
self.lookup = TemplateLookup(directories=['.'],
output_encoding='utf-8',
encoding_errors='replace')
def fill_template(self, template, bits, result):
self.lookup.put_string('actual', template)
t = self.lookup.get_template('actual')
try:
r = t.render_unicode(**bits)
except:
r = exceptions.html_error_template().render()
result.value = r
return False
def bench_mako(runner, table_size, nparagraph, img_count):
lookup = TemplateLookup()
lookup.put_string('base.mako', BASE_TEMPLATE)
lookup.put_string('page.mako', PAGE_TEMPLATE)
template = Template(CONTENT_TEMPLATE, lookup=lookup)
table = [xrange(table_size) for i in xrange(table_size)]
paragraphs = xrange(nparagraph)
title = 'Hello world!'
func = functools.partial(template.render,
table=table, paragraphs=paragraphs,
lorem=LOREM_IPSUM, title=title,
img_count=img_count, xrange=xrange)
runner.bench_func('mako', func)
def test_loop_enabled_override_lookup(self):
l = TemplateLookup()
l.put_string(
"x", """
<%page enable_loop="True" />
% for i in (1, 2, 3):
${i} ${loop.index}
% endfor
""")
self._do_test(
l.get_template("x"),
"1 0 2 1 3 2",
template_args=dict(),
filters=flatten_result,
)
def test_block_pageargs(self):
l = TemplateLookup()
l.put_string(
"caller", """
<%include file="callee" args="val1='3', val2='4'"/>
""")
l.put_string(
"callee", """
<%block name="foob">
foob, ${pageargs['val1']}, ${pageargs['val2']}
</%block>
""")
self._do_test(l.get_template("caller"), ['foob, 3, 4'],
filters=result_lines)
def test_loop_enabled_override_lookup(self):
l = TemplateLookup()
l.put_string("x",
"""
<%page enable_loop="True" />
% for i in (1, 2, 3):
${i} ${loop.index}
% endfor
"""
)
self._do_test(
l.get_template("x"),
"1 0 2 1 3 2",
template_args=dict(),
filters=flatten_result,
)
def test_utf8_format_exceptions(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if util.py3k:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
else:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${u'привет' + foobar}""")
if util.py3k:
assert u'<div class="sourceline">${'привет' + foobar}</div>'\
in result_lines(l.get_template("foo.html").render().decode('utf-8'))
else:
assert '<div class="highlight">2 ${u'пр'\
'ивет' + foobar}</div>' \
in result_lines(l.get_template("foo.html").render().decode('utf-8'))
def test_utf8_format_exceptions(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if util.py3k:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
else:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${u'привет' + foobar}""")
if util.py3k:
assert u'<div class="sourceline">${\'привет\' + foobar}</div>'\
in result_lines(l.get_template("foo.html").render().decode('utf-8'))
else:
assert '<div class="highlight">2 ${u\'пр'\
'ивет\' + foobar}</div>' \
in result_lines(l.get_template("foo.html").render().decode('utf-8'))
def test_template_lookup(self):
try:
from mako.lookup import TemplateLookup
except ImportError:
return
lookup = TemplateLookup()
lookup.put_string("base.html", '''
<%
import time
time.sleep(0.01)
%>
<html><body></body></html>
''')
template = lookup.get_template("base.html")
template.render_unicode()
stats, result = get_local_storage(local_timing).get_thread_stats()
self.assertEqual(len(result), 1)
def test_template_lookup(self):
try:
from mako.lookup import TemplateLookup
except ImportError:
return
lookup = TemplateLookup()
lookup.put_string("base.html", '''
<%
import time
time.sleep(0.01)
%>
<html><body></body></html>
''')
template = lookup.get_template("base.html")
template.render_unicode()
stats, result = get_local_storage(local_timing).get_thread_stats()
self.assertEqual(len(result), 1)
def test_utf8_format_exceptions_pygments(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if compat.py3k:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
else:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${u'привет' + foobar}""")
if compat.py3k:
assert ''привет'</span>' in \
l.get_template("foo.html").render().decode('utf-8')
else:
assert ''прив'\
'ет'</span>' in \
l.get_template("foo.html").render().decode('utf-8')
def test_block_pageargs(self):
l = TemplateLookup()
l.put_string("caller", """
<%include file="callee" args="val1='3', val2='4'"/>
""")
l.put_string("callee", """
<%block name="foob">
foob, ${pageargs['val1']}, ${pageargs['val2']}
</%block>
""")
self._do_test(
l.get_template("caller"),
[u'foob, 3, 4'],
filters=result_lines
)
def test_utf8_format_exceptions_no_pygments(self):
"""test that htmlentityreplace formatting is applied to
exceptions reported with format_exceptions=True"""
l = TemplateLookup(format_exceptions=True)
if compat.py3k:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${'привет' + foobar}""")
else:
l.put_string("foo.html", """# -*- coding: utf-8 -*-\n${u'привет' + foobar}""")
if compat.py3k:
assert '<div class="sourceline">${'привет' + foobar}</div>'\
in result_lines(l.get_template("foo.html").render().decode('utf-8'))
else:
assert '${u'приве'\
'т' + foobar}' in \
result_lines(l.get_template("foo.html").render().decode('utf-8'))
def test_viakwargs(self):
lookup = TemplateLookup()
lookup.put_string(
"a",
"""
this is a
<%include file="b" args="c=5, **context.kwargs"/>
""",
)
lookup.put_string(
"b",
"""
<%page args="a,b,c"/>
this is b. ${a}, ${b}, ${c}
""",
)
# print lookup.get_template("a").code
assert flatten_result(lookup.get_template("a").render(a=7, b=8)) == "this is a this is b. 7, 8, 5"
def test_builtin_names_dont_clobber_defaults_in_includes(self):
lookup = TemplateLookup()
lookup.put_string("test.mako",
"""
<%include file="test1.mako"/>
""")
lookup.put_string("test1.mako", """
<%page args="id='foo'"/>
${id}
""")
for template in ("test.mako", "test1.mako"):
assert flatten_result(lookup.get_template(template).render()) == "foo"
assert flatten_result(lookup.get_template(template).render(id=5)) == "5"
assert flatten_result(lookup.get_template(template).render(id=id)) == "<built-in function id>"
def test_format_exceptions_pygments(self):
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html", """
<%inherit file="base.html"/>
${foobar}
""")
l.put_string("base.html", """
${self.body()}
""")
assert '<div class="sourceline"><table class="syntax-highlightedtable">'\
'<tr><td class="linenos"><div class="linenodiv"><pre>3</pre>'\
'</div></td><td class="code"><div class="syntax-highlighted">'\
'<pre><span class="err">$</span><span class="p">{</span>'\
'<span class="n">foobar</span><span class="p">}</span>' in \
result_lines(l.get_template("foo.html").render_unicode())
def test_format_exceptions_pygments(self):
l = TemplateLookup(format_exceptions=True)
l.put_string("foo.html", """
<%inherit file="base.html"/>
${foobar}
""")
l.put_string("base.html", """
${self.body()}
""")
assert '<div class="sourceline"><table class="syntax-highlightedtable">'\
'<tr><td class="linenos"><div class="linenodiv"><pre>3</pre>'\
'</div></td><td class="code"><div class="syntax-highlighted">'\
'<pre><span class="err">$</span><span class="p">{</span>'\
'<span class="n">foobar</span><span class="p">}</span>' in \
result_lines(l.get_template("foo.html").render_unicode())
def test_viakwargs(self):
lookup = TemplateLookup()
lookup.put_string(
"a",
"""
this is a
<%include file="b" args="c=5, **context.kwargs"/>
""",
)
lookup.put_string(
"b",
"""
<%page args="a,b,c"/>
this is b. ${a}, ${b}, ${c}
""",
)
# print lookup.get_template("a").code
assert (flatten_result(lookup.get_template("a").render(
a=7, b=8)) == "this is a this is b. 7, 8, 5")
def test_mako(count):
lookup = TemplateLookup()
lookup.put_string('base.mako', BASE_TEMPLATE)
lookup.put_string('page.mako', PAGE_TEMPLATE)
template = Template(CONTENT_TEMPLATE, lookup=lookup)
table = [xrange(150) for i in xrange(150)]
paragraphs = xrange(50)
title = 'Hello world!'
times = []
for i in range(count):
t0 = time.time()
data = template.render(table=table, paragraphs=paragraphs,
lorem=LOREM_IPSUM, title=title,
img_count=50)
t1 = time.time()
times.append(t1-t0)
return times
def gen_hook_function_code(data, templates={}):
lookup = TemplateLookup(strict_undefined=True)
lookup.put_string("hook", HOOK_TEMPLATE)
lookup.put_string("pre", PREHOOK_TEMPLATE)
lookup.put_string("post", POSTHOOK_TEMPLATE)
tm = lookup.get_template(data["hook"].type)
return tm.render(**data)
def test_includes(self):
lookup = TemplateLookup()
lookup.put_string("incl1.tmpl",
"""
<%page args="bar" />
${bar}
${pageargs['foo']}
"""
)
lookup.put_string("incl2.tmpl",
"""
${pageargs}
"""
)
lookup.put_string("index.tmpl", """
<%include file="incl1.tmpl" args="**pageargs"/>
<%page args="variable" />
${variable}
<%include file="incl2.tmpl" />
""")
self._do_test(
lookup.get_template("index.tmpl"),
"bar foo var {}",
filters=flatten_result,
template_args={'variable':'var', 'bar':'bar', 'foo':'foo'}
)
def test_two_levels_one(self):
l = TemplateLookup()
l.put_string("index",
"""
<%inherit file="middle"/>
<%block name="header">
index header
</%block>
<%block>
index anon
</%block>
"""
)
l.put_string("middle", """
<%inherit file="base"/>
<%block>
middle anon
</%block>
${next.body()}
""")
l.put_string("base","""
above
<%block name="header">
the header
</%block>
${next.body()}
below
""")
self._do_test(l.get_template("index"),
["above", "index header", "middle anon",
"index anon", "below"],
filters=result_lines)
def test_block_overridden_by_def(self):
l = TemplateLookup()
l.put_string("index",
"""
<%inherit file="base"/>
<%def name="header()">
inner header
</%def>
"""
)
l.put_string("base","""
above
<%block name="header">
the header
</%block>
${next.body()}
below
""")
self._do_test(l.get_template("index"),
["above", "inner header", "below"],
filters=result_lines)
