def test_as_element(self):
"""
Verify that the directive can also be used as an element.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:if test="foo">${bar}</py:if>
</doc>""")
self.assertEqual("""<doc>
Hello
</doc>""", str(tmpl.generate(foo=True, bar='Hello')))
def test_def_in_match(self):
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:def function="maketitle(test)"><b py:replace="test" /></py:def>
<head py:match="head">${select('*')}</head>
<head><title>${maketitle(True)}</title></head>
</doc>""")
self.assertEqual(
"""<doc>
<head><title>True</title></head>
</doc>""", str(tmpl.generate()))
def filter_stream(self, req, method, filename, stream, data):
if req.perm.has_permission('TRAC_ADMIN') and filename.startswith(
'template_admin'):
script = '\n<script type="text/javascript">'\
+ 'ticketext.TicketTemplate.setUp(\'' + req.base_path + '\');'\
+ '</script>\n'
return stream | Transformer('//div[@id="footer"]').before(
MarkupTemplate(script).generate())
return stream
def test_invocation_in_attribute(self):
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:def function="echo(what)">${what or 'something'}</py:def>
<p class="${echo('foo')}">bar</p>
</doc>""")
self.assertEqual(
"""<doc>
<p class="foo">bar</p>
</doc>""",
tmpl.generate().render(encoding=None))
def test_content_directive_in_match(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<div py:match="foo">I said <q py:content="select('text()')">something</q>.</div>
<foo>bar</foo>
</html>""")
self.assertEqual(
"""<html>
<div>I said <q>bar</q>.</div>
</html>""",
tmpl.generate().render(encoding=None))
def test_as_element(self):
try:
MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:content foo="">Foo</py:content>
</doc>""",
filename='test.html').generate()
self.fail('Expected TemplateSyntaxError')
except TemplateSyntaxError, e:
self.assertEqual('test.html', e.filename)
self.assertEqual(2, e.lineno)
def test_with_empty_value(self):
"""
Verify that an empty py:with works (useless, but legal)
"""
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<span py:with="">Text</span></div>""")
self.assertEqual("""<div>
<span>Text</span></div>""",
tmpl.generate().render(encoding=None))
def generateResponseStream(self, tree):
template = MarkupTemplate("""<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:py="http://genshi.edgewall.org/">
<head><script>${jsCode}</script></head>
<body></body>
</html>""")
jsGenerator = TreeToJS()
jsCode = jsGenerator.serialize(tree)
stream = template.generate(jsCode = jsCode)
return stream
def test_otherwise(self):
tmpl = MarkupTemplate(
"""<div xmlns:py="http://genshi.edgewall.org/" py:choose="">
<span py:when="False">hidden</span>
<span py:otherwise="">hello</span>
</div>""")
self.assertEqual(
"""<div>
<span>hello</span>
</div>""", str(tmpl.generate()))
def test_extract_without_text(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<p title="Bar">Foo</p>
${ngettext("Singular", "Plural", num)}
</html>""")
translator = Translator(extract_text=False)
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((3, 'ngettext', (u'Singular', u'Plural')),
messages[0])
def test_loop_with_strip(self):
"""
Verify that the combining the `py:if` directive with `py:strip` works
correctly.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<b py:if="foo" py:strip="">${bar}</b>
</doc>""")
self.assertEqual("""<doc>
Hello
</doc>""", str(tmpl.generate(foo=True, bar='Hello')))
def test_remove_existing_attr(self):
"""
Verify that an attribute value that evaluates to `None` removes an
existing attribute of that name.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<elem class="foo" py:attrs="{'class': None}"/>
</doc>""")
self.assertEqual("""<doc>
<elem/>
</doc>""", str(tmpl.generate()))
def test_function_with_default_arg(self):
"""
Verify that keyword arguments work with `py:def` directives.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<b py:def="echo(what, bold=False)" py:strip="not bold">${what}</b>
${echo('foo')}
</doc>""")
self.assertEqual("""<doc>
foo
</doc>""", str(tmpl.generate()))
def test_fill_option_segmented_text(self):
html = MarkupTemplate("""<form>
<select name="foo">
<option value="1">foo $x</option>
</select>
</form>""").generate(x=1) | HTMLFormFiller(data={'foo': '1'})
self.assertEquals("""<form>
<select name="foo">
<option value="1" selected="selected">foo 1</option>
</select>
</form>""", unicode(html))
def test_function_raising_typeerror(self):
def badfunc():
raise TypeError
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<div py:def="dobadfunc()">
${badfunc()}
</div>
<div py:content="dobadfunc()"/>
</html>""")
self.assertRaises(TypeError, list, tmpl.generate(badfunc=badfunc))
def check_content(self):
if not self.content:
return
try:
MarkupTemplate(self.content)
except Exception as exception:
raise TemplateError(
gettext('marketing_email'
'.msg_message_invalid_content',
message=self.rec_name,
exception=exception)) from exception
def test_extract_i18n_msg_with_two_params(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="name, time">
Posted by ${post.author} at ${entry.time.strftime('%H:%m')}
</p>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual('Posted by %(name)s at %(time)s', messages[0][2])
def test_when_without_test(self):
"""
Verify that an `when` directive that doesn't have a `test` attribute
is reported as an error.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:choose="" py:strip="">
<py:when>foo</py:when>
</div>
</doc>""")
self.assertRaises(TemplateRuntimeError, str, tmpl.generate())
def test_fill_option_segmented_text_no_value(self):
html = MarkupTemplate("""<form>
<select name="foo">
<option>foo $x bar</option>
</select>
</form>""").generate(x=1) | HTMLFormFiller(data={'foo': 'foo 1 bar'})
self.assertEquals("""<form>
<select name="foo">
<option selected="selected">foo 1 bar</option>
</select>
</form>""", html.render())
def test_translate_with_translations_object(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="" i18n:comment="As in foo bar">Foo</p>
</html>""")
translator = Translator(DummyTranslations({'Foo': 'Voh'}))
tmpl.filters.insert(0, translator)
tmpl.add_directives(Translator.NAMESPACE, translator)
self.assertEqual("""<html>
<p>Voh</p>
</html>""", tmpl.generate().render())
def test_extract_i18n_msg_with_directive(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="">
Show me <input type="text" name="num" py:attrs="{'value': x}" /> entries per page.
</p>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual('Show me [1:] entries per page.', messages[0][2])
def test_extract_i18n_msg_with_param(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="name">
Hello, ${user.name}!
</p>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual('Hello, %(name)s!', messages[0][2])
def test_extract_i18n_msg_multiple(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="">
Please see <a href="help.html">Help</a> for <em>details</em>.
</p>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual('Please see [1:Help] for [2:details].', messages[0][2])
def test_shadowing(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
${x}
<span py:with="x = x * 2" py:replace="x"/>
${x}
</div>""")
self.assertEqual(
"""<div>
42
84
42
</div>""", str(tmpl.generate(x=42)))
def write_test_file(script_dir, out_dir, tests, file_name, template_file_name):
file_name = os.path.join(out_dir, file_name + ".html")
short_name = os.path.basename(file_name)
with open(os.path.join(script_dir, template_file_name), "r") as f:
template = MarkupTemplate(f)
stream = template.generate(file_name=short_name, tests=tests)
with open(file_name, "w") as f:
f.write(stream.render('html', doctype='html5', encoding="utf8"))
return file_name
def expand_macro(self, formatter, name, content):
template = """
<div>Hello World, args = ${args}</div>
"""
if genshi:
from genshi.template import MarkupTemplate
tmpl = MarkupTemplate(template)
return tmpl.generate(args=content)
else:
from trac.util.text import jinja2template
tmpl = jinja2template(template.strip())
return tmpl.render(args=content)
def test_translate_i18n_msg_with_comment(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="" i18n:comment="As in foo bar">Foo</p>
</html>""")
gettext = lambda s: u"Voh"
translator = Translator(gettext)
tmpl.filters.insert(0, translator)
tmpl.add_directives(Translator.NAMESPACE, translator)
self.assertEqual("""<html>
<p>Voh</p>
</html>""", tmpl.generate().render())
def test_extract_i18n_msg_multiple_empty(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="">
Show me <input type="text" name="num" /> entries per page, starting at page <input type="text" name="num" />.
</p>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual('Show me [1:] entries per page, starting at page [2:].',
messages[0][2])
def test_semicolon_escape(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = 'here is a semicolon: ;'; y = 'here are two semicolons: ;;' ;">
${x}
${y}
</py:with>
</div>""")
self.assertEqual(
"""<div>
here is a semicolon: ;
here are two semicolons: ;;
</div>""", str(tmpl.generate()))
def test_multiple_vars_same_name(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="
foo = 'bar';
foo = foo.replace('r', 'z')
">
$foo
</py:with>
</div>""")
self.assertEqual("""<div>
baz
</div>""", str(tmpl.generate(x=42)))
