def test_let_directive_scope(self):
'''test let directive's scope'''
vars = dict(message='hello, from breve',
title=my_name(),
do_fail=False)
# don't fail - use variable in scope
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
# do fail - try to use the variable out of scope
vars['do_fail'] = True
t = Template(html, root=template_root())
self.failUnlessRaises(NameError,
t.render,
'index',
vars,
namespace='v')
def test_macro_includes(self):
'''include() directive inside macro'''
vars = dict(message='hello, from breve', title=my_name())
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_simple_template(self):
'''simple template'''
vars = dict(message='hello, from breve', title=my_name())
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_loop_include(self):
'''looping over include() with listcomp'''
vars = dict(message='hello, from breve', title=my_name())
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_instantiation_parameters(self):
'''test instantiation parameters'''
# change the defaults to something else
args = {
'tidy': True,
'debug': True,
'namespace': 'v',
'mashup_entities': True,
'extension': '.breve'
}
t = Template(html, root=template_root(), **args)
for k, v in args.items():
self.failUnless(getattr(t, k) == v)
def test_assign_scope(self):
'''test assign directive's scope'''
vars = dict(message='hello, from breve', title=my_name())
# don't fail - use variable in scope
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_render_parameters(self):
'''test render-time parameters'''
vars = dict(message='hello, from breve', title=my_name())
args = {
'tidy': True,
'debug': True,
'namespace': 'v',
'extension': '.breve'
}
t = Template(html, root=template_root())
t.render('index', vars, **args)
for k, v in args.items():
self.failUnless(getattr(t, k) == v)
def test_encoding(self):
'''encoding comments'''
vars = dict(title=my_name())
t = Template(html, root=template_root())
actual = t.render('wrong', vars, namespace='v')
expected = expected_output()
self.assertNotEqual(actual, expected)
actual = t.render('correct', vars, namespace='v')
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_macros_inside_inherits(self):
'''test macros inside inherits(): scope issues'''
# note: I'm not convinced this is the desired behaviour, but
# it's *compatible* behaviour.
vars = dict(title=my_name(), message='Hello, from breve')
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_register_global(self):
'''register_global() function'''
vars = dict(title=my_name())
register_global('global_message', 'This is a global variable')
test_name = my_name()
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_stacks_template(self):
'''test stacks in template'''
vars = dict(title=my_name(), message='hello, from breve')
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
# stack should be empty when we finish
self.failUnless(not get_stacks())
def render(self, info, format="html", fragment=False, template=None):
"""
info == dict of variables to stick into the template namespace
format == output format if applicable
fragment == special rules about rendering part of a page
template == dotted.path.to.template (without .ext)
"""
vars = info
# check to see if we were passed a function get extra vars
if callable(self.get_extra_vars):
vars.update(self.get_extra_vars())
self.breve_opts.update(self.get_config(vars))
template_path, template_filename, args = self.load_template(template)
# self.breve_opts.update ( args )
template_root = self.breve_opts['root']
format = args.get('format', format)
if template_root and template_path.startswith(template_root):
# this feels mildly brittle
template_path = template_path[len(template_root) + 1:]
if format not in self.tag_defs:
# this seems weak (concerns about path). Should perhaps
# find a better way, but getting only a string for format
# makes it difficult to do too much
self.tag_defs[format] = __import__(format, {}, {})
self.breve_opts['doctype'] = self.breve_opts.get(
'doctype', self.tag_defs[format].doctype)
template_obj = Template(tags=self.tag_defs[format].tags,
xmlns=self.tag_defs[format].xmlns,
**self.breve_opts)
if fragment:
return template_obj.render_partial(os.path.join(
template_path, template_filename),
vars=vars,
**self.breve_opts)
return template_obj.render(os.path.join(template_path,
template_filename),
vars=vars,
**self.breve_opts)
def test_let_memory_freed(self):
'''test that let() objects are freed'''
# is this even meaningful?
import gc
vars = dict(title=my_name(),
message="memory test",
biglist=['hello'] * 1000)
collection_count = gc.get_count()
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
del vars
gc.collect()
self.assertEqual(gc.get_count(), (0, 0, 0))
def test_custom_renderer_notag(self):
'''custom renderer returning non-Tag type'''
def render_text(tag, data):
tag.clear()
return data
register_global('render_text', render_text)
vars = dict(title=my_name(), message='hello, world')
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def render(template_name, tmpl_vars=None, loader=None, fragment=False):
if tmpl_vars is None:
tmpl_vars = {}
g = pylons_globals()
tmpl_vars.update(g)
try:
opts = g['app_globals'].breve_opts
except AttributeError:
opts = {}
t = Template(tags, **opts)
return t.render(template_name,
vars=tmpl_vars,
loader=loader,
fragment=fragment)
def test_register_flattener(self):
'''register_flattener() function'''
def flatten_date(o):
return escape(o.strftime('%Y/%m/%d'))
register_flattener(datetime, flatten_date)
register_global('flatten_date', flatten_date)
vars = dict(title=my_name(), today=datetime(2008, 4, 17))
test_name = my_name()
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_loop_macros(self):
'''loop using macro'''
vars = dict(message='hello, from breve',
title=my_name(),
url_data=[
dict(url='http://www.google.com', label='Google'),
dict(url='http://www.yahoo.com', label='Yahoo!'),
dict(url='http://www.amazon.com', label='Amazon')
])
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_custom_renderer(self):
'''custom renderer'''
def render_row(tag, data):
T = html
tag.clear()
return tag[[T.td[_i] for _i in data]]
register_global('render_row', render_row)
vars = dict(title=my_name(),
my_data=[range(5), range(5, 10),
range(10, 15)])
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def test_custom_loader_stack(self):
'''custom loader stack'''
class PathLoader(object):
__slots__ = ['paths']
def __init__(self, *paths):
self.paths = paths
def stat(self, template, root):
for p in self.paths:
f = os.path.join(root, p, template)
if os.path.isfile(f):
timestamp = long(os.stat(f).st_mtime)
uid = f
return uid, timestamp
raise OSError, 'No such file or directory %s' % template
def load(self, uid):
return file(uid, 'U').read()
loader = PathLoader(
template_root(),
os.path.join(template_root(), 'path1'),
os.path.join(template_root(), 'path2'),
os.path.join(template_root(), 'path3'),
)
register_global('path_loader', loader)
vars = dict(title=my_name(), message='hello, world')
test_name = my_name()
t = Template(html, root=template_root())
actual = t.render('index', vars, namespace='v')
expected = expected_output()
try:
self.assertEqual(actual, expected)
except AssertionError:
diff(actual, expected)
raise
def __init__ ( self, names, root = BREVE_ROOT, breve_opts = { } ):
self.template = Template ( tags = html.tags, root = root, **breve_opts )
self.names = names
self.breve_opts = breve_opts
def _render ( *args, **kw ):
t = Template ( tags, **template_kw )
values = f ( *args, **kw )
return t.render ( template, values )
host = 'localhost',
port = 53306,
user = '******',
passwd = 'xxxxxxx',
db = 'minecraft'
)
lwc = sqlite3.connect('/home/mc/backup/plugins/LWC/lwc.db')
f = open('/home/mc/backup/plugins/PermissionsBukkit/config.yml', 'r')
data = yaml.safe_load(f)
f.close()
modaccounts = [u[0] for u in dict.items(data['users']) if 'modaccount' in u[1]['groups'] ]
moderators = [u[0] for u in dict.items(data['users']) if 'moderator' in u[1]['groups'] ]
day = sys.argv[1]
t = Template ( tags, root = '.' )
t.doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
vars = dict (
day = day,
players = map(collectActivity, modaccounts),
)
logblock.close()
lwc.close()
print t.render ( 'index', vars )
def build_game_message(game):
t = Template(tags, root='./templates/')
content = t.render('game', game)
return content
