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_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 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_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_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):
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_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 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_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 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_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 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_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_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_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_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_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 __addHtmlSection(self, section, id, depth):
if depth > 0:
content = ''
for text in section.text:
content = content + text
urls = self.impl.downloadHtmlImages(content)
content = self.impl.remoteToLocalImageUrls(urls, content)
stream = MarkupTemplate("""<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:py="http://genshi.edgewall.org/">
<head>
<title>${section.title}</title>
<style type="text/css">
h1 { text-align: center; }
${section.css}
</style>
</head>
<body>
<h1>${section.title}</h1>
""" + content + """
</body>
</html>""").generate(section = section)
html = stream.render('xhtml', doctype = 'xhtml11', drop_xml_decl = False)
item = self.impl.addHtml('', '%s.html' % id, html)
self.impl.addSpineItem(item)
self.impl.addTocMapNode(item.destPath, section.title, depth)
id += '.'
if len(section.subsections) > 0:
for i, subsection in enumerate(section.subsections):
self.__addHtmlSection(subsection, id + str(i + 1), depth + 1)
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_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_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 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_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_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_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 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_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_translate_i18n_msg_with_attr(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
xmlns:i18n="http://genshi.edgewall.org/i18n">
<p i18n:msg="" title="Foo bar">Foo</p>
</html>""")
gettext = lambda s: u"Voh"
translator = Translator(DummyTranslations({
'Foo': u'Voh',
'Foo bar': u'Voh bär'
}))
tmpl.filters.insert(0, translator)
tmpl.add_directives(Translator.NAMESPACE, translator)
self.assertEqual("""<html>
<p title="Voh bär">Voh</p>
</html>""", tmpl.generate().render())
def test_with_strip(self):
"""
Verify that a match template can produce the same kind of element that
it matched without entering an infinite recursion.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<elem py:match="elem" py:strip="">
<div class="elem">${select('text()')}</div>
</elem>
<elem>Hey Joe</elem>
</doc>""")
self.assertEqual(
"""<doc>
<div class="elem">Hey Joe</div>
</doc>""", str(tmpl.generate()))
def test_match_with_position_predicate(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<p py:match="body/p[1]" class="first">${select('*|text()')}</p>
<body>
<p>Foo</p>
<p>Bar</p>
</body>
</html>""")
self.assertEqual(
"""<html>
<body>
<p class="first">Foo</p>
<p>Bar</p>
</body>
</html>""", str(tmpl.generate()))
def test_match_without_closure(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<p py:match="body/p" class="para">${select('*|text()')}</p>
<body>
<p>Foo</p>
<div><p>Bar</p></div>
</body>
</html>""")
self.assertEqual(
"""<html>
<body>
<p class="para">Foo</p>
<div><p>Bar</p></div>
</body>
</html>""", str(tmpl.generate()))
def test_function_with_strip(self):
"""
Verify that a named template function with a strip directive actually
strips of the outer element.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:def="echo(what)" py:strip="">
<b>${what}</b>
</div>
${echo('foo')}
</doc>""")
self.assertEqual("""<doc>
<b>foo</b>
</doc>""",
tmpl.generate().render(encoding=None))
def test_multi_assignment(self):
"""
Verify that assignment to tuples works correctly.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:for each="k, v in items">
<p>key=$k, value=$v</p>
</py:for>
</doc>""")
self.assertEqual(
"""<doc>
<p>key=a, value=1</p>
<p>key=b, value=2</p>
</doc>""",
tmpl.generate(items=(('a', 1), ('b', 2))).render(encoding=None))
def test_multiple_true_whens(self):
"""
Verify that, if multiple `py:when` bodies match, only the first is
output.
"""
tmpl = MarkupTemplate(
"""<div xmlns:py="http://genshi.edgewall.org/" py:choose="">
<span py:when="1 == 1">1</span>
<span py:when="2 == 2">2</span>
<span py:when="3 == 3">3</span>
</div>""")
self.assertEqual("""<div>
<span>1</span>
</div>""",
tmpl.generate().render(encoding=None))
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:match path="elem">
<div class="elem">${select('text()')}</div>
</py:match>
<elem>Hey Joe</elem>
</doc>""")
self.assertEqual(
"""<doc>
<div class="elem">Hey Joe</div>
</doc>""",
tmpl.generate().render(encoding=None))
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.split(file_name)[1]
with open(os.path.join(script_dir, template_file_name)) as f:
template = MarkupTemplate(f)
stream = template.generate(file_name=short_name,
tests=tests,
file_timeout=min(1000 * len(tests), 60 * 1000),
test_timeout=1000)
with open(file_name, "w") as f:
f.write(stream.render('html', doctype='html5', encoding="utf8"))
return file_name
def test_when_with_strip(self):
"""
Verify that a when directive with a strip directive actually strips of
the outer element.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:choose="" py:strip="">
<span py:otherwise="">foo</span>
</div>
</doc>""")
self.assertEqual(
"""<doc>
<span>foo</span>
</doc>""",
tmpl.generate().render(encoding=None))
def test_when_without_test_but_with_choose_value(self):
"""
Verify that an `when` directive that doesn't have a `test` attribute
works as expected as long as the parent `choose` directive has a test
expression.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<div py:choose="foo" py:strip="">
<py:when>foo</py:when>
</div>
</doc>""")
self.assertEqual("""<doc>
foo
</doc>""",
tmpl.generate(foo='Yeah').render(encoding=None))
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:choose>
<py:when test="1 == 1">1</py:when>
<py:when test="2 == 2">2</py:when>
<py:when test="3 == 3">3</py:when>
</py:choose>
</doc>""")
self.assertEqual("""<doc>
1
</doc>""",
tmpl.generate().render(encoding=None))
def test_match_multiple_times1(self):
# See http://genshi.edgewall.org/ticket/370
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<py:match path="body[@id='content']/h2" />
<head py:match="head" />
<head py:match="head" />
<head />
<body />
</html>""")
self.assertEqual(
"""<html>
<head/>
<body/>
</html>""",
tmpl.generate().render())
def test_ignore_tag_with_fixed_xml_lang(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<p xml:lang="en">(c) 2007 Edgewall Software</p>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(0, len(messages))
def test_ignore_attribute_with_expression(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<input type="submit" value="Reply" title="Reply to comment $num" />
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(0, len(messages))
def render_genshi_tmpl(tmplstr, context, tmplpath=None):
'''
Render a Genshi template. A method should be passed in as part of the
context. If no method is passed in, xml is assumed. Valid methods are:
.. code-block:
- xml
- xhtml
- html
- text
- newtext
- oldtext
Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext``
is desired, it must be called explicitly
'''
method = context.get('method', 'xml')
if method == 'text' or method == 'newtext':
from genshi.template import NewTextTemplate
tmpl = NewTextTemplate(tmplstr)
elif method == 'oldtext':
from genshi.template import OldTextTemplate
tmpl = OldTextTemplate(tmplstr)
else:
from genshi.template import MarkupTemplate
tmpl = MarkupTemplate(tmplstr)
return tmpl.generate(**context).render(method)
def render_genshi_tmpl(tmplstr, context, tmplpath=None):
"""
Render a Genshi template. A method should be passed in as part of the
context. If no method is passed in, xml is assumed. Valid methods are:
.. code-block:
- xml
- xhtml
- html
- text
- newtext
- oldtext
Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext``
is desired, it must be called explicitly
"""
method = context.get("method", "xml")
if method == "text" or method == "newtext":
from genshi.template import NewTextTemplate # pylint: disable=no-name-in-module
tmpl = NewTextTemplate(tmplstr)
elif method == "oldtext":
from genshi.template import OldTextTemplate # pylint: disable=no-name-in-module
tmpl = OldTextTemplate(tmplstr)
else:
from genshi.template import MarkupTemplate # pylint: disable=no-name-in-module
tmpl = MarkupTemplate(tmplstr)
return tmpl.generate(**context).render(method)
def test_ast_transformation(self):
"""
Verify that the usual template expression AST transformations are
applied despite the code being compiled to a `Suite` object.
"""
tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
<span py:with="bar=foo.bar">
$bar
</span>
</div>""")
self.assertEqual(
"""<div>
<span>
42
</span>
</div>""", str(tmpl.generate(foo={'bar': 42})))
def _generate_resource(self, res, isclass=False):
template_file = "class.html" if isclass else "module.html"
templatedir_path = join(self._theme_dir, template_file)
with open(templatedir_path, 'r') as content_file:
content = content_file.read()
tmpl = MarkupTemplate(content)
stream = tmpl.generate(resource=res,
module_tree=self._resource.module_tree,
project_name=self._resource.name)
resource_path = join(self._destination, self._resource.docsdir,
res.name + '.html')
f = open(resource_path, 'w+')
f.write(stream.render('xhtml'))
f.close()
def test_nested_assignment(self):
"""
Verify that assignment to nested tuples works correctly.
"""
tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
<py:for each="idx, (k, v) in items">
<p>$idx: key=$k, value=$v</p>
</py:for>
</doc>""")
self.assertEqual(
"""<doc>
<p>0: key=a, value=1</p>
<p>1: key=b, value=2</p>
</doc>""",
tmpl.generate(items=enumerate(dict(a=1, b=2).items())).render(
encoding=None))
def filter_stream(self, req, method, filename, stream, data):
if filename != 'ticket.html':
return stream
# if specify disable, not execute.
enable = True
if 'ticketext' in req.args:
enable = req.args['ticketext']
enable = enable.lower() in _TRUE_VALUES
enable = bool(enable)
if not enable:
return stream
readyDescription = False
if req.path_info == '/newticket' and 'preview' not in req.args:
readyDescription = True
script = '\n<script type="text/javascript">\n'\
+ 'var tikectTemplate = new ticketext.TicketTemplate(\'' + req.base_path + '\');\n'\
+ 'tikectTemplate.setElementId(\'field-type\', \'field-description\');\n'\
+ 'tikectTemplate.setReadyDescription(' + str(readyDescription).lower() + ');\n'\
+ 'tikectTemplate.initialize();\n'\
+ '</script>\n'
return stream | Transformer('//div[@id="footer"]').before(
MarkupTemplate(script).generate())
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_extract_included_attribute_text(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<span title="Foo"></span>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((2, None, u'Foo', []), messages[0])
def test_extract_gettext_with_unicode_string(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
${gettext("Grüße")}
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((2, 'gettext', u'Gr\xfc\xdfe', []), messages[0])
def test_extract_funky_plural_form(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
${ngettext(len(items), *widget.display_names)}
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((2, 'ngettext', (None, None), []), messages[0])
def test_extract_text_from_sub(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<py:if test="foo">Foo</py:if>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((2, None, u'Foo', []), messages[0])
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:for each="item in items">
<b>${item}</b>
</py:for>
</doc>""")
self.assertEqual(
"""<doc>
<b>1</b>
<b>2</b>
<b>3</b>
<b>4</b>
<b>5</b>
</doc>""", str(tmpl.generate(items=range(1, 6))))
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 TemplateRuntimeError, e:
self.assertEqual('test.html', e.filename)
if sys.version_info[:2] >= (2, 4):
self.assertEqual(2, e.lineno)
def test_extract_attribute_expr(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<input type="submit" value="${_('Save')}" />
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((2, '_', u'Save', []), messages[0])
def test_extract_non_included_attribute_interpolated(self):
tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
<a href="#anchor_${num}">Foo</a>
</html>""")
translator = Translator()
messages = list(translator.extract(tmpl.stream))
self.assertEqual(1, len(messages))
self.assertEqual((2, None, u'Foo', []), messages[0])
