← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to turbosimpletal/zptsupport.py

  • Committer: Michael Hudson
  • Date: 2008-06-16 09:28:18 UTC
  • mto: This revision was merged to the branch mainline in revision 160.
  • Revision ID: michael.hudson@canonical.com-20080616092818-bqc51ar65hfco4d7
remove some slightly unrelated stuff

Show diffs side-by-side

added added

removed removed

Lines of Context:
turbosimpletal/zptsupport.py
1
1
"TurboGears support for Zope Page Templates"
2
2
 
3
 
import sys, os
4
 
 
5
 
from template import PageTemplate
 
3
import StringIO
 
4
import logging
 
5
import os
6
6
import pkg_resources
7
7
 
8
 
import logging
 
8
from simpletal import simpleTAL, simpleTALES
 
9
 
9
10
log = logging.getLogger("turbogears.zptsupport")
10
11
 
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:
 
12
 
 
13
_zpt_cache = {}
 
14
def zpt(tfile):
 
15
    tinstance = _zpt_cache.get(tfile)
 
16
    stat = os.stat(tfile)
 
17
    if tinstance is None or tinstance.stat != stat:
 
18
        tinstance = _zpt_cache[tfile] = TemplateWrapper(
 
19
            simpleTAL.compileXMLTemplate(open(tfile)), tfile, stat)
 
20
    return tinstance
 
21
 
 
22
 
 
23
class TemplateWrapper(object):
 
24
 
 
25
    def __init__(self, template, filename, stat):
 
26
        self.template = template
 
27
        self.filename = filename
 
28
        self.stat = stat
 
29
 
 
30
    def expand(self, **info):
 
31
        context = simpleTALES.Context(allowPythonPath=1)
 
32
        for k, v in info.iteritems():
 
33
            context.addGlobal(k, v)
 
34
        s = StringIO.StringIO()
 
35
        self.template.expandInline(context, s)
 
36
        return s.getvalue()
 
37
 
 
38
    @property
 
39
    def macros(self):
 
40
        return self.template.macros
 
41
 
 
42
 
 
43
class TurboZpt(object):
19
44
    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
 
    
 
45
 
 
46
    def __init__(self, extra_vars_func=None):
 
47
        self.get_extra_vars = extra_vars_func
 
48
 
26
49
    def load_template(self, classname, loadingSite=False):
27
50
        """Searches for a template along the Python path.
28
51
 
29
52
        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.
 
53
        Templates are automatically checked for changes and reloaded as
 
54
        neccessary.
33
55
        """
34
 
        ct = self.compiledTemplates
35
 
 
36
56
        divider = classname.rfind(".")
37
57
        if divider > -1:
38
58
            package = classname[0:divider]
40
60
        else:
41
61
            raise ValueError, "All templates must be in a package"
42
62
 
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
 
63
        tfile = pkg_resources.resource_filename(
 
64
            package, "%s.%s" % (basename, self.extension))
 
65
        return zpt(tfile)
69
66
 
70
67
    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
 
        print '!!!!', data.keys()
91
 
        return tinstance(**data)
 
68
        """Renders data in the desired format.
92
69
 
93
 
    def transform(self, info, template):
94
 
        "Render the output to Elements"
95
 
        pass
 
70
        @param info: the data / context itself
 
71
        @type info: dict
 
72
        @para format: "html"
 
73
        @type format: "string"
 
74
        @para template: name of the template to use
 
75
        @type template: string
 
76
        """
 
77
        tinstance = self.load_template(template)
 
78
        log.debug("Applying template %s" % (tinstance.filename))
 
79
        data = dict()
 
80
        if self.get_extra_vars:
 
81
            data.update(self.get_extra_vars())
 
82
        data.update(info)
 
83
        return tinstance.expand(**data).encode('utf-8')