1

"""

     2

    Template handler

     3

"""

     4

     5

# use Mako

     6

from mako import exceptions

     7

from mako.template import Template

     8

import mako.lookup

     9

    10

# for http.ResponseError

    11

import http

    12

    13

import helpers

    14

    15

# path to template files

    16

TEMPLATE_DIR = "templates"

    17

    18

# path to cached templates

    19

CACHE_DIR = "cache/templates"

    20

    21

# template file extension

    22

TEMPLATE_EXT = "tmpl"

    23

    24

class TemplateError (http.ResponseError) :

    25

    """

    26

        Raised by the template module functions

    27

    """

    28

    29

    pass

    30

    31

def render (tpl, **params) :

    32

    """

    33

        Render the given template, returning the output as a unicode string, or raising a TemplateError

    34

    """

    35

    36

    try :

    37

        return tpl.render_unicode(

    38

            # global helper stuff

    39

            h           = helpers,

    40

    41

            # render-specific params

    42

            **params

    43

        )

    44

    45

    # a template may render other templates

    46

    except TemplateError :

    47

        raise

    48

    49

    except :

    50

        details = exceptions.text_error_template().render()

    51

    52

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

    53

    54

class TemplateLoader (mako.lookup.TemplateLookup) :

    55

    """

    56

        Our own specialization of mako's TemplateLookup

    57

    """

    58

    59

    def __init__ (self, path, fileext=TEMPLATE_EXT) :

    60

        """

    61

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

    62

        """

    63

    64

        # store

    65

        self.path = path

    66

        self.fileext = fileext

    67

    68

        # XXX: separate cache?

    69

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

    70

    71

    def lookup (self, name) :

    72

        """

    73

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

    74

        """

    75

    76

        try :

    77

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

    78

    79

        except :

    80

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

    81

    83

        """

    84

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

    85

        """

    86

    87

        return render(self.lookup(name), **params)

    88

    96

    @classmethod

    97

    def load (cls, path) :

    98

        """

    99

            Loads a template from a specific file

   100

        """

   101

   102

        try :

   103

            return Template(filename=path, module_directory=CACHE_DIR)

   104

   105

        except :

   106

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

   107

   108

    @classmethod

   109

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

   110

        """

   111

            Render a template, using load() on the given path

   112

        """

   113

   114

        return render(cls.load(path), **params)

   115

   116