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 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 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