def test_template_comment(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<!-- !foo -->
<!--!bar-->
</div>""")
self.assertEqual("""<div>
</div>""", str(tmpl.generate()))
def test_relative_include_without_loader_relative(self):
file1 = open(os.path.join(self.dirname, "tmpl1.html"), "w")
try:
file1.write("""<div>Included</div>""")
finally:
file1.close()
file2 = open(os.path.join(self.dirname, "tmpl2.html"), "w")
try:
file2.write(
"""<html xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="tmpl1.html" />
</html>"""
)
finally:
file2.close()
tmpl = MarkupTemplate(
"""<html xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="tmpl1.html" />
</html>""",
filename=os.path.join(self.dirname, "tmpl2.html"),
)
self.assertEqual(
"""<html>
<div>Included</div>
</html>""",
tmpl.generate().render(encoding=None),
)
def test_latin1_encoded_explicit_encoding(self):
tmpl = MarkupTemplate(u"""<div xmlns:py="http://genshi.edgewall.org/">
\xf6
</div>""".encode('iso-8859-1'), encoding='iso-8859-1')
self.assertEqual(u"""<div>
\xf6
</div>""", unicode(tmpl.generate()))
def test_directive_element(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:if test="myvar">bar</py:if>
</div>""")
self.assertEqual("""<div>
bar
</div>""", str(tmpl.generate(myvar='"foo"')))
def test_latin1_encoded_with_xmldecl(self):
tmpl = MarkupTemplate(u"""<?xml version="1.0" encoding="iso-8859-1" ?>
<div xmlns:py="http://genshi.edgewall.org/">
\xf6
</div>""".encode('iso-8859-1'), encoding='iso-8859-1')
self.assertEqual(u"""<?xml version="1.0" encoding="iso-8859-1"?>\n<div>
\xf6
</div>""", unicode(tmpl.generate()))
def test_exec_import(self):
tmpl = MarkupTemplate("""<?python from datetime import timedelta ?>
<div xmlns:py="http://genshi.edgewall.org/">
${timedelta(days=2)}
</div>""")
self.assertEqual("""<div>
2 days, 0:00:00
</div>""", str(tmpl.generate()))
def test_lazy_string_with_genshi(self):
# See https://github.com/TurboGears/tg2/pull/68
from genshi.template.markup import MarkupTemplate
markup = """<b xmlns:py="http://genshi.edgewall.org/">${foo}</b>"""
template = MarkupTemplate(markup)
stream = template.generate(foo=LazyString(lambda: "bar"))
output = str(stream) # Contains only ascii char, so it should cast fine on both py2 and py3
assert output == '<b>bar</b>', output
def test_parse_with_same_namespace_nested(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<span xmlns:py="http://genshi.edgewall.org/">
</span>
</div>""")
self.assertEqual("""<div>
<span>
</span>
</div>""", str(tmpl.generate()))
def render(self, namespace, **options):
# import genshi only here because this package is optional
from genshi.template.markup import MarkupTemplate
template = MarkupTemplate(self.text)
stream = template.generate(**namespace)
# enforce conversion to unicode
options['encoding'] = None
rendered_template = stream.render(**options)
return rendered_template
def test_attr_escape_quotes(self):
"""
Verify that outputting context data in attribtes escapes quotes.
"""
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<elem class="$myvar"/>
</div>""")
self.assertEqual("""<div>
<elem class=""foo""/>
</div>""", str(tmpl.generate(myvar='"foo"')))
def test_text_noescape_quotes(self):
"""
Verify that outputting context data in text nodes doesn't escape quotes.
"""
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
$myvar
</div>""")
self.assertEqual("""<div>
"foo"
</div>""", str(tmpl.generate(myvar='"foo"')))
def test_markup_noescape(self):
"""
Verify that outputting context data that is a `Markup` instance is not
escaped.
"""
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
$myvar
</div>""")
self.assertEqual("""<div>
<b>foo</b>
</div>""", str(tmpl.generate(myvar=Markup('<b>foo</b>'))))
def test_exec_def(self):
tmpl = MarkupTemplate("""
<?python
def foo():
return 42
?>
<div xmlns:py="http://genshi.edgewall.org/">
${foo()}
</div>""")
self.assertEqual("""<div>
42
</div>""", str(tmpl.generate()))
def test_exec_in_match(self):
xml = ("""<html xmlns:py="http://genshi.edgewall.org/">
<py:match path="body/p">
<?python title="wakka wakka wakka" ?>
${title}
</py:match>
<body><p>moot text</p></body>
</html>""")
tmpl = MarkupTemplate(xml, filename='test.html', allow_exec=True)
self.assertEqual("""<html>
<body>
wakka wakka wakka
</body>
</html>""", tmpl.generate().render(encoding=None))
def test_relative_include_from_inmemory_template(self):
file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w')
try:
file1.write("""<div>Included</div>""")
finally:
file1.close()
loader = TemplateLoader([self.dirname])
tmpl2 = MarkupTemplate("""<html xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="../tmpl1.html" />
</html>""", filename='subdir/tmpl2.html', loader=loader)
self.assertEqual("""<html>
<div>Included</div>
</html>""", tmpl2.generate().render())
def test_namespace_on_removed_elem(self):
"""
Verify that a namespace declaration on an element that is removed from
the generated stream does not get pushed up to the next non-stripped
element (see ticket #107).
"""
tmpl = MarkupTemplate("""<?xml version="1.0"?>
<Test xmlns:py="http://genshi.edgewall.org/">
<Size py:if="0" xmlns:t="test">Size</Size>
<Item/>
</Test>""")
self.assertEqual("""<?xml version="1.0"?>\n<Test>
<Item/>
</Test>""", str(tmpl.generate()))
def test_with_in_match(self):
xml = ("""<html xmlns:py="http://genshi.edgewall.org/">
<py:match path="body/p">
<h1>${select('text()')}</h1>
${select('.')}
</py:match>
<body><p py:with="foo='bar'">${foo}</p></body>
</html>""")
tmpl = MarkupTemplate(xml, filename='test.html')
self.assertEqual("""<html>
<body>
<h1>bar</h1>
<p>bar</p>
</body>
</html>""", tmpl.generate().render(encoding=None))
def test_match_without_select(self):
# See <http://genshi.edgewall.org/ticket/243>
xml = ("""<html xmlns:py="http://genshi.edgewall.org/">
<py:match path="body" buffer="false">
<body>
This replaces the other text.
</body>
</py:match>
<body>
This gets replaced.
</body>
</html>""")
tmpl = MarkupTemplate(xml, filename='test.html')
self.assertEqual("""<html>
<body>
This replaces the other text.
</body>
</html>""", tmpl.generate().render(encoding=None))
def test_nested_matches_without_buffering(self):
xml = ("""<html xmlns:py="http://genshi.edgewall.org/">
<py:match path="body" once="true" buffer="false">
<body>
${select('*|text')}
And some other stuff...
</body>
</py:match>
<body>
<span py:match="span">Foo</span>
<span>Bar</span>
</body>
</html>""")
tmpl = MarkupTemplate(xml, filename='test.html')
self.assertEqual("""<html>
<body>
<span>Foo</span>
And some other stuff...
</body>
</html>""", tmpl.generate().render(encoding=None))
def test_match_tail_handling(self):
# See <http://genshi.edgewall.org/ticket/399>
xml = ("""<rhyme xmlns:py="http://genshi.edgewall.org/">
<py:match path="*[@type]">
${select('.')}
</py:match>
<lines>
<first type="one">fish</first>
<second type="two">fish</second>
<third type="red">fish</third>
<fourth type="blue">fish</fourth>
</lines>
</rhyme>""")
tmpl = MarkupTemplate(xml, filename='test.html')
self.assertEqual("""<rhyme>
<lines>
<first type="one">fish</first>
<second type="two">fish</second>
<third type="red">fish</third>
<fourth type="blue">fish</fourth>
</lines>
</rhyme>""", tmpl.generate().render(encoding=None))
def test_empty_attr(self):
tmpl = MarkupTemplate('<root attr=""/>')
self.assertEqual('<root attr=""/>', str(tmpl.generate()))
def test_interpolate_multiline(self):
tmpl = MarkupTemplate("""<root>${dict(
bar = 'baz'
)[foo]}</root>""")
self.assertEqual('<root>baz</root>', str(tmpl.generate(foo='bar')))
def show_thread(env, req, mail_ids):
from model import Mail
mails = [Mail(env, mail_id) for mail_id in mail_ids]
template = MarkupTemplate("""
<div xmlns:py="http://genshi.edgewall.org/">
<script type="text/javascript" src="${req.chrome.htdocs_location}js/folding.js"></script>
<script type="text/javascript">
jQuery(document).ready(function($) {
$("fieldset legend.foldable").enableFolding(false);
/* Hide the filters for saved queries. */
$(".options").toggleClass("collapsed");
});
</script>
<py:def function="show_thread(mail, cached_mails)">
<li class="thread_li">
<py:choose>
<a py:when="mail.has_attachments(req)" class="thread_subject_clip"
href="${req.href.mailarchive(mail.id)}">[$mail.id] ${mail.get_subject()}</a>
<a py:otherwise=""
href="${req.href.mailarchive(mail.id)}">[$mail.id] ${mail.get_subject()}</a>
<py:with vars="related_tickets=mail.get_related_tickets(req);">
<py:if test="len(related_tickets) > 0">
<span class="related_tickets">
--- (関連チケット:
<py:for each="ticket in related_tickets">
<a href="${req.href.ticket(ticket.id)}">#${ticket.id}</a>
</py:for>
)
</span>
</py:if>
</py:with>
</py:choose>
<br />
<span class="thread_from">${mail.get_fromtext()}</span>
<span class="thread_senddate">${mail.get_senddate()}</span>
<py:for each="child in mail.get_children(cached_mails=cached_mails)">
<ul class="thread_ul">
${show_thread(child, cached_mails)}
</ul>
</py:for>
</li>
</py:def>
<h2>関連メール</h2>
<div id="mail_threads">
<py:for each="mail in mails">
<fieldset class="options">
<legend class="foldable" style="! important">[${mail.id}] ${mail.subject}</legend>
<span class="thread_from">${mail.get_fromtext()}</span>
<span class="thread_senddate">${mail.get_senddate()}</span>
<div id="mail_thread">
<ul class="thread_ul">
${show_thread(mail.get_thread_root(), mail.get_thread_mails())}
</ul>
</div>
</fieldset>
</py:for>
</div>
</div>""")
return template.generate(mails=mails, req=req)
def test_interpolate_multiline(self):
tmpl = MarkupTemplate("""<root>${dict(
bar = 'baz'
)[foo]}</root>""")
self.assertEqual('<root>baz</root>', str(tmpl.generate(foo='bar')))
def test_interpolate_non_string_attrs(self):
tmpl = MarkupTemplate('<root attr="${1}"/>')
self.assertEqual('<root attr="1"/>', str(tmpl.generate()))
def test_interpolate_list_result(self):
tmpl = MarkupTemplate('<root>$foo</root>')
self.assertEqual('<root>buzz</root>', str(tmpl.generate(foo=('buzz',))))
def test_interpolate_mixed3(self):
tmpl = MarkupTemplate('<root> ${var} $var</root>')
self.assertEqual('<root> 42 42</root>', str(tmpl.generate(var=42)))
def test_interpolate_non_string_attrs(self):
tmpl = MarkupTemplate('<root attr="${1}"/>')
self.assertEqual('<root attr="1"/>', str(tmpl.generate()))
def test_empty_attr_interpolated(self):
tmpl = MarkupTemplate('<root attr="$attr"/>')
self.assertEqual('<root attr=""/>', str(tmpl.generate(attr='')))
def test_interpolate_leading_trailing_space(self):
tmpl = MarkupTemplate('<root>${ foo }</root>')
self.assertEqual('<root>bar</root>', str(tmpl.generate(foo='bar')))
def test_interpolate_mixed3(self):
tmpl = MarkupTemplate('<root> ${var} $var</root>')
self.assertEqual('<root> 42 42</root>', str(tmpl.generate(var=42)))
def test_parse_stream(self):
stream = XML('<root> ${var} $var</root>')
tmpl = MarkupTemplate(stream)
self.assertEqual('<root> 42 42</root>', str(tmpl.generate(var=42)))
def test_parse_fileobj(self):
fileobj = StringIO('<root> ${var} $var</root>')
tmpl = MarkupTemplate(fileobj)
self.assertEqual('<root> 42 42</root>', str(tmpl.generate(var=42)))
def test_interpolate_leading_trailing_space(self):
tmpl = MarkupTemplate('<root>${ foo }</root>')
self.assertEqual('<root>bar</root>', str(tmpl.generate(foo='bar')))
def test_empty_attr(self):
tmpl = MarkupTemplate('<root attr=""/>')
self.assertEqual('<root attr=""/>', str(tmpl.generate()))
def test_empty_attr_interpolated(self):
tmpl = MarkupTemplate('<root attr="$attr"/>')
self.assertEqual('<root attr=""/>', str(tmpl.generate(attr='')))
def test_interpolate_list_result(self):
tmpl = MarkupTemplate('<root>$foo</root>')
self.assertEqual('<root>buzz</root>',
str(tmpl.generate(foo=('buzz', ))))
