from mako import compat
from mako import lookup
from mako.template import Template
from test import assert_raises
from test import eq_
from test import requires_python_3
from test import TemplateTest
from test.util import flatten_result
from test.util import result_lines


class DefTest(TemplateTest):
    def test_def_noargs(self):
        template = Template(
            """

        ${mycomp()}

        <%def name="mycomp()">
            hello mycomp ${variable}
        </%def>

        """
        )
        eq_(template.render(variable="hi").strip(), """hello mycomp hi""")

    def test_def_blankargs(self):
        template = Template(
            """
        <%def name="mycomp()">
            hello mycomp ${variable}
        </%def>

        ${mycomp()}"""
        )
        eq_(template.render(variable="hi").strip(), "hello mycomp hi")

    def test_def_args(self):
        template = Template(
            """
        <%def name="mycomp(a, b)">
            hello mycomp ${variable}, ${a}, ${b}
        </%def>

        ${mycomp(5, 6)}"""
        )
        eq_(
            template.render(variable="hi", a=5, b=6).strip(),
            """hello mycomp hi, 5, 6""",
        )

    @requires_python_3
    def test_def_py3k_args(self):
        template = Template(
            """
        <%def name="kwonly(one, two, *three, four, five=5, **six)">
            look at all these args: ${one} ${two} ${three[0]} """
            """${four} ${five} ${six['seven']}
        </%def>

        ${kwonly('one', 'two', 'three', four='four', seven='seven')}"""
        )
        eq_(
            template.render(one=1, two=2, three=(3,), six=6).strip(),
            """look at all these args: one two three four 5 seven""",
        )

    def test_inter_def(self):
        """test defs calling each other"""
        template = Template(
            """
        ${b()}

        <%def name="a()">\
        im a
        </%def>

        <%def name="b()">
        im b
        and heres a:  ${a()}
        </%def>

        <%def name="c()">
        im c
        </%def>
"""
        )
        # check that "a" is declared in "b", but not in "c"
        if compat.py3k:
            assert "a" not in template.module.render_c.__code__.co_varnames
            assert "a" in template.module.render_b.__code__.co_varnames
        else:
            assert "a" not in template.module.render_c.func_code.co_varnames
            assert "a" in template.module.render_b.func_code.co_varnames

        # then test output
        eq_(flatten_result(template.render()), "im b and heres a: im a")

    def test_toplevel(self):
        """test calling a def from the top level"""

        template = Template(
            """

            this is the body

            <%def name="a()">
                this is a
            </%def>

            <%def name="b(x, y)">
                this is b, ${x} ${y}
            </%def>

        """
        )

        self._do_test(
            template.get_def("a"), "this is a", filters=flatten_result
        )
        self._do_test(
            template.get_def("b"),
            "this is b, 10 15",
            template_args={"x": 10, "y": 15},
            filters=flatten_result,
        )
        self._do_test(
            template.get_def("body"),
            "this is the body",
            filters=flatten_result,
        )

        # test that args outside of the dict can be used
        self._do_test(
            template.get_def("a"),
            "this is a",
            filters=flatten_result,
            template_args={"q": 5, "zq": "test"},
        )

    def test_def_operations(self):
        """test get/list/has def"""

        template = Template(
            """

            this is the body

            <%def name="a()">
                this is a
            </%def>

            <%def name="b(x, y)">
                this is b, ${x} ${y}
            </%def>

        """
        )

        assert template.get_def("a")
        assert template.get_def("b")
        assert_raises(AttributeError, template.get_def, ("c"))

        assert template.has_def("a")
        assert template.has_def("b")
        assert not template.has_def("c")

        defs = template.list_defs()
        assert "a" in defs
        assert "b" in defs
        assert "body" in defs
        assert "c" not in defs


class ScopeTest(TemplateTest):
    """test scoping rules.  The key is, enclosing
    scope always takes precedence over contextual scope."""

    def test_scope_one(self):
        self._do_memory_test(
            """
        <%def name="a()">
            this is a, and y is ${y}
        </%def>

        ${a()}

        <%
            y = 7
        %>

        ${a()}

""",
            "this is a, and y is None this is a, and y is 7",
            filters=flatten_result,
            template_args={"y": None},
        )

    def test_scope_two(self):
        t = Template(
            """
        y is ${y}

        <%
            y = 7
        %>

        y is ${y}
"""
        )
        try:
            t.render(y=None)
            assert False
        except UnboundLocalError:
            assert True

    def test_scope_four(self):
        """test that variables are pulled
        from 'enclosing' scope before context."""
        t = Template(
            """
            <%
                x = 5
            %>
            <%def name="a()">
                this is a. x is ${x}.
            </%def>

            <%def name="b()">
                <%
                    x = 9
                %>
                this is b. x is ${x}.
                calling a. ${a()}
            </%def>

            ${b()}
"""
        )
        eq_(
            flatten_result(t.render()),
            "this is b. x is 9. calling a. this is a. x is 5.",
        )

    def test_scope_five(self):
        """test that variables are pulled from
        'enclosing' scope before context."""
        # same as test four, but adds a scope around it.
        t = Template(
            """
            <%def name="enclosing()">
            <%
                x = 5
            %>
            <%def name="a()">
                this is a. x is ${x}.
            </%def>

            <%def name="b()">
                <%
                    x = 9
                %>
                this is b. x is ${x}.
                calling a. ${a()}
            </%def>

            ${b()}
            </%def>
            ${enclosing()}
"""
        )
        eq_(
            flatten_result(t.render()),
            "this is b. x is 9. calling a. this is a. x is 5.",
        )

    def test_scope_six(self):
        """test that the initial context counts
        as 'enclosing' scope, for plain defs"""
        t = Template(
            """

        <%def name="a()">
            a: x is ${x}
        </%def>

        <%def name="b()">
            <%
                x = 10
            %>
            b. x is ${x}.  ${a()}
        </%def>

        ${b()}
    """
        )
        eq_(flatten_result(t.render(x=5)), "b. x is 10. a: x is 5")

    def test_scope_seven(self):
        """test that the initial context counts
        as 'enclosing' scope, for nested defs"""
        t = Template(
            """
        <%def name="enclosing()">
            <%def name="a()">
                a: x is ${x}
            </%def>

            <%def name="b()">
                <%
                    x = 10
                %>
                b. x is ${x}.  ${a()}
            </%def>

            ${b()}
        </%def>
        ${enclosing()}
    """
        )
        eq_(flatten_result(t.render(x=5)), "b. x is 10. a: x is 5")

    def test_scope_eight(self):
        """test that the initial context counts
        as 'enclosing' scope, for nested defs"""
        t = Template(
            """
        <%def name="enclosing()">
            <%def name="a()">
                a: x is ${x}
            </%def>

            <%def name="b()">
                <%
                    x = 10
                %>

                b. x is ${x}.  ${a()}
            </%def>

            ${b()}
        </%def>
        ${enclosing()}
    """
        )
        eq_(flatten_result(t.render(x=5)), "b. x is 10. a: x is 5")

    def test_scope_nine(self):
        """test that 'enclosing scope' doesnt
        get exported to other templates"""

        l = lookup.TemplateLookup()
        l.put_string(
            "main",
            """
        <%
            x = 5
        %>
        this is main.  <%include file="secondary"/>
""",
        )

        l.put_string(
            "secondary",
            """
        this is secondary.  x is ${x}
""",
        )

        eq_(
            flatten_result(l.get_template("main").render(x=2)),
            "this is main. this is secondary. x is 2",
        )

    def test_scope_ten(self):
        t = Template(
            """
            <%def name="a()">
                <%def name="b()">
                    <%
                        y = 19
                    %>
                    b/c: ${c()}
                    b/y: ${y}
                </%def>
                <%def name="c()">
                    c/y: ${y}
                </%def>

                <%
                    # we assign to "y".  but the 'enclosing
                    # scope' of "b" and "c" is from
                    # the "y" on the outside
                    y = 10
                %>
                a/y: ${y}
                a/b: ${b()}
            </%def>

            <%
                y = 7
            %>
            main/a: ${a()}
            main/y: ${y}
    """
        )
        eq_(
            flatten_result(t.render()),
            "main/a: a/y: 10 a/b: b/c: c/y: 10 b/y: 19 main/y: 7",
        )

    def test_scope_eleven(self):
        t = Template(
            """
            x is ${x}
            <%def name="a(x)">
                this is a, ${b()}
                <%def name="b()">
                    this is b, x is ${x}
                </%def>
            </%def>

            ${a(x=5)}
"""
        )
        eq_(
            result_lines(t.render(x=10)),
            ["x is 10", "this is a,", "this is b, x is 5"],
        )

    def test_unbound_scope(self):
        t = Template(
            """
            <%
                y = 10
            %>
            <%def name="a()">
                y is: ${y}
                <%
                    # should raise error ?
                    y = 15
                %>
                y is ${y}
            </%def>
            ${a()}
"""
        )
        assert_raises(UnboundLocalError, t.render)

    def test_unbound_scope_two(self):
        t = Template(
            """
            <%def name="enclosing()">
            <%
                y = 10
            %>
            <%def name="a()">
                y is: ${y}
                <%
                    # should raise error ?
                    y = 15
                %>
                y is ${y}
            </%def>
            ${a()}
            </%def>
            ${enclosing()}
"""
        )
        try:
            print(t.render())
            assert False
        except UnboundLocalError:
            assert True

    def test_canget_kwargs(self):
        """test that arguments passed to the body()
        function are accessible by top-level defs"""
        l = lookup.TemplateLookup()
        l.put_string(
            "base",
            """

        ${next.body(x=12)}

        """,
        )

        l.put_string(
            "main",
            """
            <%inherit file="base"/>
            <%page args="x"/>
            this is main.  x is ${x}

            ${a()}

            <%def name="a(**args)">
                this is a, x is ${x}
            </%def>
        """,
        )

        # test via inheritance
        eq_(
            result_lines(l.get_template("main").render()),
            ["this is main. x is 12", "this is a, x is 12"],
        )

        l.put_string(
            "another",
            """
            <%namespace name="ns" file="main"/>

            ${ns.body(x=15)}
        """,
        )
        # test via namespace
        eq_(
            result_lines(l.get_template("another").render()),
            ["this is main. x is 15", "this is a, x is 15"],
        )

    def test_inline_expression_from_arg_one(self):
        """test that cache_key=${foo} gets its value from
        the 'foo' argument in the <%def> tag,
        and strict_undefined doesn't complain.

        this is #191.

        """
        t = Template(
            """
        <%def name="layout(foo)" cached="True" cache_key="${foo}">
        foo: ${foo}
        </%def>

        ${layout(3)}
        """,
            strict_undefined=True,
            cache_impl="plain",
        )

        eq_(result_lines(t.render()), ["foo: 3"])

    def test_interpret_expression_from_arg_two(self):
        """test that cache_key=${foo} gets its value from
        the 'foo' argument regardless of it being passed
        from the context.

        This is here testing that there's no change
        to existing behavior before and after #191.

        """
        t = Template(
            """
        <%def name="layout(foo)" cached="True" cache_key="${foo}">
        foo: ${value}
        </%def>

        ${layout(3)}
        """,
            cache_impl="plain",
        )

        eq_(result_lines(t.render(foo="foo", value=1)), ["foo: 1"])
        eq_(result_lines(t.render(foo="bar", value=2)), ["foo: 1"])


class NestedDefTest(TemplateTest):
    def test_nested_def(self):
        t = Template(
            """

        ${hi()}

        <%def name="hi()">
            hey, im hi.
            and heres ${foo()}, ${bar()}

            <%def name="foo()">
                this is foo
            </%def>

            <%def name="bar()">
                this is bar
            </%def>
        </%def>
"""
        )
        eq_(
            flatten_result(t.render()),
            "hey, im hi. and heres this is foo , this is bar",
        )

    def test_nested_2(self):
        t = Template(
            """
            x is ${x}
            <%def name="a()">
                this is a, x is ${x}
                ${b()}
                <%def name="b()">
                    this is b: ${x}
                </%def>
            </%def>
            ${a()}
"""
        )

        eq_(
            flatten_result(t.render(x=10)),
            "x is 10 this is a, x is 10 this is b: 10",
        )

    def test_nested_with_args(self):
        t = Template(
            """
        ${a()}
        <%def name="a()">
            <%def name="b(x, y=2)">
                b x is ${x} y is ${y}
            </%def>
            a ${b(5)}
        </%def>
"""
        )
        eq_(flatten_result(t.render()), "a b x is 5 y is 2")

    def test_nested_def_2(self):
        template = Template(
            """
        ${a()}
        <%def name="a()">
            <%def name="b()">
                <%def name="c()">
                    comp c
                </%def>
                ${c()}
            </%def>
            ${b()}
        </%def>
"""
        )
        eq_(flatten_result(template.render()), "comp c")

    def test_nested_nested_def(self):
        t = Template(
            """

        ${a()}
        <%def name="a()">
            a
            <%def name="b1()">
                a_b1
            </%def>
            <%def name="b2()">
                a_b2 ${c1()}
                <%def name="c1()">
                    a_b2_c1
                </%def>
            </%def>
            <%def name="b3()">
                a_b3 ${c1()}
                <%def name="c1()">
                    a_b3_c1 heres x: ${x}
                    <%
                        y = 7
                    %>
                    y is ${y}
                </%def>
                <%def name="c2()">
                    a_b3_c2
                    y is ${y}
                    c1 is ${c1()}
                </%def>
                ${c2()}
            </%def>

            ${b1()} ${b2()}  ${b3()}
        </%def>
"""
        )
        eq_(
            flatten_result(t.render(x=5, y=None)),
            "a a_b1 a_b2 a_b2_c1 a_b3 a_b3_c1 "
            "heres x: 5 y is 7 a_b3_c2 y is "
            "None c1 is a_b3_c1 heres x: 5 y is 7",
        )

    def test_nested_nested_def_2(self):
        t = Template(
            """
        <%def name="a()">
            this is a ${b()}
            <%def name="b()">
                this is b
                ${c()}
            </%def>

            <%def name="c()">
                this is c
            </%def>
        </%def>
        ${a()}
"""
        )
        eq_(flatten_result(t.render()), "this is a this is b this is c")

    def test_outer_scope(self):
        t = Template(
            """
        <%def name="a()">
            a: x is ${x}
        </%def>

        <%def name="b()">
            <%def name="c()">
            <%
                x = 10
            %>
            c. x is ${x}.  ${a()}
            </%def>

            b. ${c()}
        </%def>

        ${b()}

        x is ${x}
"""
        )
        eq_(flatten_result(t.render(x=5)), "b. c. x is 10. a: x is 5 x is 5")


class ExceptionTest(TemplateTest):
    def test_raise(self):
        template = Template(
            """
            <%
                raise Exception("this is a test")
            %>
    """,
            format_exceptions=False,
        )
        assert_raises(Exception, template.render)

    def test_handler(self):
        def handle(context, error):
            context.write("error message is " + str(error))
            return True

        template = Template(
            """
            <%
                raise Exception("this is a test")
            %>
    """,
            error_handler=handle,
        )
        eq_(template.render().strip(), "error message is this is a test")