def setUp(self):
from wheezy.template.engine import Engine
from wheezy.template.ext.core import CoreExtension
from wheezy.template.loader import DictLoader
self.engine = Engine(loader=DictLoader({}),
extensions=[CoreExtension()])
try:
from wheezy.template.engine import Engine
from wheezy.template.loader import DictLoader
from wheezy.template.ext.core import CoreExtension
except ImportError:
test_wheezy_template = None
else:
engine = Engine(loader=DictLoader({
'x':
s("""\
@require(table)
<table>
@for row in table:
<tr>
@for key, value in row.items():
<td>@key!h</td><td>@value!s</td>
@end
</tr>
@end
</table>
""")
}),
extensions=[CoreExtension()])
engine.global_vars.update({'h': escape})
wheezy_template = engine.get_template('x')
def test_wheezy_template():
return wheezy_template.render(ctx)
def tohtml(self):
path = os.path.join(os.path.dirname(__file__), 'reader.html.template')
loader = DictLoader({'reader': open(path).read()})
engine = Engine(loader=loader, extensions=[CoreExtension()])
template = engine.get_template('reader')
return template.render({'feed': self}).encode('utf-8')
class Engine(BaseEngine):
def render(self, name, ctx, local_defs, super_defs):
super_defs['__super__'] = s = {}
return super(Engine, self).render(name, ctx, local_defs, s)
def super_token(m):
i = m.end(1) - m.start(1)
end, name, value = var_token(m)
s = 'super_defs["__super__"]["' + value[:i] + '"]' + value[i:]
return end, 'var', s
core = CoreExtension()
core.lexer_rules[150] = (re.compile(r'@super\.(\w+)'), super_token)
engine = Engine(loader=DictLoader(pages), extensions=[core])
class TestCase(unittest.TestCase):
def test_render(self):
template = engine.get_template('page_b')
r = template.render({})
assert ['b', 'a', 'super'] == r.split()
if __name__ == '__main__':
unittest.main()
class EscapeExtension(object):
builder_rules = [("var", build_var)]
# setup
template = """
@require(var)
@def x(s):
<meta name="@s" />
@end
@var @var!e @var!s @x(var)!safe
"""
engine = Engine(
loader=DictLoader({"template": template}),
extensions=[EscapeExtension(), CoreExtension()],
)
engine.global_vars.update({"e": escape})
# test
class TestCase(unittest.TestCase):
def test_render(self) -> None:
template = engine.get_template("template")
r = template.render({"var": "<X>"})
self.assertEqual('<X> <X> <X> <meta name="<X>" />',
r.strip())
r = template.render({"var": "X"})
self.assertEqual('X X X <meta name="X" />', r.strip())
</form>
<script>
window.onload=function()
{
c = document.getElementById('captcha');
c.onclick = function() {
this.src=this.src.replace(/&r=\d+/g,'') + '&r=' + \
Math.floor(Math.random() * 100 + 1);
};
}
</script>
</body></html>"""
}
engine = Engine(
loader=DictLoader(templates),
extensions=[CoreExtension(),
WidgetExtension(),
WhitespaceExtension()])
all_urls = [('', WelcomeHandler),
url('captcha.jpg', captcha_handler, name='captcha')]
options = {'http_cache': cache, 'render_template': WheezyTemplate(engine)}
main = WSGIApplication([
bootstrap_defaults(url_mapping=all_urls), http_cache_middleware_factory,
path_routing_middleware_factory
], options)
if __name__ == '__main__':
from wsgiref.handlers import BaseHandler
import unittest
from wheezy.template.engine import Engine
from wheezy.template.ext.core import CoreExtension
from wheezy.template.loader import DictLoader
page_a = 'a'
page_b = 'b'
page_c = """
@require(name)
@include('page_' + name)
"""
pages = {'page_a': page_a, 'page_b': page_b, 'page_c': page_c}
engine = Engine(loader=DictLoader(pages), extensions=[CoreExtension()])
class TestCase(unittest.TestCase):
def test_render(self):
template = engine.get_template('page_c')
r = template.render({'name': 'a'})
self.assertEqual('a', r.strip())
r = template.render({'name': 'b'})
self.assertEqual('b', r.strip())
if __name__ == '__main__':
unittest.main()
def setUp(self) -> None:
self.templates: typing.Dict[str, str] = {}
self.engine = Engine(
loader=DictLoader(templates=self.templates),
extensions=[CoreExtension()],
)
def setUp(self):
from wheezy.template.engine import Engine
from wheezy.template.loader import DictLoader
self.engine = Engine(
loader=DictLoader(templates={}),
extensions=[])
def setUp(self) -> None:
self.engine = Engine(loader=DictLoader({}),
extensions=[CoreExtension()])
def compile_template(template_dict, template_name):
"""Compile template."""
engine = Engine(loader=DictLoader(template_dict), extensions=[CoreExtension()])
compiled = engine.get_template(template_name)
return compiled
def setUp(self):
from wheezy.template.loader import DictLoader
self.loader = DictLoader(templates={
'tmpl1.html': 'x',
'shared/master.html': 'x'
})
def setUp(self) -> None:
self.loader = DictLoader(templates={
"tmpl1.html": "x",
"shared/master.html": "x"
})
"page_b": page_b,
"page_all": page_all,
}
def build_include(builder: Builder, lineno: int, token: str,
value: str) -> bool:
assert token == "include"
builder.add(lineno, "w(_r(" + value + ", ctx, {}, {}))")
return True
class MyExtention(object):
builder_rules = [("include", build_include)]
engine = Engine(loader=DictLoader(pages),
extensions=[MyExtention(), CoreExtension()])
class TestCase(unittest.TestCase):
def test_render(self) -> None:
template = engine.get_template("page_all")
r = template.render({})
self.assertEqual(["a", "b"], r.split())
if __name__ == "__main__":
unittest.main()
