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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
#!/usr/bin/env python
# $Id: Filters.py,v 1.33 2007/12/29 23:08:18 tavis_rudd Exp $
"""Filters for the #filter directive; output filters Cheetah's $placeholders .
Meta-Data
================================================================================
Author: Tavis Rudd <tavis@damnsimple.com>
Version: $Revision: 1.33 $
Start Date: 2001/08/01
Last Revision Date: $Date: 2007/12/29 23:08:18 $
"""
__author__ = "Tavis Rudd <tavis@damnsimple.com>"
__revision__ = "$Revision: 1.33 $"[11:-2]
# Additional entities WebSafe knows how to transform. No need to include
# '<', '>' or '&' since those will have been done already.
webSafeEntities = {' ': ' ', '"': '"'}
class Error(Exception):
pass
##################################################
## BASE CLASS
class Filter(object):
"""A baseclass for the Cheetah Filters."""
def __init__(self, template=None):
"""Setup a reference to the template that is using the filter instance.
This reference isn't used by any of the standard filters, but is
available to Filter subclasses, should they need it.
Subclasses should call this method.
"""
self.template = template
def filter(self, val,
#encoding='utf8',
encoding=None,
str=str,
**kw):
"""Pass Unicode strings through unmolested, unless an encoding is specified.
"""
if isinstance(val, unicode):
if encoding:
filtered = val.encode(encoding)
else:
filtered = val
elif val is None:
filtered = ''
else:
filtered = str(val)
return filtered
RawOrEncodedUnicode = Filter
##################################################
## ENHANCED FILTERS
class EncodeUnicode(Filter):
def filter(self, val,
encoding='utf8',
str=str,
**kw):
"""Encode Unicode strings, by default in UTF-8.
>>> import Cheetah.Template
>>> t = Cheetah.Template.Template('''
... $myvar
... ${myvar, encoding='utf16'}
... ''', searchList=[{'myvar': u'Asni\xe8res'}],
... filter='EncodeUnicode')
>>> print t
"""
if isinstance(val, unicode):
filtered = val.encode(encoding)
elif val is None:
filtered = ''
else:
filtered = str(val)
return filtered
class MaxLen(Filter):
def filter(self, val, **kw):
"""Replace None with '' and cut off at maxlen."""
output = super(MaxLen, self).filter(val, **kw)
if kw.has_key('maxlen') and len(output) > kw['maxlen']:
return output[:kw['maxlen']]
return output
class WebSafe(Filter):
"""Escape HTML entities in $placeholders.
"""
def filter(self, val, **kw):
s = super(WebSafe, self).filter(val, **kw)
# These substitutions are copied from cgi.escape().
s = s.replace("&", "&") # Must be done first!
s = s.replace("<", "<")
s = s.replace(">", ">")
# Process the additional transformations if any.
if kw.has_key('also'):
also = kw['also']
entities = webSafeEntities # Global variable.
for k in also:
if k in entities:
v = entities[k]
else:
v = "&#%s;" % ord(k)
s = s.replace(k, v)
return s
class Strip(Filter):
"""Strip leading/trailing whitespace but preserve newlines.
This filter goes through the value line by line, removing leading and
trailing whitespace on each line. It does not strip newlines, so every
input line corresponds to one output line, with its trailing newline intact.
We do not use val.split('\n') because that would squeeze out consecutive
blank lines. Instead, we search for each newline individually. This
makes us unable to use the fast C .split method, but it makes the filter
much more widely useful.
This filter is intended to be usable both with the #filter directive and
with the proposed #sed directive (which has not been ratified yet.)
"""
def filter(self, val, **kw):
s = super(Strip, self).filter(val, **kw)
result = []
start = 0 # The current line will be s[start:end].
while 1: # Loop through each line.
end = s.find('\n', start) # Find next newline.
if end == -1: # If no more newlines.
break
chunk = s[start:end].strip()
result.append(chunk)
result.append('\n')
start = end + 1
# Write the unfinished portion after the last newline, if any.
chunk = s[start:].strip()
result.append(chunk)
return "".join(result)
class StripSqueeze(Filter):
"""Canonicalizes every chunk of whitespace to a single space.
Strips leading/trailing whitespace. Removes all newlines, so multi-line
input is joined into one ling line with NO trailing newline.
"""
def filter(self, val, **kw):
s = super(StripSqueeze, self).filter(val, **kw)
s = s.split()
return " ".join(s)
##################################################
## MAIN ROUTINE -- testing
def test():
s1 = "abc <=> &"
s2 = " asdf \n\t 1 2 3\n"
print "WebSafe INPUT:", `s1`
print " WebSafe:", `WebSafe().filter(s1)`
print
print " Strip INPUT:", `s2`
print " Strip:", `Strip().filter(s2)`
print "StripSqueeze:", `StripSqueeze().filter(s2)`
print "Unicode:", `EncodeUnicode().filter(u'aoeu12345\u1234')`
if __name__ == "__main__": test()
# vim: shiftwidth=4 tabstop=4 expandtab
|
