1

"""

     2

    Template handler

     3

"""

     4

     5

from mako import exceptions, util

     6

from mako.runtime import Context

     7

from mako.template import Template

     8

import mako.lookup

     9

    10

from qmsk.web import http, helpers

    11

    12

# path to template files

    13

TEMPLATE_DIR = "templates"

    14

    15

# path to cached templates

    16

CACHE_DIR = "cache/templates"

    17

    18

# template file extension

    19

TEMPLATE_EXT = "tmpl"

    20

    22

    """

    23

        Raised by the template module functions

    24

    """

    25

    26

    pass

    27

    28

class TemplateLoader (mako.lookup.TemplateLookup) :

    29

    """

    30

        Our own specialization of mako's TemplateLookup

    31

    """

    32

    33

    def __init__ (self, path, fileext=TEMPLATE_EXT, _helper_class=helpers.Helpers, **env) :

    34

        """

    35

            Initialize to load templates located at path, with the given file extension.

    36

    37

            The given Helpers class is used to provide the helper methods

    38

    39

            The given **env list is supplied to every template render

    40

        """

    41

    42

        # store

    43

        self.path = path

    44

        self.fileext = fileext

    45

        self.helper_class = _helper_class

    46

        self.env = env

    47

    48

        # build the TemplateLookup

    49

        super(TemplateLoader, self).__init__(directories=[path], module_directory=CACHE_DIR)

    50

    51

    def _render (self, tpl, env, params) :

    52

        """

    53

            Render the given template with given env/params, returning the output as a unicode string, or raising a TemplateError

    54

        """

    55

    56

        # build our Helpers class

    57

        helpers = self.helper_class()

    58

    59

        # build the context from our env, and params

    60

        ctx = dict(

    61

            h       = helpers,

    62

        )

    63

        ctx.update(env)

    64

        ctx.update(params)

    65

    66

        # the buffer to use for unicode output

    67

        buf = util.FastEncodingBuffer(unicode=True)

    68

    69

        # the context to use

    70

        context = Context(buf, **ctx)

    71

    72

        # bind our helper

    73

        helpers._bind_ctx(context)

    74

    75

        try :

    76

            # render template

    77

            tpl.render_context(context)

    78

    79

        # a template may render other templates

    80

        except TemplateError :

    81

            raise

    82

    83

        except :

    84

            # raise a TemplateError with the details

    85

            details = exceptions.text_error_template().render()

    86

    87

            raise TemplateError("Template render failed", status='500 Internal Server Error', details=details)

    88

    89

        else :

    90

            # return the unicode data

    91

            return buf.getvalue()

    92

    93

    def lookup (self, name) :

    94

        """

    95

            Looks up a template based on the bare "name", which does not include the path or file extension

    96

        """

    97

    98

        try :

    99

            return self.get_template("%s.%s" % (name, self.fileext))

   100

   101

        except :

   102

            raise TemplateError("Template broken: %r" % (name, ), status='500 Internal Server Error', details=exceptions.text_error_template().render())

   103

   104

    def render (self, name, **params) :

   105

        """

   106

            Render a template, using lookup() on the given name

   107

        """

   108

   109

        return self._render(self.lookup(name), self.env, params)

   110

   111

    def render_to_response (self, name, **params) :

   112

        """

   113

            Render a template, returning a http.Response object

   114

        """

   115

   116

        return http.Response(self.render(name, **params))

   117

   118

    def load (self, path) :

   119

        """

   120

            Loads a template from a specific file

   121

        """

   122

   123

        try :

   124

            return Template(filename=path, module_directory=CACHE_DIR)

   125

   126

        except :

   127

            raise TemplateError("Template broken: %r" % (path, ), status='500 Internal Server Error', details=exceptions.text_error_template().render())

   128

   129

    def render_file (self, path, **params) :

   130

        """

   131

            Render a template, using load() on the given path. No global environment vars are defined for the render.

   132

        """

   133

   134

        return self._render(self.load(path), dict(), params)

   135

   136

    def render_template (self, template, **params) :

   137

        """

   138

            Render the given template object. No global environment vars are defined for the render.

   139

        """

   140

   141

        return self._render(template, dict(), params)

   142