def test_match_with_xpath_variable(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<span py:match="*[name()=$tagname]">
Hello ${select('@name')}
</span>
<greeting name="Dude"/>
</div>""")
self.assertEqual("""<div>
<span>
Hello Dude
</span>
</div>""", tmpl.generate(tagname='greeting').render(encoding=None))
self.assertEqual("""<div>
<greeting name="Dude"/>
</div>""", tmpl.generate(tagname='sayhello').render(encoding=None))
def test_match_multiple_times3(self):
# See http://genshi.edgewall.org/ticket/370#comment:12
tmpl = MarkupTemplate(
"""<?xml version="1.0"?>
<root xmlns:py="http://genshi.edgewall.org/">
<py:match path="foo/bar">
<zzzzz/>
</py:match>
<foo>
<bar/>
<bar/>
</foo>
<bar/>
</root>"""
)
self.assertEqual(
"""<?xml version="1.0"?>\n<root>
<foo>
<zzzzz/>
<zzzzz/>
</foo>
<bar/>
</root>""",
tmpl.generate().render(),
)
def test_triple_match_produces_no_duplicate_items(self):
tmpl = MarkupTemplate(
"""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:match="div[@id='content']" py:attrs="select('@*')" once="true">
<ul id="tabbed_pane" />
${select('*')}
</div>
<body py:match="body" once="true" buffer="false">
${select('*|text()')}
</body>
<body py:match="body" once="true" buffer="false">
${select('*|text()')}
</body>
<body>
<div id="content">
<h1>Ticket X</h1>
</div>
</body>
</doc>"""
)
output = tmpl.generate().render("xhtml", doctype="xhtml")
matches = re.findall("tabbed_pane", output)
self.assertNotEqual(None, matches)
self.assertEqual(1, len(matches))
def test_multiple_vars_trailing_semicolon(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = x * 2; y = x / 2;">${x} ${y}</py:with>
</div>""")
self.assertEqual("""<div>
84 42
</div>""", str(tmpl.generate(x=42)))
def emitHTML(self, _htmlpath, _templateFn, **kwds):
"""
read the specified template, perform template
instantantiation and write the result to _htmlpath.
Any keyword arguments are used to fill in the blanks
in the template.
"""
while _htmlpath.startswith(os.sep):
_htmlpath = _htmlpath[1:]
outfn = os.path.join(self.siteRoot, _htmlpath)
infn = os.path.join(gTemplateDir, _templateFn)
outdn = os.path.dirname(outfn)
if not os.path.exists(outdn):
os.makedirs(outdn)
tmpl = MarkupTemplate(open(infn, 'r').read(), loader=self._makeLoader(infn), lookup='strict')
variables = self._makeGlobals(_htmlpath)
variables.update(kwds)
stream = tmpl.generate(**variables)
fp = open(outfn, "w")
fp.write(stream.render('html'))
fp.close()
def test_recursive_match_1(self):
"""
Match directives are applied recursively, meaning that they are also
applied to any content they may have produced themselves:
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<elem py:match="elem">
<div class="elem">
${select('*')}
</div>
</elem>
<elem>
<subelem>
<elem/>
</subelem>
</elem>
</doc>""")
self.assertEqual("""<doc>
<elem>
<div class="elem">
<subelem>
<elem>
<div class="elem">
</div>
</elem>
</subelem>
</div>
</elem>
</doc>""", tmpl.generate().render(encoding=None))
def test_match_with_recursive_attribute(self):
tmpl = MarkupTemplate(
"""<doc xmlns:py="http://genshi.edgewall.org/">
<py:match path="elem" recursive="false"><elem>
<div class="elem">
${select('*')}
</div>
</elem></py:match>
<elem>
<subelem>
<elem/>
</subelem>
</elem>
</doc>"""
)
self.assertEqual(
"""<doc>
<elem>
<div class="elem">
<subelem>
<elem/>
</subelem>
</div>
</elem>
</doc>""",
tmpl.generate().render(encoding=None),
)
def test_multiple_matches(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<input py:match="form//input" py:attrs="select('@*')"
value="${values[str(select('@name'))]}" />
<form><p py:for="field in fields">
<label>${field.capitalize()}</label>
<input type="text" name="${field}" />
</p></form>
</html>""")
fields = ['hello_%s' % i for i in range(5)]
values = dict([('hello_%s' % i, i) for i in range(5)])
self.assertEqual("""<html>
<form><p>
<label>Hello_0</label>
<input value="0" type="text" name="hello_0"/>
</p><p>
<label>Hello_1</label>
<input value="1" type="text" name="hello_1"/>
</p><p>
<label>Hello_2</label>
<input value="2" type="text" name="hello_2"/>
</p><p>
<label>Hello_3</label>
<input value="3" type="text" name="hello_3"/>
</p><p>
<label>Hello_4</label>
<input value="4" type="text" name="hello_4"/>
</p></form>
</html>""", tmpl.generate(fields=fields, values=values)
.render(encoding=None))
def test_not_iterable(self):
"""
Verify that assignment to nested tuples works correctly.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:for each="item in foo">
$item
</py:for>
</doc>""", filename='test.html')
try:
list(tmpl.generate(foo=12))
self.fail('Expected TemplateRuntimeError')
except TypeError, e:
assert (str(e) == "iteration over non-sequence" or
str(e) == "'int' object is not iterable")
exc_type, exc_value, exc_traceback = sys.exc_info()
frame = exc_traceback.tb_next
frames = []
while frame.tb_next:
frame = frame.tb_next
frames.append(frame)
self.assertEqual("<Expression u'iter(foo)'>",
frames[-1].tb_frame.f_code.co_name)
self.assertEqual('test.html',
frames[-1].tb_frame.f_code.co_filename)
self.assertEqual(2, frames[-1].tb_lineno)
def test_strip_false(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<div py:strip="False"><b>foo</b></div>
</div>""")
self.assertEqual("""<div>
<div><b>foo</b></div>
</div>""", str(tmpl.generate()))
def test_as_element(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:replace value="title" />
</div>""", filename='test.html')
self.assertEqual("""<div>
Test
</div>""", tmpl.generate(title='Test').render(encoding=None))
def test_multiple_vars_trailing_semicolon(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = x * 2; y = x / 2;">${x} ${y}</py:with>
</div>""")
self.assertEqual("""<div>
84 %s
</div>""" % (84 / 2), tmpl.generate(x=42).render(encoding=None))
def test_as_element(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = x * 2">${x}</py:with>
</div>""")
self.assertEqual("""<div>
84
</div>""", tmpl.generate(x=42).render(encoding=None))
def test_strip_empty(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<div py:strip=""><b>foo</b></div>
</div>""")
self.assertEqual("""<div>
<b>foo</b>
</div>""", tmpl.generate().render(encoding=None))
def test_nested_vars_single_assignment(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x, (y, z) = (1, (2, 3))">${x} ${y} ${z}</py:with>
</div>""")
self.assertEqual("""<div>
1 2 3
</div>""", tmpl.generate(x=42).render(encoding=None))
def test_multiple_vars_single_assignment(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = y = z = 1">${x} ${y} ${z}</py:with>
</div>""")
self.assertEqual("""<div>
1 1 1
</div>""", tmpl.generate(x=42).render(encoding=None))
def test_match_with_once_attribute(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<py:match path="body" once="true"><body>
<div id="wrap">
${select("*")}
</div>
</body></py:match>
<body>
<p>Foo</p>
</body>
<body>
<p>Bar</p>
</body>
</html>""")
self.assertEqual(
"""<html>
<body>
<div id="wrap">
<p>Foo</p>
</div>
</body>
<body>
<p>Bar</p>
</body>
</html>""",
tmpl.generate().render(encoding=None))
def application(environ, start_response):
output = api.mongoApi(environ)
records = json.loads(output)["result"]
items = []
if type(records) in seqTypes:
if len(records):
items.append(str(len(records)) + " records")
buildHeader(records[0], items)
for rec in records:
buildRecord(rec, items)
else:
items.append("no records found")
else:
items.append("<i>count:</i> " + str(records))
print >>sys.stderr, "DEBUG VIEW items:", items
template = "/template/record_tab.html"
f = open(DOCROOT + template)
tmpl = MarkupTemplate(f)
f.close()
stream = tmpl.generate(DOCROOT=DOCROOT, items=items)
output = stream.render("xhtml")
status = "200 OK"
response_headers = [("Content-type", "text/html"), ("Content-Length", str(len(output)))]
start_response(status, response_headers)
return [output]
def test_recursive_match_3(self):
tmpl = MarkupTemplate("""<test xmlns:py="http://genshi.edgewall.org/">
<py:match path="b[@type='bullet']">
<bullet>${select('*|text()')}</bullet>
</py:match>
<py:match path="group[@type='bullet']">
<ul>${select('*')}</ul>
</py:match>
<py:match path="b">
<generic>${select('*|text()')}</generic>
</py:match>
<b>
<group type="bullet">
<b type="bullet">1</b>
<b type="bullet">2</b>
</group>
</b>
</test>
""")
self.assertEqual("""<test>
<generic>
<ul><bullet>1</bullet><bullet>2</bullet></ul>
</generic>
</test>""", tmpl.generate().render(encoding=None))
def test_recursive_match_2(self):
"""
When two or more match templates match the same element and also
themselves output the element they match, avoiding recursion is even
more complex, but should work.
"""
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<body py:match="body">
<div id="header"/>
${select('*')}
</body>
<body py:match="body">
${select('*')}
<div id="footer"/>
</body>
<body>
<h1>Foo</h1>
</body>
</html>""")
self.assertEqual("""<html>
<body>
<div id="header"/><h1>Foo</h1>
<div id="footer"/>
</body>
</html>""", tmpl.generate().render(encoding=None))
def test_select_text_in_element(self):
"""
See http://genshi.edgewall.org/ticket/77#comment:1
"""
tmpl = MarkupTemplate("""<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:py="http://genshi.edgewall.org/">
<body py:match="body" py:content="select('*')" />
<h1 py:match="h1">
<text>
${select('text()')}
</text>
Goodbye!
</h1>
<body>
<h1>Hello!</h1>
</body>
</html>""")
self.assertEqual("""<html xmlns="http://www.w3.org/1999/xhtml">
<body><h1>
<text>
Hello!
</text>
Goodbye!
</h1></body>
</html>""", tmpl.generate().render(encoding=None))
def application(environ, start_response):
output = api.mongoApi(environ)
records = json.loads(output)['result']
items = []
if type(records) in seqTypes:
if len(records):
if len(records) > MAX_RECORDS:
records = records[:MAX_RECORDS]
items.append("<b>Exceeded max records for pretty output; showing first %s</b>" % MAX_RECORDS)
for rec in records:
if type(rec) in stringTypes:
items.append(rec)
elif type(rec) in hashTypes:
buildRecord(rec, items)
else:
print >> sys.stderr, "ERROR: unknown type for buildRecord:", type(rec)
else:
items.append("no records found")
else:
items.append("<i>count:</i> " + str(records))
## print >> sys.stderr, "DEBUG VIEW records:", records[:10]
template = "/template/record.html"
f = open(DOCROOT + template)
tmpl = MarkupTemplate(f)
f.close()
stream = tmpl.generate(DOCROOT=DOCROOT, items=items, seqTypes=seqTypes)
output = stream.render('xhtml')
status = '200 OK'
response_headers = [('Content-type', 'text/html'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [output]
def test_match_with_xpath_variable(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<span py:match="*[name()=$tagname]">
Hello ${select('@name')}
</span>
<greeting name="Dude"/>
</div>""")
self.assertEqual(
"""<div>
<span>
Hello Dude
</span>
</div>""", str(tmpl.generate(tagname='greeting')))
self.assertEqual(
"""<div>
<greeting name="Dude"/>
</div>""", str(tmpl.generate(tagname='sayhello')))
def test_multiple_vars_single_assignment(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = y = z = 1">${x} ${y} ${z}</py:with>
</div>""")
self.assertEqual("""<div>
1 1 1
</div>""",
tmpl.generate(x=42).render(encoding=None))
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>""", str(tmpl.generate()))
def test_multiple_vars_trailing_semicolon(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = x * 2; y = x / 2;">${x} ${y}</py:with>
</div>""")
self.assertEqual("""<div>
84 %s
</div>""" % (84 / 2),
tmpl.generate(x=42).render(encoding=None))
def test_nested_vars_single_assignment(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x, (y, z) = (1, (2, 3))">${x} ${y} ${z}</py:with>
</div>""")
self.assertEqual("""<div>
1 2 3
</div>""",
tmpl.generate(x=42).render(encoding=None))
def make_index(test_filenames, inner_html_files):
template = MarkupTemplate(open(os.path.join(file_base, 'index.xml')))
stream = template.generate(file_names=serialize_filenames(test_filenames),
inner_html_file_names=serialize_filenames(inner_html_files));
out_f = open("index.html", "w")
out_f.write(stream.render('html', doctype='html5',
encoding="utf-8"))
def test_strip_empty(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<div py:strip=""><b>foo</b></div>
</div>""")
self.assertEqual("""<div>
<b>foo</b>
</div>""",
tmpl.generate().render(encoding=None))
def test_as_element(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:replace value="title" />
</div>""",
filename='test.html')
self.assertEqual("""<div>
Test
</div>""", str(tmpl.generate(title='Test')))
def test_as_element(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<py:with vars="x = x * 2">${x}</py:with>
</div>""")
self.assertEqual("""<div>
84
</div>""",
tmpl.generate(x=42).render(encoding=None))
def test_invocation_in_attribute_none(self):
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:def function="echo()">${None}</py:def>
<p class="${echo()}">bar</p>
</doc>""")
self.assertEqual("""<doc>
<p>bar</p>
</doc>""", str(tmpl.generate()))
def test_strip_false(self):
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<div py:strip="False"><b>foo</b></div>
</div>""")
self.assertEqual(
"""<div>
<div><b>foo</b></div>
</div>""", str(tmpl.generate()))
def body(self, environ, full_path):
"""Pass environ and **self.variables into the template."""
template = MarkupTemplate(full_path.read())
variables = self.variables.copy()
variables["environ"] = environ
return [template.generate(**variables)
.render('html', doctype='html')]
def test_invocation_in_attribute_none(self):
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:def function="echo()">${None}</py:def>
<p class="${echo()}">bar</p>
</doc>""")
self.assertEqual("""<doc>
<p>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_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>""", tmpl.generate().render(encoding=None))
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>""", str(tmpl.generate()))
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>""", tmpl.generate().render(encoding=None))
def test_otherwise_outside_choose(self):
"""
Verify that an `otherwise` directive outside of a `choose` directive is
reported as an error.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:otherwise="" />
</doc>""")
self.assertRaises(TemplateRuntimeError, str, tmpl.generate())
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>""", str(tmpl.generate()))
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>""", str(tmpl.generate()))
def test_otherwise_outside_choose(self):
"""
Verify that an `otherwise` directive outside of a `choose` directive is
reported as an error.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:otherwise="" />
</doc>""")
self.assertRaises(TemplateRuntimeError, str, tmpl.generate())
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 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 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_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_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_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_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 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 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_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 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 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)))
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 test_namespace_context(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:x="http://www.example.org/">
<div py:match="x:foo">Foo</div>
<foo xmlns="http://www.example.org/"/>
</html>""")
# FIXME: there should be a way to strip out unwanted/unused namespaces,
# such as the "x" in this example
self.assertEqual(
"""<html xmlns:x="http://www.example.org/">
<div>Foo</div>
</html>""", str(tmpl.generate()))
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())
