← Back to branch summary

~divmod-dev/divmod.org/trunk

« back to all changes in this revision

Viewing changes to Nevow/nevow/loaders.py

  • Committer: Jean-Paul Calderone
  • Date: 2014-06-29 20:33:04 UTC
  • mfrom: (2749.1.1 remove-epsilon-1325289)
  • Revision ID: exarkun@twistedmatrix.com-20140629203304-gdkmbwl1suei4m97
merge lp:~exarkun/divmod.org/remove-epsilon-1325289

Show diffs side-by-side

added added

removed removed

Lines of Context:
Nevow/nevow/loaders.py
1
 
# Copyright (c) 2004 Divmod.
2
 
# See LICENSE for details.
3
 
 
4
 
"""Builtin template loaders that supply a Page or renderer with a
5
 
document to render.
6
 
 
7
 
Nevow provides the following DocFactory loaders by default:
8
 
 
9
 
  - B{stan} - turn a stan tag tree into a DocFactory
10
 
  - B{xmlfile} - load a well formed XML document from file
11
 
  - B{htmlfile} - load a HTML file from disk
12
 
  - B{xmlstr} - load a well formed XML document from a string
13
 
  - B{htmlstr} - load a HTML document from a string
14
 
 
15
 
Unless absolutely necessary you should use either the stan loader or
16
 
one of the xml loaders. The html loaders should only be used for badly
17
 
formed HTML documents, i.e. if your HTML developer hasn't heard of
18
 
XHTML yet. Even then, you should probably try to educate the HTML
19
 
developer first ;-).
20
 
"""
21
 
 
22
 
import warnings
23
 
 
24
 
import os.path
25
 
from zope.interface import implements
26
 
 
27
 
from twisted.python.reflect import getClass
28
 
from twisted.web import microdom
29
 
 
30
 
from nevow import inevow
31
 
from nevow import flat
32
 
from nevow.flat import flatsax
33
 
from nevow.util import CachedFile
34
 
 
35
 
 
36
 
class stan(object):
37
 
    """A stan tags document factory"""
38
 
 
39
 
    implements(inevow.IDocFactory)
40
 
 
41
 
    stan = None
42
 
    pattern = None
43
 
    _cache = None
44
 
 
45
 
    def __init__(self, stan=None, pattern=None):
46
 
        if stan is not None:
47
 
            self.stan = stan
48
 
        if pattern is not None:
49
 
            self.pattern = pattern
50
 
 
51
 
 
52
 
    def load(self, ctx=None, preprocessors=()):
53
 
        if self._cache is None:
54
 
            stan = [self.stan]
55
 
            for proc in preprocessors:
56
 
                stan = proc(stan)
57
 
            stan = flat.precompile(stan, ctx)
58
 
            if self.pattern is not None:
59
 
                stan = inevow.IQ(stan).onePattern(self.pattern)
60
 
            self._cache = stan
61
 
        return self._cache
62
 
 
63
 
 
64
 
 
65
 
class htmlstr(object):
66
 
    """A document factory for HTML contained in a string"""
67
 
 
68
 
    implements(inevow.IDocFactory)
69
 
 
70
 
    template = None
71
 
    pattern = None
72
 
    beExtremelyLenient = True
73
 
    _cache = None
74
 
 
75
 
    def __init__(self, template=None, pattern=None, beExtremelyLenient=None):
76
 
        warnings.warn(
77
 
            "[v0.8] htmlstr is deprecated because it's buggy. Please start using xmlfile and/or xmlstr.",
78
 
            DeprecationWarning,
79
 
            stacklevel=2)
80
 
        if template is not None:
81
 
            self.template = template
82
 
        if pattern is not None:
83
 
            self.pattern = pattern
84
 
        if beExtremelyLenient is not None:
85
 
            self.beExtremelyLenient = beExtremelyLenient
86
 
 
87
 
    def load(self, ctx=None, preprocessors=()):
88
 
        assert not preprocessors, "preprocessors not supported by htmlstr"
89
 
        if self._cache is None:
90
 
            doc = microdom.parseString(self.template, beExtremelyLenient=self.beExtremelyLenient)
91
 
            doc = flat.precompile(doc, ctx)
92
 
            if self.pattern is not None:
93
 
                doc = inevow.IQ(doc).onePattern(self.pattern)
94
 
            self._cache = doc
95
 
        return self._cache
96
 
 
97
 
class htmlfile(object):
98
 
    """A document factory for an HTML disk template"""
99
 
 
100
 
    implements(inevow.IDocFactory)
101
 
 
102
 
    template = None
103
 
    pattern = None
104
 
    templateDir = ''
105
 
    beExtremelyLenient = True
106
 
 
107
 
    def __init__(self, template=None, pattern=None, templateDir=None, beExtremelyLenient=None):
108
 
        warnings.warn(
109
 
            "[v0.8] htmlfile is deprecated because it's buggy. Please start using xmlfile and/or xmlstr.",
110
 
            DeprecationWarning,
111
 
            stacklevel=2)
112
 
        if template is not None:
113
 
            self.template = template
114
 
        if pattern is not None:
115
 
            self.pattern = pattern
116
 
        if templateDir is not None:
117
 
            self.templateDir = templateDir
118
 
        if beExtremelyLenient is not None:
119
 
            self.beExtremelyLenient = beExtremelyLenient
120
 
        _filename = os.path.join(self.templateDir, self.template)
121
 
        self._cache = CachedFile(_filename, self._reallyLoad)
122
 
 
123
 
    def _reallyLoad(self, path, ctx):
124
 
        doc = microdom.parse(path, beExtremelyLenient=self.beExtremelyLenient)
125
 
        doc = flat.precompile(doc, ctx)
126
 
        if self.pattern is not None:
127
 
            doc = inevow.IQ(doc).onePattern(self.pattern)
128
 
        return doc
129
 
 
130
 
    def load(self, ctx=None, preprocessors=()):
131
 
        assert not preprocessors, "preprocessors not supported by htmlfile"
132
 
        return self._cache.load(ctx)
133
 
 
134
 
class xmlstr(object):
135
 
 
136
 
    implements(inevow.IDocFactory)
137
 
 
138
 
    template = None
139
 
    pattern = None
140
 
    ignoreDocType = None
141
 
    ignoreComment = None
142
 
    _cache = None
143
 
 
144
 
    def __init__(self, template=None, pattern=None, ignoreDocType=False, ignoreComment=False):
145
 
        if template is not None:
146
 
            self.template = template
147
 
        if pattern is not None:
148
 
            self.pattern = pattern
149
 
        if ignoreDocType is not None:
150
 
            self.ignoreDocType = ignoreDocType
151
 
        if ignoreComment is not None:
152
 
            self.ignoreComment = ignoreComment
153
 
 
154
 
    def load(self, ctx=None, preprocessors=()):
155
 
        """
156
 
        Get an instance, possibly cached from a previous call, of this document
157
 
        """
158
 
        if self._cache is None:
159
 
            doc = flatsax.parseString(self.template, self.ignoreDocType, self.ignoreComment)
160
 
            for proc in preprocessors:
161
 
                doc = proc(doc)
162
 
            doc = flat.precompile(doc, ctx)
163
 
            if self.pattern is not None:
164
 
                doc = inevow.IQ(doc).onePattern(self.pattern)
165
 
            self._cache = doc
166
 
        return self._cache
167
 
 
168
 
 
169
 
class xmlfile(object):
170
 
 
171
 
    implements(inevow.IDocFactory)
172
 
 
173
 
    template = None
174
 
    templateDir = None
175
 
    pattern = None
176
 
    ignoreDocType = False
177
 
    ignoreComment = False
178
 
 
179
 
    def __init__(self, template=None, pattern=None, templateDir=None, ignoreDocType=None, ignoreComment=None):
180
 
        self._cache = {}
181
 
        if template is not None:
182
 
            self.template = template
183
 
        if pattern is not None:
184
 
            self.pattern = pattern
185
 
        if templateDir is not None:
186
 
            self.templateDir = templateDir
187
 
        if ignoreDocType is not None:
188
 
            self.ignoreDocType = ignoreDocType
189
 
        if ignoreComment is not None:
190
 
            self.ignoreComment = ignoreComment
191
 
        if self.templateDir is not None:
192
 
            self._filename = os.path.join(self.templateDir, self.template)
193
 
        else:
194
 
            self._filename = self.template
195
 
 
196
 
        self._cache = {}
197
 
 
198
 
    def load(self, ctx=None, preprocessors=()):
199
 
        rendererFactoryClass = None
200
 
        if ctx is not None:
201
 
            r = inevow.IRendererFactory(ctx, None)
202
 
            if r is not None:
203
 
                rendererFactoryClass = getClass(r)
204
 
 
205
 
        cacheKey = (self._filename, self.pattern, rendererFactoryClass)
206
 
        cachedFile = self._cache.get(cacheKey)
207
 
        if cachedFile is None:
208
 
            cachedFile = self._cache[cacheKey] = CachedFile(self._filename, self._reallyLoad)
209
 
 
210
 
        return cachedFile.load(ctx, preprocessors)
211
 
 
212
 
    def _reallyLoad(self, path, ctx, preprocessors):
213
 
        doc = flatsax.parse(open(self._filename), self.ignoreDocType, self.ignoreComment)
214
 
        for proc in preprocessors:
215
 
            doc = proc(doc)
216
 
        doc = flat.precompile(doc, ctx)
217
 
 
218
 
        if self.pattern is not None:
219
 
            doc = inevow.IQ(doc).onePattern(self.pattern)
220
 
 
221
 
        return doc