| from mako import exceptions | |
| from mako import lookup | |
| from mako.template import Template | |
| from mako.testing.assertions import assert_raises | |
| from mako.testing.assertions import assert_raises_message_with_given_cause | |
| from mako.testing.assertions import eq_ | |
| from mako.testing.fixtures import TemplateTest | |
| from mako.testing.helpers import flatten_result | |
| from mako.testing.helpers import result_lines | |
| class NamespaceTest(TemplateTest): | |
| def test_inline_crossreference(self): | |
| self._do_memory_test( | |
| """ | |
| <%namespace name="x"> | |
| <%def name="a()"> | |
| this is x a | |
| </%def> | |
| <%def name="b()"> | |
| this is x b, and heres ${a()} | |
| </%def> | |
| </%namespace> | |
| ${x.a()} | |
| ${x.b()} | |
| """, | |
| "this is x a this is x b, and heres this is x a", | |
| filters=flatten_result, | |
| ) | |
| def test_inline_assignment(self): | |
| self._do_memory_test( | |
| """ | |
| <%namespace name="x"> | |
| <%def name="a()"> | |
| <% | |
| x = 5 | |
| %> | |
| this is x: ${x} | |
| </%def> | |
| </%namespace> | |
| ${x.a()} | |
| """, | |
| "this is x: 5", | |
| filters=flatten_result, | |
| ) | |
| def test_inline_arguments(self): | |
| self._do_memory_test( | |
| """ | |
| <%namespace name="x"> | |
| <%def name="a(x, y)"> | |
| <% | |
| result = x * y | |
| %> | |
| result: ${result} | |
| </%def> | |
| </%namespace> | |
| ${x.a(5, 10)} | |
| """, | |
| "result: 50", | |
| filters=flatten_result, | |
| ) | |
| def test_inline_not_duped(self): | |
| self._do_memory_test( | |
| """ | |
| <%namespace name="x"> | |
| <%def name="a()"> | |
| foo | |
| </%def> | |
| </%namespace> | |
| <% | |
| assert x.a is not UNDEFINED, "namespace x.a wasn't defined" | |
| assert a is UNDEFINED, "name 'a' is in the body locals" | |
| %> | |
| """, | |
| "", | |
| filters=flatten_result, | |
| ) | |
| def test_dynamic(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "a", | |
| """ | |
| <%namespace name="b" file="${context['b_def']}"/> | |
| a. b: ${b.body()} | |
| """, | |
| ) | |
| collection.put_string( | |
| "b", | |
| """ | |
| b. | |
| """, | |
| ) | |
| eq_( | |
| flatten_result(collection.get_template("a").render(b_def="b")), | |
| "a. b: b.", | |
| ) | |
| def test_template(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="comp" file="defs.html"/> | |
| this is main. ${comp.def1("hi")} | |
| ${comp.def2("there")} | |
| """, | |
| ) | |
| collection.put_string( | |
| "defs.html", | |
| """ | |
| <%def name="def1(s)"> | |
| def1: ${s} | |
| </%def> | |
| <%def name="def2(x)"> | |
| def2: ${x} | |
| </%def> | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is main. def1: hi def2: there" | |
| ) | |
| def test_module(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="comp" module="test.sample_module_namespace"/> | |
| this is main. ${comp.foo1()} | |
| ${comp.foo2("hi")} | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is main. this is foo1. this is foo2, x is hi" | |
| ) | |
| def test_module_2(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="comp" module="test.foo.test_ns"/> | |
| this is main. ${comp.foo1()} | |
| ${comp.foo2("hi")} | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is main. this is foo1. this is foo2, x is hi" | |
| ) | |
| def test_module_imports(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace import="*" module="test.foo.test_ns"/> | |
| this is main. ${foo1()} | |
| ${foo2("hi")} | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is main. this is foo1. this is foo2, x is hi" | |
| ) | |
| def test_module_imports_2(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace import="foo1, foo2" module="test.foo.test_ns"/> | |
| this is main. ${foo1()} | |
| ${foo2("hi")} | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is main. this is foo1. this is foo2, x is hi" | |
| ) | |
| def test_context(self): | |
| """test that namespace callables get access to the current context""" | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="comp" file="defs.html"/> | |
| this is main. ${comp.def1()} | |
| ${comp.def2("there")} | |
| """, | |
| ) | |
| collection.put_string( | |
| "defs.html", | |
| """ | |
| <%def name="def1()"> | |
| def1: x is ${x} | |
| </%def> | |
| <%def name="def2(x)"> | |
| def2: x is ${x} | |
| </%def> | |
| """, | |
| ) | |
| assert ( | |
| flatten_result( | |
| collection.get_template("main.html").render(x="context x") | |
| ) | |
| == "this is main. def1: x is context x def2: x is there" | |
| ) | |
| def test_overload(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="comp" file="defs.html"> | |
| <%def name="def1(x, y)"> | |
| overridden def1 ${x}, ${y} | |
| </%def> | |
| </%namespace> | |
| this is main. ${comp.def1("hi", "there")} | |
| ${comp.def2("there")} | |
| """, | |
| ) | |
| collection.put_string( | |
| "defs.html", | |
| """ | |
| <%def name="def1(s)"> | |
| def1: ${s} | |
| </%def> | |
| <%def name="def2(x)"> | |
| def2: ${x} | |
| </%def> | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is main. overridden def1 hi, there def2: there" | |
| ) | |
| def test_getattr(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="foo" file="ns.html"/> | |
| <% | |
| if hasattr(foo, 'lala'): | |
| foo.lala() | |
| if not hasattr(foo, 'hoho'): | |
| context.write('foo has no hoho.') | |
| %> | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns.html", | |
| """ | |
| <%def name="lala()">this is lala.</%def> | |
| """, | |
| ) | |
| assert ( | |
| flatten_result(collection.get_template("main.html").render()) | |
| == "this is lala.foo has no hoho." | |
| ) | |
| def test_in_def(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="foo" file="ns.html"/> | |
| this is main. ${bar()} | |
| <%def name="bar()"> | |
| this is bar, foo is ${foo.bar()} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns.html", | |
| """ | |
| <%def name="bar()"> | |
| this is ns.html->bar | |
| </%def> | |
| """, | |
| ) | |
| assert result_lines(collection.get_template("main.html").render()) == [ | |
| "this is main.", | |
| "this is bar, foo is", | |
| "this is ns.html->bar", | |
| ] | |
| def test_in_remote_def(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="foo" file="ns.html"/> | |
| this is main. ${bar()} | |
| <%def name="bar()"> | |
| this is bar, foo is ${foo.bar()} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns.html", | |
| """ | |
| <%def name="bar()"> | |
| this is ns.html->bar | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%namespace name="main" file="main.html"/> | |
| this is index | |
| ${main.bar()} | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == ["this is index", "this is bar, foo is", "this is ns.html->bar"] | |
| def test_dont_pollute_self(self): | |
| # test that get_namespace() doesn't modify the original context | |
| # incompatibly | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%def name="foo()"> | |
| <% | |
| foo = local.get_namespace("foo.html") | |
| %> | |
| </%def> | |
| name: ${self.name} | |
| name via bar: ${bar()} | |
| ${next.body()} | |
| name: ${self.name} | |
| name via bar: ${bar()} | |
| <%def name="bar()"> | |
| ${self.name} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "page.html", | |
| """ | |
| <%inherit file="base.html"/> | |
| ${self.foo()} | |
| hello world | |
| """, | |
| ) | |
| collection.put_string("foo.html", """<%inherit file="base.html"/>""") | |
| assert result_lines(collection.get_template("page.html").render()) == [ | |
| "name: self:page.html", | |
| "name via bar:", | |
| "self:page.html", | |
| "hello world", | |
| "name: self:page.html", | |
| "name via bar:", | |
| "self:page.html", | |
| ] | |
| def test_inheritance(self): | |
| """test namespace initialization in a base inherited template that | |
| doesnt otherwise access the namespace""" | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%namespace name="foo" file="ns.html" inheritable="True"/> | |
| ${next.body()} | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns.html", | |
| """ | |
| <%def name="bar()"> | |
| this is ns.html->bar | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%inherit file="base.html"/> | |
| this is index | |
| ${self.foo.bar()} | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == ["this is index", "this is ns.html->bar"] | |
| def test_inheritance_two(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%def name="foo()"> | |
| base.foo | |
| </%def> | |
| <%def name="bat()"> | |
| base.bat | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "lib.html", | |
| """ | |
| <%inherit file="base.html"/> | |
| <%def name="bar()"> | |
| lib.bar | |
| ${parent.foo()} | |
| ${self.foo()} | |
| ${parent.bat()} | |
| ${self.bat()} | |
| </%def> | |
| <%def name="foo()"> | |
| lib.foo | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "front.html", | |
| """ | |
| <%namespace name="lib" file="lib.html"/> | |
| ${lib.bar()} | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("front.html").render() | |
| ) == ["lib.bar", "base.foo", "lib.foo", "base.bat", "base.bat"] | |
| def test_attr(self): | |
| l = lookup.TemplateLookup() | |
| l.put_string( | |
| "foo.html", | |
| """ | |
| <%! | |
| foofoo = "foo foo" | |
| onlyfoo = "only foo" | |
| %> | |
| <%inherit file="base.html"/> | |
| <%def name="setup()"> | |
| <% | |
| self.attr.foolala = "foo lala" | |
| %> | |
| </%def> | |
| ${self.attr.basefoo} | |
| ${self.attr.foofoo} | |
| ${self.attr.onlyfoo} | |
| ${self.attr.lala} | |
| ${self.attr.foolala} | |
| """, | |
| ) | |
| l.put_string( | |
| "base.html", | |
| """ | |
| <%! | |
| basefoo = "base foo 1" | |
| foofoo = "base foo 2" | |
| %> | |
| <% | |
| self.attr.lala = "base lala" | |
| %> | |
| ${self.attr.basefoo} | |
| ${self.attr.foofoo} | |
| ${self.attr.onlyfoo} | |
| ${self.attr.lala} | |
| ${self.setup()} | |
| ${self.attr.foolala} | |
| body | |
| ${self.body()} | |
| """, | |
| ) | |
| assert result_lines(l.get_template("foo.html").render()) == [ | |
| "base foo 1", | |
| "foo foo", | |
| "only foo", | |
| "base lala", | |
| "foo lala", | |
| "body", | |
| "base foo 1", | |
| "foo foo", | |
| "only foo", | |
| "base lala", | |
| "foo lala", | |
| ] | |
| def test_attr_raise(self): | |
| l = lookup.TemplateLookup() | |
| l.put_string( | |
| "foo.html", | |
| """ | |
| <%def name="foo()"> | |
| </%def> | |
| """, | |
| ) | |
| l.put_string( | |
| "bar.html", | |
| """ | |
| <%namespace name="foo" file="foo.html"/> | |
| ${foo.notfoo()} | |
| """, | |
| ) | |
| assert_raises(AttributeError, l.get_template("bar.html").render) | |
| def test_custom_tag_1(self): | |
| template = Template( | |
| """ | |
| <%def name="foo(x, y)"> | |
| foo: ${x} ${y} | |
| </%def> | |
| <%self:foo x="5" y="${7+8}"/> | |
| """ | |
| ) | |
| assert result_lines(template.render()) == ["foo: 5 15"] | |
| def test_custom_tag_2(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%def name="foo(x, y)"> | |
| foo: ${x} ${y} | |
| </%def> | |
| <%def name="bat(g)"><% | |
| return "the bat! %s" % g | |
| %></%def> | |
| <%def name="bar(x)"> | |
| ${caller.body(z=x)} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%namespace name="myns" file="base.html"/> | |
| <%myns:foo x="${'some x'}" y="some y"/> | |
| <%myns:bar x="${myns.bat(10)}" args="z"> | |
| record: ${z} | |
| </%myns:bar> | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == ["foo: some x some y", "record: the bat! 10"] | |
| def test_custom_tag_3(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%namespace name="foo" file="ns.html" inheritable="True"/> | |
| ${next.body()} | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns.html", | |
| """ | |
| <%def name="bar()"> | |
| this is ns.html->bar | |
| caller body: ${caller.body()} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%inherit file="base.html"/> | |
| this is index | |
| <%self.foo:bar> | |
| call body | |
| </%self.foo:bar> | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == [ | |
| "this is index", | |
| "this is ns.html->bar", | |
| "caller body:", | |
| "call body", | |
| ] | |
| def test_custom_tag_case_sensitive(self): | |
| t = Template( | |
| """ | |
| <%def name="renderPanel()"> | |
| panel ${caller.body()} | |
| </%def> | |
| <%def name="renderTablePanel()"> | |
| <%self:renderPanel> | |
| hi | |
| </%self:renderPanel> | |
| </%def> | |
| <%self:renderTablePanel/> | |
| """ | |
| ) | |
| assert result_lines(t.render()) == ["panel", "hi"] | |
| def test_expr_grouping(self): | |
| """test that parenthesis are placed around string-embedded | |
| expressions.""" | |
| template = Template( | |
| """ | |
| <%def name="bar(x, y)"> | |
| ${x} | |
| ${y} | |
| </%def> | |
| <%self:bar x=" ${foo} " y="x${g and '1' or '2'}y"/> | |
| """, | |
| input_encoding="utf-8", | |
| ) | |
| # the concat has to come out as "x + (g and '1' or '2') + y" | |
| assert result_lines(template.render(foo="this is foo", g=False)) == [ | |
| "this is foo", | |
| "x2y", | |
| ] | |
| def test_ccall(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%namespace name="foo" file="ns.html" inheritable="True"/> | |
| ${next.body()} | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns.html", | |
| """ | |
| <%def name="bar()"> | |
| this is ns.html->bar | |
| caller body: ${caller.body()} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%inherit file="base.html"/> | |
| this is index | |
| <%call expr="self.foo.bar()"> | |
| call body | |
| </%call> | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == [ | |
| "this is index", | |
| "this is ns.html->bar", | |
| "caller body:", | |
| "call body", | |
| ] | |
| def test_ccall_2(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "base.html", | |
| """ | |
| <%namespace name="foo" file="ns1.html" inheritable="True"/> | |
| ${next.body()} | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns1.html", | |
| """ | |
| <%namespace name="foo2" file="ns2.html"/> | |
| <%def name="bar()"> | |
| <%call expr="foo2.ns2_bar()"> | |
| this is ns1.html->bar | |
| caller body: ${caller.body()} | |
| </%call> | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "ns2.html", | |
| """ | |
| <%def name="ns2_bar()"> | |
| this is ns2.html->bar | |
| caller body: ${caller.body()} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%inherit file="base.html"/> | |
| this is index | |
| <%call expr="self.foo.bar()"> | |
| call body | |
| </%call> | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == [ | |
| "this is index", | |
| "this is ns2.html->bar", | |
| "caller body:", | |
| "this is ns1.html->bar", | |
| "caller body:", | |
| "call body", | |
| ] | |
| def test_import(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "functions.html", | |
| """ | |
| <%def name="foo()"> | |
| this is foo | |
| </%def> | |
| <%def name="bar()"> | |
| this is bar | |
| </%def> | |
| <%def name="lala()"> | |
| this is lala | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "func2.html", | |
| """ | |
| <%def name="a()"> | |
| this is a | |
| </%def> | |
| <%def name="b()"> | |
| this is b | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%namespace file="functions.html" import="*"/> | |
| <%namespace file="func2.html" import="a, b"/> | |
| ${foo()} | |
| ${bar()} | |
| ${lala()} | |
| ${a()} | |
| ${b()} | |
| ${x} | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render( | |
| bar="this is bar", x="this is x" | |
| ) | |
| ) == [ | |
| "this is foo", | |
| "this is bar", | |
| "this is lala", | |
| "this is a", | |
| "this is b", | |
| "this is x", | |
| ] | |
| def test_import_calledfromdef(self): | |
| l = lookup.TemplateLookup() | |
| l.put_string( | |
| "a", | |
| """ | |
| <%def name="table()"> | |
| im table | |
| </%def> | |
| """, | |
| ) | |
| l.put_string( | |
| "b", | |
| """ | |
| <%namespace file="a" import="table"/> | |
| <% | |
| def table2(): | |
| table() | |
| return "" | |
| %> | |
| ${table2()} | |
| """, | |
| ) | |
| t = l.get_template("b") | |
| assert flatten_result(t.render()) == "im table" | |
| def test_closure_import(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "functions.html", | |
| """ | |
| <%def name="foo()"> | |
| this is foo | |
| </%def> | |
| <%def name="bar()"> | |
| this is bar | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%namespace file="functions.html" import="*"/> | |
| <%def name="cl1()"> | |
| ${foo()} | |
| </%def> | |
| <%def name="cl2()"> | |
| ${bar()} | |
| </%def> | |
| ${cl1()} | |
| ${cl2()} | |
| """, | |
| ) | |
| assert result_lines( | |
| collection.get_template("index.html").render( | |
| bar="this is bar", x="this is x" | |
| ) | |
| ) == ["this is foo", "this is bar"] | |
| def test_import_local(self): | |
| t = Template( | |
| """ | |
| <%namespace import="*"> | |
| <%def name="foo()"> | |
| this is foo | |
| </%def> | |
| </%namespace> | |
| ${foo()} | |
| """ | |
| ) | |
| assert flatten_result(t.render()) == "this is foo" | |
| def test_ccall_import(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "functions.html", | |
| """ | |
| <%def name="foo()"> | |
| this is foo | |
| </%def> | |
| <%def name="bar()"> | |
| this is bar. | |
| ${caller.body()} | |
| ${caller.lala()} | |
| </%def> | |
| """, | |
| ) | |
| collection.put_string( | |
| "index.html", | |
| """ | |
| <%namespace name="func" file="functions.html" import="*"/> | |
| <%call expr="bar()"> | |
| this is index embedded | |
| foo is ${foo()} | |
| <%def name="lala()"> | |
| this is lala ${foo()} | |
| </%def> | |
| </%call> | |
| """, | |
| ) | |
| # print collection.get_template("index.html").code | |
| # print collection.get_template("functions.html").code | |
| assert result_lines( | |
| collection.get_template("index.html").render() | |
| ) == [ | |
| "this is bar.", | |
| "this is index embedded", | |
| "foo is", | |
| "this is foo", | |
| "this is lala", | |
| "this is foo", | |
| ] | |
| def test_nonexistent_namespace_uri(self): | |
| collection = lookup.TemplateLookup() | |
| collection.put_string( | |
| "main.html", | |
| """ | |
| <%namespace name="defs" file="eefs.html"/> | |
| this is main. ${defs.def1("hi")} | |
| ${defs.def2("there")} | |
| """, | |
| ) | |
| collection.put_string( | |
| "defs.html", | |
| """ | |
| <%def name="def1(s)"> | |
| def1: ${s} | |
| </%def> | |
| <%def name="def2(x)"> | |
| def2: ${x} | |
| </%def> | |
| """, | |
| ) | |
| assert_raises_message_with_given_cause( | |
| exceptions.TemplateLookupException, | |
| "Can't locate template for uri 'eefs.html", | |
| exceptions.TopLevelLookupException, | |
| collection.get_template("main.html").render, | |
| ) |