← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to turbozpt/zptsupport.py

add a lightly hacked copy of turbozpt (it's not much code)

Show diffs side-by-side

added added

removed removed

Lines of Context:
turbozpt/zptsupport.py
 
1
"TurboGears support for Zope Page Templates"
 
2
 
 
3
import sys, os
 
4
 
 
5
from template import PageTemplate
 
6
import pkg_resources
 
7
 
 
8
import logging
 
9
log = logging.getLogger("turbogears.zptsupport")
 
10
 
 
11
def _recompile_template(package, basename, tfile, classname):
 
12
    log.debug("Recompiling template for %s" % classname)
 
13
    mod = PageTemplate(tfile)
 
14
    mtime = os.stat(tfile).st_mtime
 
15
    mod.__mtime__ = mtime
 
16
    return mod
 
17
 
 
18
class TurboZpt:
 
19
    extension = "pt"
 
20
    
 
21
    def __init__(self, extra_vars_func=None, options={}):
 
22
        self.options = options
 
23
        self.get_extra_vars = extra_vars_func
 
24
        self.compiledTemplates = {}
 
25
    
 
26
    def load_template(self, classname, loadingSite=False):
 
27
        """Searches for a template along the Python path.
 
28
 
 
29
        Template files must end in ".pt" and be in legitimate packages.
 
30
        U can set "zpt.cache_templates" option to cache a loaded template
 
31
        class and only check for updates. Templates are automatically
 
32
        checked for changes and reloaded as neccessary.
 
33
        """
 
34
        ct = self.compiledTemplates
 
35
 
 
36
        divider = classname.rfind(".")
 
37
        if divider > -1:
 
38
            package = classname[0:divider]
 
39
            basename = classname[divider+1:]
 
40
        else:
 
41
            raise ValueError, "All templates must be in a package"
 
42
 
 
43
        cache_templates = self.options.get("zpt.cache_templates", True)
 
44
        tfile = pkg_resources.resource_filename(package, 
 
45
                                                "%s.%s" % 
 
46
                                                (basename,
 
47
                                                self.extension))
 
48
                                                
 
49
        if cache_templates:
 
50
            if ct.has_key(classname):
 
51
                mtime = os.stat(tfile).st_mtime
 
52
                mod = ct[classname]
 
53
                if mod.__mtime__ != mtime:
 
54
                    # Recompile template
 
55
                    mod = _recompile_template(package, basename, tfile, classname)
 
56
                    ct[classname] = mod
 
57
                #else:
 
58
                    # use template from cache    
 
59
                    # pass 
 
60
            else:
 
61
                # First time compile template
 
62
                mod = PageTemplate(tfile)
 
63
                mod.__mtime__ = os.stat(tfile).st_mtime
 
64
                ct[classname] = mod
 
65
        else:
 
66
            mod = PageTemplate(tfile)
 
67
 
 
68
        return mod
 
69
 
 
70
    def render(self, info, format="html", fragment=False, template=None):
 
71
        """Renders data in the desired format.
 
72
        
 
73
        @param info: the data / context itself
 
74
        @type info: dict
 
75
        @para format: "html"
 
76
        @type format: "string"
 
77
        @para template: name of the template to use
 
78
        @type template: string
 
79
        """
 
80
        #if isinstance(template, type):
 
81
        #    tclass = template
 
82
        #else:
 
83
        
 
84
        tinstance = self.load_template(template)
 
85
        log.debug("Applying template %s" % (tinstance.filename))
 
86
        data = dict()
 
87
        if self.get_extra_vars:
 
88
            data.update(self.get_extra_vars())
 
89
        data.update(info)
 
90
        
 
91
        return str(tinstance(**data))
 
92
 
 
93
    def transform(self, info, template):
 
94
        "Render the output to Elements"
 
95
        pass