def test_nested_macros(self):
"""test nested macros"""
T = tags
url_data = [
{'url': 'http://www.google.com', 'label': 'Google'},
{'url': 'http://www.yahoo.com', 'label': 'Yahoo!'},
{'url': 'http://www.amazon.com', 'label': 'Amazon'}
]
template = (
macro('list_macro', lambda url, label: (
macro('link_macro', lambda _u, _l:
T.a(href=_u)[_l]
),
T.li[link_macro(url, label)]
)),
T.html[
T.head[T.title[my_name()]],
T.body[
T.ul[
[list_macro(**_item)
for _item in url_data]
]
]
]
)
output = flatten(template)
self.assertEqual(
output,
(u'<html><head><title>test_nested_macros</title></head>'
u'<body><ul><li><a href="http://www.google.com">Google</a></li>'
u'<li><a href="http://www.yahoo.com">Yahoo!</a></li>'
u'<li><a href="http://www.amazon.com">Amazon</a></li></ul></body></html>')
)
def test_nested_macros(self):
'''test nested macros'''
T = tags
url_data = [{
'url': 'http://www.google.com',
'label': 'Google'
}, {
'url': 'http://www.yahoo.com',
'label': 'Yahoo!'
}, {
'url': 'http://www.amazon.com',
'label': 'Amazon'
}]
template = (
macro(
'list_macro', lambda url, label:
(macro('link_macro', lambda _u, _l: T.a(href=_u)[_l]), T.li[
link_macro(url, label)])),
T.html[T.head[T.title[my_name()]],
T.body[T.ul[[list_macro(**_item) for _item in url_data]]]])
output = flatten(template)
self.assertEqual(output, (
u'<html><head><title>test_nested_macros</title></head>'
u'<body><ul><li><a href="http://www.google.com">Google</a></li>'
u'<li><a href="http://www.yahoo.com">Yahoo!</a></li>'
u'<li><a href="http://www.amazon.com">Amazon</a></li></ul></body></html>'
))
def test_dom_traversal_from_macro(self):
'''macro abuse: self-traversing template'''
T = tags
template = (
assign('selectors', []),
macro('css_sep', lambda attr: attr == 'class' and '.' or '#'),
macro(
'get_selectors', lambda tag, is_tag: selectors.extend([
"%s%s%s { }" % (tag.name, css_sep(_k.strip('_')), _v)
for _k, _v in tag.attrs.items()
if _k.strip('_') in ('id', 'class')
])),
macro('extract_css',
lambda tag: tag.walk(get_selectors, True) and tag),
macro('css_results',
lambda selectors: T.pre['\n'.join(selectors)]), T.
html[T.head[T.title['macro madness']],
T.body[extract_css(
T.div(class_='text', id='main-content')[
T.img(src='/images/breve-logo.png', alt='breve logo'),
T.br,
T.span(class_='bold')['''Hello from Breve!''']]),
css_results(selectors)]])
output = flatten(template)
self.assertEqual(
output,
(u'<html><head><title>macro madness</title></head>'
u'<body><div class="text" id="main-content">'
u'<img src="/images/breve-logo.png" alt="breve logo"></img>'
u'<br /><span class="bold">Hello from Breve!</span></div>'
u'<pre>div.text { }\ndiv#main-content { }\nspan.bold { }</pre>'
u'</body></html>'))
def test_dom_traversal_from_macro(self):
T = tags
template = (
assign('selectors', []),
macro('css_sep', lambda attr:
attr == 'class' and '.' or '#'
),
macro(
'get_selectors',
lambda tag, is_tag: selectors.extend(
["%s%s%s { }" % (tag.name, css_sep(_k.strip('_')), _v)
for _k, _v in tag.attrs.items()
if _k.strip('_') in ('id', 'class')
]
)
),
macro('extract_css', lambda tag:
tag.walk(get_selectors, True) and tag
),
macro(
'css_results', lambda selectors:
T.pre['\n'.join(selectors)]
),
T.html[
T.head[T.title['macro madness']],
T.body[extract_css(
T.div(class_='text', id='main-content')[
T.img(src='/images/breve-logo.png', alt='breve logo'),
T.br,
T.span(class_='bold')['''Hello from Breve!''']
]
), css_results(selectors)]
]
)
"""macro abuse: self-traversing template"""
T = tags
output = flatten(template)
self.assertEqual(
output,
(u'<html><head><title>macro madness</title></head>'
u'<body><div class="text" id="main-content">'
u'<img src="/images/breve-logo.png" alt="breve logo"></img>'
u'<br /><span class="bold">Hello from Breve!</span></div>'
u'<pre>div.text { }\ndiv#main-content { }\nspan.bold { }</pre>'
u'</body></html>')
)
def test_autolist_macro ( self ):
'''test autolist macro'''
data = [ "Item %s" % _i for _i in range ( 1,9 ) ]
template = (
macro ( 'AutoList', lambda data:
data and (
T.ul ( class_='autolist' ) [
[ T.li [ _i ] for _i in data ]
]
) or ''
),
T.html [
T.head [ T.title [ my_name ( ) ] ],
T.body [ AutoList ( data ) ]
]
)
output = flatten ( template )
self.assertEqual (
output,
( u'<html><head><title>test_autolist_macro</title></head>'
u'<body><ul class="autolist"><li>Item 1</li><li>Item 2</li>'
u'<li>Item 3</li><li>Item 4</li><li>Item 5</li><li>Item 6</li>'
u'<li>Item 7</li><li>Item 8</li></ul></body></html>' )
)
def test_tag_multiplication_with_macro(self):
"""tag multiplication including macro"""
T = tags
url_data = [
{'url': 'http://www.google.com', 'label': 'Google', 'class': 'link'},
{'url': 'http://www.yahoo.com', 'label': 'Yahoo!', 'class': 'link'},
{'url': 'http://www.amazon.com', 'label': 'Amazon', 'class': 'link'}
]
template = (
macro('test_macro', lambda url:
T.a(href=url)["$label"]
),
T.html[
T.head[T.title[my_name()]],
T.body[
T.ul[
T.li(class_="$class")[test_macro("$url")] * url_data
]
]
]
)
output = flatten(template)
self.assertEqual(
output,
(u'<html><head><title>test_tag_multiplication_with_macro</title></head>'
u'<body><ul><li class="link"><a href="http://www.google.com">Google</a></li>'
u'<li class="link"><a href="http://www.yahoo.com">Yahoo!</a></li>'
u'<li class="link"><a href="http://www.amazon.com">Amazon</a></li></ul></body></html>')
)
def test_macros ( self ):
'''test macros'''
T = tags
url_data = [
{ 'url': 'http://www.google.com', 'label': 'Google' },
{ 'url': 'http://www.yahoo.com', 'label': 'Yahoo!' },
{ 'url': 'http://www.amazon.com', 'label': 'Amazon' }
]
template = (
macro ( 'test_macro', lambda url, label:
T.a ( href = url ) [ label ]
),
T.html [
T.head [ T.title [ my_name ( ) ] ],
T.body [
T.ul [
[ T.li [ test_macro ( **_item ) ]
for _item in url_data ]
]
]
]
)
output = flatten ( template )
self.assertEqual (
output,
( u'<html><head><title>test_macros</title></head>'
u'<body><ul><li><a href="http://www.google.com">Google</a></li>'
u'<li><a href="http://www.yahoo.com">Yahoo!</a></li>'
u'<li><a href="http://www.amazon.com">Amazon</a></li></ul></body></html>' )
)
def test_tag_multiplication_with_macro(self):
'''tag multiplication including macro'''
T = tags
url_data = [{
'url': 'http://www.google.com',
'label': 'Google',
'class': 'link'
}, {
'url': 'http://www.yahoo.com',
'label': 'Yahoo!',
'class': 'link'
}, {
'url': 'http://www.amazon.com',
'label': 'Amazon',
'class': 'link'
}]
template = (
macro('test_macro', lambda url: T.a(href=url)["$label"]),
T.html[T.head[T.title[my_name()]],
T.body[T.ul[T.li(class_="$class")[test_macro("$url")] *
url_data]]])
output = flatten(template)
self.assertEqual(output, (
u'<html><head><title>test_tag_multiplication_with_macro</title></head>'
u'<body><ul><li class="link"><a href="http://www.google.com">Google</a></li>'
u'<li class="link"><a href="http://www.yahoo.com">Yahoo!</a></li>'
u'<li class="link"><a href="http://www.amazon.com">Amazon</a></li></ul></body></html>'
))
def test_macros():
"""test macros"""
url_data = [
{'url': 'http://www.google.com', 'label': 'Google'},
{'url': 'http://www.yahoo.com', 'label': 'Yahoo!'},
{'url': 'http://www.amazon.com', 'label': 'Amazon'}
]
template = (
macro('test_macro', lambda url, label:
T.a(href=url)[label]
),
T.html[
T.head[T.title[my_name()]],
T.body[
T.ul[
[T.li[test_macro(**_item)] # @UndefinedVariable
for _item in url_data]
]
]
]
)
output = flatten(template)
assert output == ('<html><head><title>test_macros</title></head>'
'<body><ul><li><a href="http://www.google.com">Google</a></li>'
'<li><a href="http://www.yahoo.com">Yahoo!</a></li>'
'<li><a href="http://www.amazon.com">Amazon</a></li></ul></body></html>')
def test_toc_macro ( self ):
'''test table-of-contents macro'''
template = (
assign ( 'TOC', [ ] ),
macro ( 'TableOfContents', lambda matchtags, tag: (
macro ( 'toc_search', lambda tag, is_tag:
tag.name in matchtags and (
TOC.append ( T.a ( href='#toc-%s' % tag.children [ 0 ] ) [ tag.children [ 0 ] ] ),
tag.attrs.update ( { 'class': 'chapter-%s' % tag.name } ),
tag.children.insert ( 0, T.a ( name='toc-%s' % tag.children [ 0 ] ) [ tag.name ] )
) or True
),
tag.walk ( toc_search, True )
) ),
T.html [
T.head [ T.title [ my_name ( ) ] ],
T.body [
T.div ( id='TableOfContents' ) [
'Table of Contents',
lambda: T.ul [ [ T.li [ _t ] for _t in TOC ] ]
],
TableOfContents ( ( 'h1', 'h2', 'h3' ), T.div [
T.h1 [ 'Chapter 1' ],
T.div [ 'chapter 1 content' ],
T.h1 [ 'Chapter 2' ],
T.div [
'chapter 2 content',
T.h2 [ 'Chapter 2 subsection' ],
T.div [
'chapter 2 subsection content'
]
]
] )
]
]
)
actual = flatten ( template )
def test_dom_traversal_from_macro():
"""macro abuse: self-traversing template"""
template = (
assign('selectors', []),
macro('css_sep', lambda attr:
attr == 'class' and '.' or '#'
),
macro('get_selectors', lambda tag, is_tag:
selectors.extend([ # @UndefinedVariable
"%s%s%s { }" % (tag.name, css_sep(_k.strip('_')), _v) # @UndefinedVariable
for _k, _v in tag.attrs.items()
if _k.strip('_') in ('id', 'class')
])
),
macro('extract_css', lambda tag:
tag.walk(get_selectors, True) and tag # @UndefinedVariable
),
macro('css_results', lambda selectors:
T.pre['\n'.join(selectors)]
),
T.html[
T.head[T.title['macro madness']],
T.body[extract_css(# @UndefinedVariable
T.div('class', 'text', 'id', 'main-content')[
T.img('src', '/images/breve-logo.png', 'alt', 'breve logo'),
T.br,
T.span (class_='bold') [ """Hello from Breve!""" ]
]
), css_results(selectors)] # @UndefinedVariable
]
)
output = flatten(template)
assert output == ('<html><head><title>macro madness</title></head>'
'<body><div class="text" id="main-content">'
'<img src="/images/breve-logo.png" alt="breve logo"></img>'
'<br /><span class="bold">Hello from Breve!</span></div>'
'<pre>div.text { }\ndiv#main-content { }\nspan.bold { }</pre>'
'</body></html>')
def test_assign_with_macro(self):
'''assign directive with macro'''
T = tags
template = (assign('msg',
'okay'), macro('display_msg',
lambda _m: T.span[_m]),
T.html[T.head[T.title[my_name()]],
T.body[T.div[display_msg(msg)]]])
output = flatten(template)
self.assertEqual(
output,
(u'<html><head><title>test_assign_with_macro</title></head>'
u'<body><div><span>okay</span></div></body></html>'))
def test_assign_with_macro():
"""assign directive with macro"""
template = (
assign('msg', 'okay2'),
macro('display_msg', lambda _m:
T.span[_m]
),
T.html[
T.head[T.title[my_name()]],
T.body[T.div[display_msg(msg)]] # @UndefinedVariable
]
)
output = flatten(template)
assert output == ('<html><head><title>test_assign_with_macro</title></head>'
'<body><div><span>okay2</span></div></body></html>')
def test_autotable_macro ( self ):
'''test autotable macro'''
data = [
[ 'One', 'Two', 'Three', 'Four' ],
range ( 0, 4 ),
range ( 4, 8 ),
range ( 8, 12 )
]
template = (
macro ( 'AutoTable', lambda data, header=False: (
assign ( 'alts', [ 'even', 'odd' ] ),
data and (
T.table ( class_='autotable' ) [
header and (
T.thead [ [ T.th [ _col ] for _col in data [ 0 ] ] ]
),
T.tbody [
[ T.tr ( class_='row-%s' % alts [ _rx % 2 ] ) [
[ T.td ( class_='col-%s' % alts [ _cx % 2 ] ) [ _col ]
for _cx, _col in enumerate ( _row ) ]
] for _rx, _row in enumerate ( data [ int ( header ): ] ) ]
]
]
) or ''
) ),
T.html [
T.head [ T.title [ my_name ( ) ] ],
T.body [
AutoTable ( data, header=True )
]
]
)
output = flatten ( template )
self.assertEqual (
output,
( u'<html><head><title>test_autotable_macro</title></head>'
u'<body><table class="autotable"><thead><th>One</th><th>Two</th><th>Three</th><th>Four</th></thead>'
u'<tbody><tr class="row-even"><td class="col-even">0</td><td class="col-odd">1</td>'
u'<td class="col-even">2</td><td class="col-odd">3</td></tr>'
u'<tr class="row-odd"><td class="col-even">4</td><td class="col-odd">5</td><td class="col-even">6</td>'
u'<td class="col-odd">7</td></tr>'
u'<tr class="row-even"><td class="col-even">8</td><td class="col-odd">9</td>'
u'<td class="col-even">10</td><td class="col-odd">11</td></tr></tbody>'
u'</table></body></html>' )
)
def test_autolist_macro ( self ):
'''test autolist macro'''
sublist1 = [ "List 1:%s" % _i for _i in range ( 3 ) ]
sublist2 = [ "List 2:%s" % _i for _i in range ( 3, 6 ) ]
sublist3 = [ "List 3:%s" % _i for _i in range ( 6, 9 ) ]
sublist3.append ( sublist2 )
data = [
'Item A', 'Item B', 'Item C',
sublist1,
'Item D', 'Item E', 'Item F',
sublist3,
]
template = (
macro ( 'AutoList', lambda data, level=0:
data and (
T.ul ( class_='autolist level-%s' % level ) [
[ T.li [
[ lambda _i, _j: _i, AutoList ]
[ isinstance ( _i, list ) ]( _i, level + 1 )
]
for _i in data ]
]
) or ''
),
T.html [
T.head [ T.title [ my_name ( ) ] ],
T.body [ AutoList ( data ) ]
]
)
output = flatten ( template )
self.assertEqual (
output,
( u'<html><head><title>test_autolist_macro</title></head>'
u'<body><ul class="autolist level-0"><li>Item A</li>'
u'<li>Item B</li><li>Item C</li><li><ul class="autolist level-1">'
u'<li>List 1:0</li><li>List 1:1</li><li>List 1:2</li></ul></li>'
u'<li>Item D</li><li>Item E</li><li>Item F</li><li>'
u'<ul class="autolist level-1"><li>List 3:6</li>'
u'<li>List 3:7</li><li>List 3:8</li><li><ul class="autolist level-2">'
u'<li>List 2:3</li><li>List 2:4</li><li>List 2:5</li></ul>'
u'</li></ul></li></ul></body></html>' )
)
def test_assign_with_macro(self):
"""assign directive with macro"""
T = tags
template = (
assign('msg', 'okay'),
macro('display_msg', lambda _m:
T.span[_m]
),
T.html[
T.head[T.title[my_name()]],
T.body[T.div[display_msg(msg)]]
]
)
output = flatten(template)
self.assertEqual(
output,
(u'<html><head><title>test_assign_with_macro</title></head>'
u'<body><div><span>okay</span></div></body></html>')
)
def test_autolist_macro1():
"""test autolist macro"""
data = ["Item %s" % _i for _i in range(1, 9)]
template = (
macro('AutoList', lambda data:
data and (
T.ul(class_='autolist')[
[T.li[_i] for _i in data]
]
) or ''
),
T.html[
T.head[T.title[my_name()]],
T.body[AutoList(data)] # @UndefinedVariable
]
)
output = flatten(template)
assert output == ('<html><head><title>test_autolist_macro1</title></head>'
'<body><ul class="autolist"><li>Item 1</li><li>Item 2</li>'
'<li>Item 3</li><li>Item 4</li><li>Item 5</li><li>Item 6</li>'
'<li>Item 7</li><li>Item 8</li></ul></body></html>')
