from mako import lookup
from mako.template import Template
from test import eq_
from test import TemplateTest
from test.util import flatten_result
from test.util 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()}
        """,
        )

        self.assertRaises(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",
        ]