def test_num_literal(self):
self.assertEqual(42, Expression("42").evaluate({}))
if IS_PYTHON2:
self.assertEqual(42, Expression("42L").evaluate({}))
self.assertEqual(.42, Expression(".42").evaluate({}))
if IS_PYTHON2:
self.assertEqual(0o7, Expression("07").evaluate({}))
self.assertEqual(0xF2, Expression("0xF2").evaluate({}))
self.assertEqual(0XF2, Expression("0XF2").evaluate({}))
def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
Directive.__init__(self, None, template, namespaces, lineno, offset)
self.vars = []
value = value.strip()
try:
ast = _parse(value, 'exec')
for node in ast.body:
if not isinstance(node, _ast.Assign):
raise TemplateSyntaxError('only assignment allowed in '
'value of the "with" directive',
template.filepath, lineno, offset)
self.vars.append(([_assignment(n) for n in node.targets],
Expression(node.value, template.filepath,
lineno, lookup=template.lookup)))
except SyntaxError as err:
err.msg += ' in expression "%s" of "%s" directive' % (value,
self.tagname)
raise TemplateSyntaxError(err, template.filepath, lineno,
offset + (err.offset or 0))
def process(self, stream, directives, ctxt, vars):
try:
render_context = ctxt['flatland_render_context']
except KeyError:
ctxt['flatland_render_context'] = render_context = Context()
if 'filters' not in self.attributes:
attrs = self.attributes
else:
attrs = self.attributes.copy()
attrs['filters'] = _eval_expr(Expression(attrs['filters']), ctxt,
vars)
render_context.push()
render_context.update(attrs)
assert not directives
for event in stream:
yield event
render_context.pop()
def test_error_access_undefined(self):
expr = Expression("nothing", filename='index.html', lineno=50,
lookup='strict')
try:
expr.evaluate({})
self.fail('Expected UndefinedError')
except UndefinedError as e:
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('"nothing" not defined', str(e))
self.assertEqual("<Expression 'nothing'>",
frames[-3].tb_frame.f_code.co_name)
self.assertEqual('index.html',
frames[-3].tb_frame.f_code.co_filename)
self.assertEqual(50, frames[-3].tb_lineno)
def test_error_getitem_undefined_string(self):
class Something(object):
def __repr__(self):
return '<Something>'
expr = Expression('something["nil"]', filename='index.html', lineno=50,
lookup='strict')
try:
expr.evaluate({'something': Something()})
self.fail('Expected UndefinedError')
except UndefinedError as e:
self.assertEqual('<Something> has no member named "nil"', str(e))
exc_type, exc_value, exc_traceback = sys.exc_info()
search_string = '''<Expression 'something["nil"]'>'''
frame = exc_traceback.tb_next
while frame.tb_next:
frame = frame.tb_next
code = frame.tb_frame.f_code
if code.co_name == search_string:
break
else:
self.fail("never found the frame I was looking for")
self.assertEqual('index.html', code.co_filename)
self.assertEqual(50, frame.tb_lineno)
def __init__(self, args, template, namespaces=None, lineno=-1, offset=-1):
Directive.__init__(self, None, template, namespaces, lineno, offset)
ast = _parse(args).body
self.args = []
self.star_args = None
self.dstar_args = None
self.defaults = {}
if isinstance(ast, _ast.Call):
self.name = ast.func.id
for arg in ast.args:
# only names
self.args.append(arg.id)
for kwd in ast.keywords:
self.args.append(kwd.arg)
exp = Expression(kwd.value, template.filepath,
lineno, lookup=template.lookup)
self.defaults[kwd.arg] = exp
if getattr(ast, 'starargs', None):
self.star_args = ast.starargs.id
if getattr(ast, 'kwargs', None):
self.dstar_args = ast.kwargs.id
else:
self.name = ast.id
def test_tuple_literal(self):
self.assertEqual((), Expression("()").evaluate({}))
self.assertEqual((1, 2, 3), Expression("(1, 2, 3)").evaluate({}))
self.assertEqual((True, ),
Expression("(value,)").evaluate({'value': True}))
def test_dict_literal(self):
self.assertEqual({}, Expression("{}").evaluate({}))
self.assertEqual({'key': True},
Expression("{'key': value}").evaluate({'value':
True}))
def test_name_lookup(self):
self.assertEqual('bar', Expression('foo').evaluate({'foo': 'bar'}))
self.assertEqual(id, Expression('id').evaluate({}))
self.assertEqual('bar', Expression('id').evaluate({'id': 'bar'}))
self.assertEqual(None, Expression('id').evaluate({'id': None}))
def test_slice_negative_start(self):
expr = Expression("numbers[-1:]")
self.assertEqual([4], expr.evaluate({'numbers': range(5)}))
def test_slice(self):
expr = Expression("numbers[0:2]")
self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
def test_generator_expression_with_getitem(self):
items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
expr = Expression("list(i['name'] for i in items if i['value'] > 1)")
self.assertEqual(['b'], expr.evaluate({'items': items}))
def test_binop_xor(self):
self.assertEqual(1, Expression("1 ^ 0").evaluate({}))
self.assertEqual(1, Expression("x ^ y").evaluate({'x': 1, 'y': 0}))
def test_binop_and(self):
self.assertEqual(0, Expression("1 & 0").evaluate({}))
self.assertEqual(0, Expression("x & y").evaluate({'x': 1, 'y': 0}))
def test_binop_mod(self):
self.assertEqual(1, Expression("3 % 2").evaluate({}))
self.assertEqual(1, Expression("x % y").evaluate({'x': 3, 'y': 2}))
def test_hash(self):
expr = Expression('x,y')
self.assertEqual(hash(expr), hash(Expression('x,y')))
self.assertNotEqual(hash(expr), hash(Expression('y, x')))
def test_list_comprehension_with_getitem(self):
items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
expr = Expression("[i['name'] for i in items if i['value'] > 1]")
self.assertEqual(['b'], expr.evaluate({'items': items}))
def test_compare_lt(self):
self.assertEqual(True, Expression("1 < 2").evaluate({}))
self.assertEqual(True, Expression("x < y").evaluate({'x': 1, 'y': 2}))
def test_conditional_expression(self):
expr = Expression("'T' if foo else 'F'")
self.assertEqual('T', expr.evaluate({'foo': True}))
self.assertEqual('F', expr.evaluate({'foo': False}))
def test_compare_gt(self):
self.assertEqual(True, Expression("2 > 1").evaluate({}))
self.assertEqual(True, Expression("x > y").evaluate({'x': 2, 'y': 1}))
def test_slice_copy(self):
expr = Expression("numbers[:]")
self.assertEqual([0, 1, 2, 3, 4], expr.evaluate({'numbers': range(5)}))
def test_compare_ge(self):
self.assertEqual(True, Expression("1 >= 1").evaluate({}))
self.assertEqual(True, Expression("x >= y").evaluate({'x': 1, 'y': 1}))
def test_slice_negative_end(self):
expr = Expression("numbers[:-1]")
self.assertEqual([0, 1, 2, 3], expr.evaluate({'numbers': range(5)}))
def test_call_function(self):
self.assertEqual(42, Expression("foo()").evaluate({'foo': lambda: 42}))
data = {'foo': 'bar'}
self.assertEqual('BAR', Expression("foo.upper()").evaluate(data))
data = {'foo': {'bar': range(42)}}
self.assertEqual(42, Expression("len(foo.bar)").evaluate(data))
def test_builtins(self):
expr = Expression('Markup')
self.assertEqual(expr.evaluate({}), Markup)
def test_eq(self):
expr = Expression('x,y')
self.assertEqual(expr, Expression('x,y'))
self.assertNotEqual(expr, Expression('y, x'))
def test_list_literal(self):
self.assertEqual([], Expression("[]").evaluate({}))
self.assertEqual([1, 2, 3], Expression("[1, 2, 3]").evaluate({}))
self.assertEqual([True],
Expression("[value]").evaluate({'value': True}))
def test_call_dstar_args(self):
def foo(x):
return x
expr = Expression("foo(**bar)")
self.assertEqual(42, expr.evaluate({'foo': foo, 'bar': {"x": 42}}))
def test_unaryop_pos(self):
self.assertEqual(1, Expression("+1").evaluate({}))
self.assertEqual(1, Expression("+x").evaluate({'x': 1}))
def test_lambda(self):
data = {'items': range(5)}
expr = Expression("filter(lambda x: x > 2, items)")
self.assertEqual([3, 4], expr.evaluate(data))
