def check_exprs(src, env=None, errors=None):
node = parse(src)
env = env or {}
env.update(def_types(node))
node = check(node, Environ(env, errors))
LocationChecker().visit(node)
return node
def test_requirements():
node = parse(u"""
def baz
div #b.count
def bar
span #a.name
span y
baz :b #a
span #c
def foo
div
each i x
bar :a i :c 5
""")
node = check(
node,
Environ({
'x': ListType[Record[{
'name': StringType,
'count': IntType
}]],
'y': StringType,
}))
mapping = extract(node)
with query_eq_patcher():
check_eq(
mapping['foo'],
Edge(
[Field('y'),
Link('x', Edge([Field('count'), Field('name')]))]))
def assertCompiles(self, src, code, env=None):
node = parse(src)
node = check(node, Environ(env or {}))
mod = compile_module(node)
first = dumps(mod).strip()
second = dedent(code).strip()
if first != second:
msg = ('Compiled code is not equal:\n\n{}'.format('\n'.join(
difflib.ndiff(first.splitlines(), second.splitlines()))))
raise self.failureException(msg)
def assertCompiles(self, src, code, env=None):
node = parse(src)
node = check(node, Environ(env))
mod = compile_module(node)
try:
compile(mod, '<kinko-template>', 'exec')
except TypeError:
print(dumps(mod))
raise
else:
self.compareSources(dumps(mod), code)
def testModule(self):
foo_node = parse("""
def func1
div
./func2
def func2
div
bar/func3
""")
bar_node = parse("""
def func3
div "Text"
""")
foo_node = NamesResolver('foo').visit(foo_node)
bar_node = NamesResolver('bar').visit(bar_node)
node = collect_defs([foo_node, bar_node])
env = Environ(def_types(node))
node = check(node, env)
modules = split_defs(node)
foo_node = modules['foo']
bar_node = modules['bar']
foo_node = NamesUnResolver('foo').visit(foo_node)
bar_node = NamesUnResolver('bar').visit(bar_node)
foo_module = compile_module(foo_node)
_exec_in(compile(foo_module, '<kinko:foo>', 'exec'), {})
self.compareSources(
dumps(foo_module),
"""
def func1(ctx):
ctx.buffer.write('<div>')
func2(ctx)
ctx.buffer.write('</div>')
def func2(ctx):
ctx.buffer.write('<div>')
ctx.lookup('bar/func3')(ctx)
ctx.buffer.write('</div>')
""",
)
bar_module = compile_module(bar_node)
_exec_in(compile(bar_module, '<kinko:bar>', 'exec'), {})
self.compareSources(
dumps(bar_module),
"""
def func3(ctx):
ctx.buffer.write('<div>Text</div>')
""",
)
def testModule(self):
foo_node = parse("""
def func1
div
./func2
def func2
div
bar/func3
""")
bar_node = parse("""
def func3
div "Text"
""")
foo_node = NamesResolver('foo').visit(foo_node)
bar_node = NamesResolver('bar').visit(bar_node)
node = collect_defs([foo_node, bar_node])
env = Environ(def_types(node))
node = check(node, env)
modules = split_defs(node)
foo_node = modules['foo']
bar_node = modules['bar']
foo_node = NamesUnResolver('foo').visit(foo_node)
bar_node = NamesUnResolver('bar').visit(bar_node)
foo_module = compile_module(foo_node)
_exec_in(compile(foo_module, '<kinko:foo>', 'exec'), {})
self.compareSources(
dumps(foo_module),
"""
def func1(ctx):
ctx.buffer.write('<div>')
func2(ctx)
ctx.buffer.write('</div>')
def func2(ctx):
ctx.buffer.write('<div>')
ctx.lookup('bar/func3')(ctx)
ctx.buffer.write('</div>')
""",
)
bar_module = compile_module(bar_node)
_exec_in(compile(bar_module, '<kinko:bar>', 'exec'), {})
self.compareSources(
dumps(bar_module),
"""
def func3(ctx):
ctx.buffer.write('<div>Text</div>')
""",
)
def assertCompiles(self, src, code, env=None):
node = parse(src)
node = check(node, Environ(env))
mod = compile_module(node)
try:
compile(mod, '<kinko-template>', 'exec')
except TypeError:
print(dumps(mod))
raise
else:
self.compareSources(dumps(mod), code)
def assertCompiles(self, src, code, env=None):
node = parse(src)
node = check(node, Environ(env or {}))
mod = compile_module(node)
first = dumps(mod).strip()
second = dedent(code).strip()
if first != second:
msg = ('Compiled code is not equal:\n\n{}'
.format('\n'.join(difflib.ndiff(first.splitlines(),
second.splitlines()))))
raise self.failureException(msg)
def assertRenders(self, src, content, context=None, env=None):
node = parse(src)
node = check(node, Environ(env))
mod = compile_module(node)
mod_code = compile(mod, '<kinko-template>', 'exec')
ctx = SimpleContext(context or {})
ctx.buffer.push()
ns = {}
_exec_in(mod_code, ns)
ns['foo'](ctx)
rendered = ctx.buffer.pop()
self.assertEqual(rendered, content)
def assertRenders(self, src, content, context=None, env=None):
node = parse(src)
node = check(node, Environ(env))
mod = compile_module(node)
mod_code = compile(mod, '<kinko-template>', 'exec')
ctx = SimpleContext(context or {})
ctx.buffer.push()
ns = {}
_exec_in(mod_code, ns)
ns['foo'](ctx)
rendered = ctx.buffer.pop()
self.assertEqual(rendered, content)
def test_dependent():
node = parse("""
def foo
./bar :arg "value"
def bar
#arg
""")
node = NamesResolver('test').visit(node)
env = Environ(def_types(node))
node = check(node, env)
foo_expr, bar_expr = node.values
check_eq(foo_expr.__type__, Func[[], StringType])
check_eq(bar_expr.__type__,
Func[[NamedArg['arg', TypeVar[None]]],
TypeVar[None]])
# checks that TypeVar instance is the same
assert bar_expr.__type__.__instance__.__args__[0].__arg_type__ is \
bar_expr.__type__.__instance__.__result__
def get_refs(src, env=None):
node = check(parse(src), Environ(env))
refs_collector = RefsCollector()
refs_collector.visit(node)
return node, refs_collector.refs
def check_expr(src, env=None, errors=None):
node = check(parse(src).values[0], Environ(env, errors))
LocationChecker().visit(node)
return node
