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

    21

class TemplateError (Exception) :

    22

    """

    23

        Raised by the template module functions

    24

    """

    25

    26

    pass

    27

    28

def fmt_mako_exception () :

    29

    """

    30

        Returns a string containing the Mako-ized error traceback (so that it includes the template data)

    31

    """

    32

    33

    return exceptions.text_error_template().render()

    34

    35

class TemplateLoader (mako.lookup.TemplateLookup) :

    36

    """

    37

        Our own specialization of mako's TemplateLookup

    38

    """

    39

    40

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

    41

        """

    42

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

    43

    44

            The given Helpers class is used to provide the helper methods

    45

    46

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

    47

        """

    48

    49

        # store

    50

        self.path = path

    51

        self.fileext = fileext

    52

        self.helper_class = _helper_class

    53

        self.env = env

    54

    55

        # build the TemplateLookup

    56

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

    57

    58

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

    59

        """

    60

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

    61

        """

    62

    63

        # build our Helpers class

    64

        helpers = self.helper_class()

    65

    66

        # build the context from our env, and params

    67

        ctx = dict(

    68

            h       = helpers,

    69

        )

    70

        ctx.update(env)

    71

        ctx.update(params)

    72

    73

        # the buffer to use for unicode output

    74

        buf = util.FastEncodingBuffer(unicode=True)

    75

    76

        # the context to use

    77

        context = Context(buf, **ctx)

    78

    79

        # bind our helper

    80

        helpers._bind_ctx(context)

    81

    82

        try :

    83

            # render template

    84

            tpl.render_context(context)

    85

    86

        # a template may render other templates

    87

        except TemplateError :

    88

            raise

    89

    90

        except :

    91

            # raise a TemplateError with the details

    92

            raise TemplateError("tpl=%r, params=%r: %s" % (tpl, params, fmt_mako_exception()))

    93

    94

        else :

    95

            # return the unicode data

    96

            return buf.getvalue()

    97

    98

    def lookup (self, name) :

    99

        """

   100

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

   101

        """

   102

   103

        try :

   104

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

   105

   106

        except :

   107

            raise TemplateError("name=%r: %s" % (name, fmt_mako_exception()))

   108

   109

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

   110

        """

   111

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

   112

        """

   113

   114

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

   115

   116

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

   117

        """

   118

            Render a template, returning a http.Response object

   119

        """

   120

   121

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

   122

   123

    def load (self, path) :

   124

        """

   125

            Loads a template from a specific file

   126

        """

   127

   128

        try :

   129

            return Template(filename=path, module_directory=CACHE_DIR)

   130

   131

        except :

   132

            raise TemplateError("path=%r: %s" % (path, fmt_mako_exception()))

   133

   134

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

   135

        """

   136

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

   137

        """

   138

   139

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

   140

   141

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

   142

        """

   143

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

   144

        """

   145

   146

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

   147