Mercurial > genshi > mirror
annotate markup/core.py @ 27:b4f78c05e5c9 trunk
* Fix the boilerplate in the Python source files.
* Some more docstrings and cosmetic fixes.
| author | cmlenz |
|---|---|
| date | Wed, 28 Jun 2006 09:28:09 +0000 |
| parents | 5420cfe42d36 |
| children | 3421dd98f015 |
| rev | line source |
|---|---|
| 1 | 1 # -*- coding: utf-8 -*- |
| 2 # | |
| 3 # Copyright (C) 2006 Christopher Lenz | |
| 4 # All rights reserved. | |
| 5 # | |
| 6 # This software is licensed as described in the file COPYING, which | |
| 7 # you should have received as part of this distribution. The terms | |
| 27 | 8 # are also available at http://markup.cmlenz.net/wiki/License. |
| 1 | 9 # |
| 10 # This software consists of voluntary contributions made by many | |
| 11 # individuals. For the exact contribution history, see the revision | |
| 27 | 12 # history and logs, available at http://markup.cmlenz.net/log/. |
| 1 | 13 |
| 14 """Core classes for markup processing.""" | |
| 15 | |
| 16 import htmlentitydefs | |
| 17 import re | |
| 18 from StringIO import StringIO | |
| 19 | |
| 20 __all__ = ['Stream', 'Markup', 'escape', 'unescape', 'Namespace', 'QName'] | |
| 21 | |
| 22 | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
23 class StreamEventKind(str): |
| 1 | 24 """A kind of event on an XML stream.""" |
| 25 | |
| 26 | |
| 27 class Stream(object): | |
| 28 """Represents a stream of markup events. | |
| 29 | |
| 30 This class is basically an iterator over the events. | |
| 31 | |
| 32 Also provided are ways to serialize the stream to text. The `serialize()` | |
| 33 method will return an iterator over generated strings, while `render()` | |
| 34 returns the complete generated text at once. Both accept various parameters | |
| 35 that impact the way the stream is serialized. | |
| 36 | |
| 37 Stream events are tuples of the form: | |
| 38 | |
| 39 (kind, data, position) | |
| 40 | |
| 41 where `kind` is the event kind (such as `START`, `END`, `TEXT`, etc), `data` | |
| 42 depends on the kind of event, and `position` is a `(line, offset)` tuple | |
| 43 that contains the location of the original element or text in the input. | |
| 44 """ | |
| 45 __slots__ = ['events'] | |
| 46 | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
47 START = StreamEventKind('START') # a start tag |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
48 END = StreamEventKind('END') # an end tag |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
49 TEXT = StreamEventKind('TEXT') # literal text |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
50 PROLOG = StreamEventKind('PROLOG') # XML prolog |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
51 DOCTYPE = StreamEventKind('DOCTYPE') # doctype declaration |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
52 START_NS = StreamEventKind('START-NS') # start namespace mapping |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
53 END_NS = StreamEventKind('END-NS') # end namespace mapping |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
54 PI = StreamEventKind('PI') # processing instruction |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
55 COMMENT = StreamEventKind('COMMENT') # comment |
| 1 | 56 |
| 57 def __init__(self, events): | |
| 58 """Initialize the stream with a sequence of markup events. | |
| 59 | |
| 27 | 60 @param events: a sequence or iterable providing the events |
| 1 | 61 """ |
| 62 self.events = events | |
| 63 | |
| 64 def __iter__(self): | |
| 65 return iter(self.events) | |
| 66 | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
67 def render(self, method='xml', encoding='utf-8', filters=None, **kwargs): |
| 1 | 68 """Return a string representation of the stream. |
| 69 | |
| 70 @param method: determines how the stream is serialized; can be either | |
| 71 'xml' or 'html', or a custom `Serializer` subclass | |
| 72 @param encoding: how the output string should be encoded; if set to | |
| 73 `None`, this method returns a `unicode` object | |
| 74 | |
| 75 Any additional keyword arguments are passed to the serializer, and thus | |
| 76 depend on the `method` parameter value. | |
| 77 """ | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
78 generator = self.serialize(method=method, filters=filters, **kwargs) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
79 output = u''.join(list(generator)) |
| 1 | 80 if encoding is not None: |
|
9
5dc4bfe67c20
Actually use the specified encoding in `Stream.render()`.
cmlenz
parents:
8
diff
changeset
|
81 return output.encode(encoding) |
|
8
3710e3d0d4a2
`Stream.render()` was masking `TypeError`s (fix based on suggestion by Matt Good).
cmlenz
parents:
6
diff
changeset
|
82 return output |
| 1 | 83 |
| 84 def select(self, path): | |
| 85 """Return a new stream that contains the events matching the given | |
| 86 XPath expression. | |
| 87 | |
| 88 @param path: a string containing the XPath expression | |
| 89 """ | |
| 90 from markup.path import Path | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
91 return Path(path).select(self) |
| 1 | 92 |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
93 def serialize(self, method='xml', filters=None, **kwargs): |
| 1 | 94 """Generate strings corresponding to a specific serialization of the |
| 95 stream. | |
| 96 | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
97 Unlike the `render()` method, this method is a generator that returns |
| 1 | 98 the serialized output incrementally, as opposed to returning a single |
| 99 string. | |
| 100 | |
| 101 @param method: determines how the stream is serialized; can be either | |
| 102 'xml' or 'html', or a custom `Serializer` subclass | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
103 @param filters: list of filters to apply to the stream before |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
104 serialization. The default is to apply whitespace |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
105 reduction using `markup.filters.WhitespaceFilter`. |
| 1 | 106 """ |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
107 from markup.filters import WhitespaceFilter |
| 1 | 108 from markup import output |
| 109 cls = method | |
| 110 if isinstance(method, basestring): | |
| 111 cls = {'xml': output.XMLSerializer, | |
| 112 'html': output.HTMLSerializer}[method] | |
| 113 else: | |
| 27 | 114 assert issubclass(cls, output.Serializer) |
| 1 | 115 serializer = cls(**kwargs) |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
116 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
117 stream = self |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
118 if filters is None: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
119 filters = [WhitespaceFilter()] |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
120 for filter_ in filters: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
121 stream = filter_(iter(stream)) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
122 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
123 return serializer.serialize(stream) |
| 1 | 124 |
| 125 def __str__(self): | |
| 126 return self.render() | |
| 127 | |
| 128 def __unicode__(self): | |
| 129 return self.render(encoding=None) | |
| 130 | |
| 131 | |
| 132 class Attributes(list): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
133 """Sequence type that stores the attributes of an element. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
134 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
135 The order of the attributes is preserved, while accessing and manipulating |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
136 attributes by name is also supported. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
137 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
138 >>> attrs = Attributes([('href', '#'), ('title', 'Foo')]) |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
139 >>> attrs |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
140 [(u'href', '#'), (u'title', 'Foo')] |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
141 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
142 >>> 'href' in attrs |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
143 True |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
144 >>> 'tabindex' in attrs |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
145 False |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
146 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
147 >>> attrs.get(u'title') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
148 'Foo' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
149 >>> attrs.set(u'title', 'Bar') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
150 >>> attrs |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
151 [(u'href', '#'), (u'title', 'Bar')] |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
152 >>> attrs.remove(u'title') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
153 >>> attrs |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
154 [(u'href', '#')] |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
155 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
156 New attributes added using the `set()` method are appended to the end of |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
157 the list: |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
158 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
159 >>> attrs.set(u'accesskey', 'k') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
160 >>> attrs |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
161 [(u'href', '#'), (u'accesskey', 'k')] |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
162 """ |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
163 __slots__ = [] |
| 1 | 164 |
| 165 def __init__(self, attrib=None): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
166 """Create the `Attributes` instance. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
167 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
168 If the `attrib` parameter is provided, it is expected to be a sequence |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
169 of `(name, value)` tuples. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
170 """ |
| 27 | 171 if attrib is None: |
| 172 attrib = [] | |
| 173 list.__init__(self, [(QName(name), value) for name, value in attrib]) | |
| 1 | 174 |
| 175 def __contains__(self, name): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
176 """Return whether the list includes an attribute with the specified |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
177 name. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
178 """ |
| 27 | 179 return name in [attr for attr, _ in self] |
| 1 | 180 |
| 181 def get(self, name, default=None): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
182 """Return the value of the attribute with the specified name, or the |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
183 value of the `default` parameter if no such attribute is found. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
184 """ |
| 1 | 185 for attr, value in self: |
| 186 if attr == name: | |
| 187 return value | |
| 188 return default | |
| 189 | |
|
5
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
190 def remove(self, name): |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
191 """Removes the attribute with the specified name. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
192 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
193 If no such attribute is found, this method does nothing. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
194 """ |
|
5
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
195 for idx, (attr, _) in enumerate(self): |
|
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
196 if attr == name: |
|
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
197 del self[idx] |
|
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
198 break |
|
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
199 |
| 1 | 200 def set(self, name, value): |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
201 """Sets the specified attribute to the given value. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
202 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
203 If an attribute with the specified name is already in the list, the |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
204 value of the existing entry is updated. Otherwise, a new attribute is |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
205 appended to the end of the list. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
206 """ |
| 1 | 207 for idx, (attr, _) in enumerate(self): |
| 208 if attr == name: | |
| 209 self[idx] = (attr, value) | |
| 210 break | |
| 211 else: | |
| 212 self.append((QName(name), value)) | |
| 213 | |
| 214 | |
| 215 class Markup(unicode): | |
| 216 """Marks a string as being safe for inclusion in HTML/XML output without | |
| 217 needing to be escaped. | |
| 218 """ | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
219 __slots__ = [] |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
220 |
| 27 | 221 def __new__(cls, text='', *args): |
| 1 | 222 if args: |
| 223 text %= tuple([escape(arg) for arg in args]) | |
| 27 | 224 return unicode.__new__(cls, text) |
| 1 | 225 |
| 226 def __add__(self, other): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
227 return Markup(unicode(self) + escape(other)) |
| 1 | 228 |
| 229 def __mod__(self, args): | |
| 230 if not isinstance(args, (list, tuple)): | |
| 231 args = [args] | |
| 232 return Markup(unicode.__mod__(self, | |
| 233 tuple([escape(arg) for arg in args]))) | |
| 234 | |
| 235 def __mul__(self, num): | |
| 236 return Markup(unicode(self) * num) | |
| 237 | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
238 def __repr__(self): |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
239 return '<%s "%s">' % (self.__class__.__name__, self) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
240 |
| 1 | 241 def join(self, seq): |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
242 return Markup(unicode(self).join([escape(item) for item in seq])) |
| 1 | 243 |
| 244 def stripentities(self, keepxmlentities=False): | |
| 245 """Return a copy of the text with any character or numeric entities | |
| 246 replaced by the equivalent UTF-8 characters. | |
| 247 | |
| 248 If the `keepxmlentities` parameter is provided and evaluates to `True`, | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
249 the core XML entities (&, ', >, < and ") are not |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
250 stripped. |
| 1 | 251 """ |
| 252 def _replace_entity(match): | |
| 253 if match.group(1): # numeric entity | |
| 254 ref = match.group(1) | |
| 255 if ref.startswith('x'): | |
| 256 ref = int(ref[1:], 16) | |
| 257 else: | |
| 258 ref = int(ref, 10) | |
| 259 return unichr(ref) | |
| 260 else: # character entity | |
| 261 ref = match.group(2) | |
| 27 | 262 if keepxmlentities and ref in ('amp', 'apos', 'gt', 'lt', |
| 263 'quot'): | |
| 1 | 264 return '&%s;' % ref |
| 265 try: | |
| 266 codepoint = htmlentitydefs.name2codepoint[ref] | |
| 267 return unichr(codepoint) | |
| 268 except KeyError: | |
| 269 if keepxmlentities: | |
| 270 return '&%s;' % ref | |
| 271 else: | |
| 272 return ref | |
| 273 return Markup(re.sub(r'&(?:#((?:\d+)|(?:[xX][0-9a-fA-F]+));?|(\w+);)', | |
| 274 _replace_entity, self)) | |
| 275 | |
| 276 def striptags(self): | |
| 277 """Return a copy of the text with all XML/HTML tags removed.""" | |
| 278 return Markup(re.sub(r'<[^>]*?>', '', self)) | |
| 279 | |
| 280 def escape(cls, text, quotes=True): | |
| 281 """Create a Markup instance from a string and escape special characters | |
| 282 it may contain (<, >, & and \"). | |
| 283 | |
| 284 If the `quotes` parameter is set to `False`, the \" character is left | |
| 285 as is. Escaping quotes is generally only required for strings that are | |
| 286 to be used in attribute values. | |
| 287 """ | |
| 288 if isinstance(text, cls): | |
| 289 return text | |
| 290 text = unicode(text) | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
291 if not text or isinstance(text, cls): |
| 1 | 292 return cls() |
| 293 text = text.replace('&', '&') \ | |
| 294 .replace('<', '<') \ | |
| 295 .replace('>', '>') | |
| 296 if quotes: | |
| 297 text = text.replace('"', '"') | |
| 298 return cls(text) | |
| 299 escape = classmethod(escape) | |
| 300 | |
| 301 def unescape(self): | |
| 302 """Reverse-escapes &, <, > and \" and returns a `unicode` object.""" | |
| 303 if not self: | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
304 return u'' |
| 1 | 305 return unicode(self).replace('"', '"') \ |
| 306 .replace('>', '>') \ | |
| 307 .replace('<', '<') \ | |
| 308 .replace('&', '&') | |
| 309 | |
| 310 def plaintext(self, keeplinebreaks=True): | |
| 6 | 311 """Returns the text as a `unicode` string with all entities and tags |
| 312 removed. | |
| 313 """ | |
| 1 | 314 text = unicode(self.striptags().stripentities()) |
| 315 if not keeplinebreaks: | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
316 text = text.replace(u'\n', u' ') |
| 1 | 317 return text |
| 318 | |
| 319 def sanitize(self): | |
| 320 from markup.filters import HTMLSanitizer | |
| 321 from markup.input import HTMLParser | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
322 text = StringIO(self.stripentities(keepxmlentities=True)) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
10
diff
changeset
|
323 return Stream(HTMLSanitizer()(HTMLParser(text))) |
| 1 | 324 |
| 325 | |
| 326 escape = Markup.escape | |
| 327 | |
| 328 def unescape(text): | |
| 329 """Reverse-escapes &, <, > and \" and returns a `unicode` object.""" | |
| 330 if not isinstance(text, Markup): | |
| 331 return text | |
| 332 return text.unescape() | |
| 333 | |
| 334 | |
| 335 class Namespace(object): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
336 """Utility class creating and testing elements with a namespace. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
337 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
338 Internally, namespace URIs are encoded in the `QName` of any element or |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
339 attribute, the namespace URI being enclosed in curly braces. This class |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
340 helps create and test these strings. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
341 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
342 A `Namespace` object is instantiated with the namespace URI. |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
343 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
344 >>> html = Namespace('http://www.w3.org/1999/xhtml') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
345 >>> html |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
346 <Namespace "http://www.w3.org/1999/xhtml"> |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
347 >>> html.uri |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
348 u'http://www.w3.org/1999/xhtml' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
349 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
350 The `Namespace` object can than be used to generate `QName` objects with |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
351 that namespace: |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
352 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
353 >>> html.body |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
354 u'{http://www.w3.org/1999/xhtml}body' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
355 >>> html.body.localname |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
356 u'body' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
357 >>> html.body.namespace |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
358 u'http://www.w3.org/1999/xhtml' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
359 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
360 The same works using item access notation, which is useful for element or |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
361 attribute names that are not valid Python identifiers: |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
362 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
363 >>> html['body'] |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
364 u'{http://www.w3.org/1999/xhtml}body' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
365 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
366 A `Namespace` object can also be used to test whether a specific `QName` |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
367 belongs to that namespace using the `in` operator: |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
368 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
369 >>> qname = html.body |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
370 >>> qname in html |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
371 True |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
372 >>> qname in Namespace('http://www.w3.org/2002/06/xhtml2') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
373 False |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
374 """ |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
375 def __init__(self, uri): |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
376 self.uri = unicode(uri) |
| 1 | 377 |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
378 def __contains__(self, qname): |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
379 return qname.namespace == self.uri |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
380 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
381 def __eq__(self, other): |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
382 if isinstance(other, Namespace): |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
383 return self.uri == other.uri |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
384 return self.uri == other |
| 1 | 385 |
| 386 def __getitem__(self, name): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
387 return QName(self.uri + u'}' + name) |
| 1 | 388 |
| 389 __getattr__ = __getitem__ | |
| 390 | |
| 391 def __repr__(self): | |
| 392 return '<Namespace "%s">' % self.uri | |
| 393 | |
| 394 def __str__(self): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
395 return self.uri.encode('utf-8') |
| 1 | 396 |
| 397 def __unicode__(self): | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
398 return self.uri |
| 1 | 399 |
| 400 | |
| 401 class QName(unicode): | |
| 402 """A qualified element or attribute name. | |
| 403 | |
| 404 The unicode value of instances of this class contains the qualified name of | |
| 405 the element or attribute, in the form `{namespace}localname`. The namespace | |
| 406 URI can be obtained through the additional `namespace` attribute, while the | |
| 407 local name can be accessed through the `localname` attribute. | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
408 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
409 >>> qname = QName('foo') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
410 >>> qname |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
411 u'foo' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
412 >>> qname.localname |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
413 u'foo' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
414 >>> qname.namespace |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
415 |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
416 >>> qname = QName('http://www.w3.org/1999/xhtml}body') |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
417 >>> qname |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
418 u'{http://www.w3.org/1999/xhtml}body' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
419 >>> qname.localname |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
420 u'body' |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
421 >>> qname.namespace |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
422 u'http://www.w3.org/1999/xhtml' |
| 1 | 423 """ |
| 424 __slots__ = ['namespace', 'localname'] | |
| 425 | |
| 426 def __new__(cls, qname): | |
| 427 if isinstance(qname, QName): | |
| 428 return qname | |
| 429 | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
430 parts = qname.split(u'}', 1) |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
431 if qname.find(u'}') > 0: |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
432 self = unicode.__new__(cls, u'{' + qname) |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
433 self.namespace = unicode(parts[0]) |
|
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
434 self.localname = unicode(parts[1]) |
| 1 | 435 else: |
| 436 self = unicode.__new__(cls, qname) | |
| 437 self.namespace = None | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
438 self.localname = unicode(qname) |
| 1 | 439 return self |