Mercurial > genshi > mirror

annotate markup/core.py @ 150:d35688d16831 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Removed to many classes from the `__all__` list of `markup.template` in [191].
author cmlenz
date Tue, 15 Aug 2006 22:01:01 +0000
parents a4a0ca41b6ad
children 7b1f07496bf7
rev   line source
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
1 # -*- coding: utf-8 -*-
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
2 #
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 54
diff changeset
3 # Copyright (C) 2006 Edgewall Software
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
4 # All rights reserved.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
5 #
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
6 # This software is licensed as described in the file COPYING, which
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
7 # you should have received as part of this distribution. The terms
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 54
diff changeset
8 # are also available at http://markup.edgewall.org/wiki/License.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
9 #
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
10 # This software consists of voluntary contributions made by many
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
11 # individuals. For the exact contribution history, see the revision
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 54
diff changeset
12 # history and logs, available at http://markup.edgewall.org/log/.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
13
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
14 """Core classes for markup processing."""
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
15
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
16 import htmlentitydefs
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
17 import re
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
18
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
19 __all__ = ['Stream', 'Markup', 'escape', 'unescape', 'Namespace', 'QName']
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
20
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
21
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
22 class StreamEventKind(str):
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
23 """A kind of event on an XML stream."""
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
24
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
25
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
26 class Stream(object):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
27 """Represents a stream of markup events.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
28
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
29 This class is basically an iterator over the events.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
30
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
31 Also provided are ways to serialize the stream to text. The `serialize()`
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
32 method will return an iterator over generated strings, while `render()`
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
33 returns the complete generated text at once. Both accept various parameters
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
34 that impact the way the stream is serialized.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
35
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
36 Stream events are tuples of the form:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
37
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
38 (kind, data, position)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
39
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
40 where `kind` is the event kind (such as `START`, `END`, `TEXT`, etc), `data`
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
41 depends on the kind of event, and `position` is a `(line, offset)` tuple
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
42 that contains the location of the original element or text in the input.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
43 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
44 __slots__ = ['events']
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
45
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
46 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
47 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
48 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
49 DOCTYPE = StreamEventKind('DOCTYPE') # doctype declaration
143
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents: 141
diff changeset
50 START_NS = StreamEventKind('START_NS') # start namespace mapping
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents: 141
diff changeset
51 END_NS = StreamEventKind('END_NS') # end namespace mapping
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents: 141
diff changeset
52 START_CDATA = StreamEventKind('START_CDATA') # start CDATA section
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents: 141
diff changeset
53 END_CDATA = StreamEventKind('END_CDATA') # end CDATA section
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
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
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
56
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
57 def __init__(self, events):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
58 """Initialize the stream with a sequence of markup events.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
59
27
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 18
diff changeset
60 @param events: a sequence or iterable providing the events
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
61 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
62 self.events = events
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
63
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
64 def __iter__(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
65 return iter(self.events)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
66
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
67 def filter(self, *filters):
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
68 """Apply filters to the stream.
113
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
69
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
70 This method returns a new stream with the given filters applied. The
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
71 filters must be callables that accept the stream object as parameter,
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
72 and return the filtered stream.
113
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
73 """
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
74 stream = self
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
75 for filter_ in filters:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
76 stream = filter_(iter(stream))
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
77 return Stream(stream)
113
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
78
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
79 def render(self, method='xml', encoding='utf-8', **kwargs):
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
80 """Return a string representation of the stream.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
81
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
82 @param method: determines how the stream is serialized; can be either
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 91
diff changeset
83 "xml", "xhtml", or "html", or a custom `Serializer`
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 91
diff changeset
84 subclass
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
85 @param encoding: how the output string should be encoded; if set to
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
86 `None`, this method returns a `unicode` object
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
87
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
88 Any additional keyword arguments are passed to the serializer, and thus
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
89 depend on the `method` parameter value.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
90 """
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
91 generator = self.serialize(method=method, **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
92 output = u''.join(list(generator))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
93 if encoding is not None:
147
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work.
cmlenz
parents: 145
diff changeset
94 return output.encode(encoding, 'xmlcharrefreplace')
8
3710e3d0d4a2 `Stream.render()` was masking `TypeError`s (fix based on suggestion by Matt Good).
cmlenz
parents: 6
diff changeset
95 return output
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
96
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
97 def select(self, path):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
98 """Return a new stream that contains the events matching the given
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
99 XPath expression.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
100
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
101 @param path: a string containing the XPath expression
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
102 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
103 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
104 return Path(path).select(self)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
105
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
106 def serialize(self, method='xml', **kwargs):
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
107 """Generate strings corresponding to a specific serialization of the
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
108 stream.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
109
18
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
110 Unlike the `render()` method, this method is a generator that returns
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
111 the serialized output incrementally, as opposed to returning a single
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
112 string.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
113
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
114 @param method: determines how the stream is serialized; can be either
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
115 "xml", "xhtml", or "html", or a custom serializer class
147
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work.
cmlenz
parents: 145
diff changeset
116
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work.
cmlenz
parents: 145
diff changeset
117 Any additional keyword arguments are passed to the serializer, and thus
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work.
cmlenz
parents: 145
diff changeset
118 depend on the `method` parameter value.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
119 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
120 from markup import output
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
121 cls = method
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
122 if isinstance(method, basestring):
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 91
diff changeset
123 cls = {'xml': output.XMLSerializer,
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 91
diff changeset
124 'xhtml': output.XHTMLSerializer,
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 91
diff changeset
125 'html': output.HTMLSerializer}[method]
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
126 serialize = cls(**kwargs)
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 116
diff changeset
127 return serialize(_ensure(self))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
128
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
129 def __str__(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
130 return self.render()
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
131
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
132 def __unicode__(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
133 return self.render(encoding=None)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
134
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
135
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
136 START = Stream.START
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
137 END = Stream.END
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
138 TEXT = Stream.TEXT
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
139 DOCTYPE = Stream.DOCTYPE
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
140 START_NS = Stream.START_NS
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
141 END_NS = Stream.END_NS
143
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents: 141
diff changeset
142 START_CDATA = Stream.START_CDATA
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents: 141
diff changeset
143 END_CDATA = Stream.END_CDATA
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
144 PI = Stream.PI
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
145 COMMENT = Stream.COMMENT
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
146
111
2368c3becc52 Some fixes and more unit tests for the XPath engine.
cmlenz
parents: 100
diff changeset
147 def _ensure(stream):
2368c3becc52 Some fixes and more unit tests for the XPath engine.
cmlenz
parents: 100
diff changeset
148 """Ensure that every item on the stream is actually a markup event."""
2368c3becc52 Some fixes and more unit tests for the XPath engine.
cmlenz
parents: 100
diff changeset
149 for event in stream:
145
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples.
cmlenz
parents: 143
diff changeset
150 if type(event) is not tuple:
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples.
cmlenz
parents: 143
diff changeset
151 if hasattr(event, 'totuple'):
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples.
cmlenz
parents: 143
diff changeset
152 event = event.totuple()
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples.
cmlenz
parents: 143
diff changeset
153 else:
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples.
cmlenz
parents: 143
diff changeset
154 event = TEXT, unicode(event), (None, -1, -1)
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples.
cmlenz
parents: 143
diff changeset
155 yield event
111
2368c3becc52 Some fixes and more unit tests for the XPath engine.
cmlenz
parents: 100
diff changeset
156
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
157
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
158 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
159 """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
160
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
161 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
162 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
163
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
164 >>> 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
165 >>> attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
166 [(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
167
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
168 >>> 'href' in attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
169 True
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
170 >>> 'tabindex' in attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
171 False
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
172
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
173 >>> 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
174 'Foo'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
175 >>> 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
176 >>> attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
177 [(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
178 >>> 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
179 >>> attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
180 [(u'href', '#')]
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
181
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
182 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
183 the list:
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
184
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
185 >>> 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
186 >>> attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
187 [(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
188 """
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
189 __slots__ = []
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
190
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
191 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
192 """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
193
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
194 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
195 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
196 """
27
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 18
diff changeset
197 if attrib is None:
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 18
diff changeset
198 attrib = []
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 18
diff changeset
199 list.__init__(self, [(QName(name), value) for name, value in attrib])
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
200
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
201 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
202 """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
203 name.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
204 """
133
79f445396cd7 Minor cleanup and performance improvement for the builder module.
cmlenz
parents: 123
diff changeset
205 for attr, _ in self:
79f445396cd7 Minor cleanup and performance improvement for the builder module.
cmlenz
parents: 123
diff changeset
206 if attr == name:
79f445396cd7 Minor cleanup and performance improvement for the builder module.
cmlenz
parents: 123
diff changeset
207 return True
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
208
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
209 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
210 """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
211 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
212 """
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
213 for attr, value in self:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
214 if attr == name:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
215 return value
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
216 return default
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
217
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
218 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
219 """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
220
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
221 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
222 """
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
223 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
224 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
225 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
226 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
227
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
228 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
229 """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
230
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
231 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
232 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
233 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
234 """
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
235 for idx, (attr, _) in enumerate(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
236 if attr == name:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
237 self[idx] = (attr, value)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
238 break
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
239 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
240 self.append((QName(name), value))
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
241
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
242 def totuple(self):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
243 return TEXT, u''.join([x[1] for x in self]), (None, -1, -1)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
244
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
245
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
246 def plaintext(text, keeplinebreaks=True):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
247 """Returns the text as a `unicode` string with all entities and tags
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
248 removed.
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
249 """
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
250 text = stripentities(striptags(text))
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
251 if not keeplinebreaks:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
252 text = text.replace(u'\n', u' ')
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
253 return text
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
254
113
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
255 def stripentities(text, keepxmlentities=False):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
256 """Return a copy of the given text with any character or numeric entities
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
257 replaced by the equivalent UTF-8 characters.
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
258
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
259 If the `keepxmlentities` parameter is provided and evaluates to `True`,
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
260 the core XML entities (&amp;, &apos;, &gt;, &lt; and &quot;) are not
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
261 stripped.
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
262 """
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
263 def _replace_entity(match):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
264 if match.group(1): # numeric entity
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
265 ref = match.group(1)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
266 if ref.startswith('x'):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
267 ref = int(ref[1:], 16)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
268 else:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
269 ref = int(ref, 10)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
270 return unichr(ref)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
271 else: # character entity
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
272 ref = match.group(2)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
273 if keepxmlentities and ref in ('amp', 'apos', 'gt', 'lt',
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
274 'quot'):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
275 return '&%s;' % ref
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
276 try:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
277 codepoint = htmlentitydefs.name2codepoint[ref]
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
278 return unichr(codepoint)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
279 except KeyError:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
280 if keepxmlentities:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
281 return '&amp;%s;' % ref
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
282 else:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
283 return ref
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
284 return re.sub(r'&(?:#((?:\d+)|(?:[xX][0-9a-fA-F]+));?|(\w+);)',
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
285 _replace_entity, text)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
286
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
287 def striptags(text):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
288 """Return a copy of the text with all XML/HTML tags removed."""
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
289 return re.sub(r'<[^>]*?>', '', text)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
290
113
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream.
cmlenz
parents: 111
diff changeset
291
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
292 class Markup(unicode):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
293 """Marks a string as being safe for inclusion in HTML/XML output without
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
294 needing to be escaped.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
295 """
18
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
296 __slots__ = []
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
297
27
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 18
diff changeset
298 def __new__(cls, text='', *args):
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
299 if args:
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 133
diff changeset
300 text %= tuple(map(escape, args))
27
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 18
diff changeset
301 return unicode.__new__(cls, text)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
302
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
303 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
304 return Markup(unicode(self) + escape(other))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
305
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
306 def __mod__(self, args):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
307 if not isinstance(args, (list, tuple)):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
308 args = [args]
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 133
diff changeset
309 return Markup(unicode.__mod__(self, tuple(map(escape, args))))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
310
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
311 def __mul__(self, num):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
312 return Markup(unicode(self) * num)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
313
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
314 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
315 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
316
54
1f3cd91325d9 Fix a number of escaping problems:
cmlenz
parents: 34
diff changeset
317 def join(self, seq, escape_quotes=True):
1f3cd91325d9 Fix a number of escaping problems:
cmlenz
parents: 34
diff changeset
318 return Markup(unicode(self).join([escape(item, quotes=escape_quotes)
34
3421dd98f015 quotes should not be escaped inside text nodes
mgood
parents: 27
diff changeset
319 for item in seq]))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
320
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
321 def escape(cls, text, quotes=True):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
322 """Create a Markup instance from a string and escape special characters
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
323 it may contain (<, >, & and \").
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
324
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
325 If the `quotes` parameter is set to `False`, the \" character is left
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
326 as is. Escaping quotes is generally only required for strings that are
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
327 to be used in attribute values.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
328 """
73
1da51d718391 Some more performance tweaks.
cmlenz
parents: 69
diff changeset
329 if not text:
1da51d718391 Some more performance tweaks.
cmlenz
parents: 69
diff changeset
330 return cls()
1da51d718391 Some more performance tweaks.
cmlenz
parents: 69
diff changeset
331 if type(text) is cls:
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
332 return text
73
1da51d718391 Some more performance tweaks.
cmlenz
parents: 69
diff changeset
333 text = unicode(text).replace('&', '&amp;') \
1da51d718391 Some more performance tweaks.
cmlenz
parents: 69
diff changeset
334 .replace('<', '&lt;') \
1da51d718391 Some more performance tweaks.
cmlenz
parents: 69
diff changeset
335 .replace('>', '&gt;')
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
336 if quotes:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
337 text = text.replace('"', '&#34;')
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
338 return cls(text)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
339 escape = classmethod(escape)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
340
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
341 def unescape(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
342 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
343 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
344 return u''
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
345 return unicode(self).replace('&#34;', '"') \
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
346 .replace('&gt;', '>') \
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
347 .replace('&lt;', '<') \
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
348 .replace('&amp;', '&')
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
349
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
350 def stripentities(self, keepxmlentities=False):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
351 """Return a copy of the text with any character or numeric entities
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
352 replaced by the equivalent UTF-8 characters.
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
353
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
354 If the `keepxmlentities` parameter is provided and evaluates to `True`,
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
355 the core XML entities (&amp;, &apos;, &gt;, &lt; and &quot;) are not
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
356 stripped.
6
71e8e645fe81 Simplified implementation of `py:content` directive.
cmlenz
parents: 5
diff changeset
357 """
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
358 return Markup(stripentities(self, keepxmlentities=keepxmlentities))
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
359
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
360 def striptags(self):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
361 """Return a copy of the text with all XML/HTML tags removed."""
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 115
diff changeset
362 return Markup(striptags(self))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
363
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
364
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
365 escape = Markup.escape
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
366
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
367 def unescape(text):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
368 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
369 if not isinstance(text, Markup):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
370 return text
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
371 return text.unescape()
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
372
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
373
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
374 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
375 """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
376
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
377 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
378 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
379 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
380
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
381 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
382
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
383 >>> 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
384 >>> html
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
385 <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
386 >>> html.uri
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
387 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
388
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
389 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
390 that namespace:
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
391
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
392 >>> html.body
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
393 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
394 >>> html.body.localname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
395 u'body'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
396 >>> html.body.namespace
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
397 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
398
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
399 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
400 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
401
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
402 >>> html['body']
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
403 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
404
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
405 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
406 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
407
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
408 >>> qname = html.body
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
409 >>> qname in html
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
410 True
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
411 >>> 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
412 False
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
413 """
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
414 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
415 self.uri = unicode(uri)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
416
18
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
417 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
418 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
419
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
420 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
421 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
422 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
423 return self.uri == other
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
424
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
425 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
426 return QName(self.uri + u'}' + name)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
427 __getattr__ = __getitem__
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
428
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
429 def __repr__(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
430 return '<Namespace "%s">' % self.uri
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
431
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
432 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
433 return self.uri.encode('utf-8')
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
434
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
435 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
436 return self.uri
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
437
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
438
147
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work.
cmlenz
parents: 145
diff changeset
439 # The namespace used by attributes such as xml:lang and xml:space
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
440 XML_NAMESPACE = Namespace('http://www.w3.org/XML/1998/namespace')
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
441
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
442
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
443 class QName(unicode):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
444 """A qualified element or attribute name.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
445
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
446 The unicode value of instances of this class contains the qualified name of
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
447 the element or attribute, in the form `{namespace}localname`. The namespace
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
448 URI can be obtained through the additional `namespace` attribute, while the
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
449 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
450
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
451 >>> qname = QName('foo')
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
452 >>> qname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
453 u'foo'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
454 >>> qname.localname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
455 u'foo'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
456 >>> qname.namespace
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
457
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
458 >>> 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
459 >>> qname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
460 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
461 >>> qname.localname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
462 u'body'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
463 >>> qname.namespace
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
464 u'http://www.w3.org/1999/xhtml'
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
465 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
466 __slots__ = ['namespace', 'localname']
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
467
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
468 def __new__(cls, qname):
100
a519f581a1b1 Ported [111] to trunk.
cmlenz
parents: 96
diff changeset
469 if type(qname) is cls:
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
470 return qname
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
471
18
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents: 17
diff changeset
472 parts = qname.split(u'}', 1)
100
a519f581a1b1 Ported [111] to trunk.
cmlenz
parents: 96
diff changeset
473 if len(parts) > 1:
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 133
diff changeset
474 self = unicode.__new__(cls, u'{%s' % qname)
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 133
diff changeset
475 self.namespace, self.localname = map(unicode, parts)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
476 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
477 self = unicode.__new__(cls, qname)
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 133
diff changeset
478 self.namespace, self.localname = None, unicode(qname)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
479 return self
Copyright (C) 2012-2017 Edgewall Software