~loggerhead-team/loggerhead/trunk-rich

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
"TurboGears support for Zope Page Templates"

import StringIO
import logging
import pkg_resources

#from zope.pagetemplate.pagetemplatefile import PageTemplateFile
from simpletal import simpleTAL, simpleTALES

log = logging.getLogger("turbogears.zptsupport")

_zpt_cache = {}

def zpt(tfile):
    tinstance = _zpt_cache.get(tfile)
    if tinstance is None:
        tinstance = _zpt_cache[tfile] = TemplateWrapper(
            simpleTAL.compileXMLTemplate(open(tfile)), tfile)
    return tinstance

class TemplateWrapper(object):

    def __init__(self, template, filename):
        self.template = template
        self.filename = filename

    def expand(self, **info):
        context = simpleTALES.Context(allowPythonPath=1)
        for k, v in info.iteritems():
            context.addGlobal(k, v)
        s = StringIO.StringIO()
        self.template.expandInline(context, s)
        return s.getvalue()

    @property
    def macros(self):
        return self.template.macros

## class TGPageTemplateFile(PageTemplateFile):

##     def pt_getContext(self, args=(), options={}, **ignored):
##         namespace = super(TGPageTemplateFile, self).pt_getContext(
##             args, options, **ignored)
##         namespace.update(options)
##         return namespace

class TurboZpt(object):
    extension = "pt"

    def __init__(self, extra_vars_func=None):
        self.get_extra_vars = extra_vars_func

    def load_template(self, classname, loadingSite=False):
        """Searches for a template along the Python path.

        Template files must end in ".pt" and be in legitimate packages.
        Templates are automatically checked for changes and reloaded as
        neccessary.
        """
        divider = classname.rfind(".")
        if divider > -1:
            package = classname[0:divider]
            basename = classname[divider+1:]
        else:
            raise ValueError, "All templates must be in a package"

        tfile = pkg_resources.resource_filename(
            package, "%s.%s" % (basename, self.extension))
        return zpt(tfile)

    def render(self, info, format="html", fragment=False, template=None):
        """Renders data in the desired format.

        @param info: the data / context itself
        @type info: dict
        @para format: "html"
        @type format: "string"
        @para template: name of the template to use
        @type template: string
        """
        tinstance = self.load_template(template)
        log.debug("Applying template %s" % (tinstance.filename))
        data = dict()
        if self.get_extra_vars:
            data.update(self.get_extra_vars())
        data.update(info)
        return tinstance.expand(**data).encode('utf-8')