annotate genshi/output.py @ 719:4bc6741b2811 trunk

Fix copyright years.
author cmlenz
date Thu, 10 Apr 2008 19:47:27 +0000
parents 5420fe9d99a9
children be0b4a7b2fd4
rev   line source
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
1 # -*- coding: utf-8 -*-
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
2 #
719
4bc6741b2811 Fix copyright years.
cmlenz
parents: 713
diff changeset
3 # Copyright (C) 2006-2008 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
230
84168828b074 Renamed Markup to Genshi in repository.
cmlenz
parents: 219
diff changeset
8 # are also available at http://genshi.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
230
84168828b074 Renamed Markup to Genshi in repository.
cmlenz
parents: 219
diff changeset
12 # history and logs, available at http://genshi.edgewall.org/log/.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
13
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
14 """This module provides different kinds of serialization methods for XML event
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
15 streams.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
16 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
17
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
18 from itertools import chain
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
19 try:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
20 frozenset
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
21 except NameError:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
22 from sets import ImmutableSet as frozenset
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
23 import re
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
24
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
25 from genshi.core import escape, Attrs, Markup, Namespace, QName, StreamEventKind
460
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
26 from genshi.core import START, END, TEXT, XML_DECL, DOCTYPE, START_NS, END_NS, \
402
c199e9b95884 Fix output of namespace declarations for namespace URLs appearing more than once in a stream. Thanks to Jeff Cutsinger for reporting the problem.
cmlenz
parents: 397
diff changeset
27 START_CDATA, END_CDATA, PI, COMMENT, XML_NAMESPACE
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
28
462
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
29 __all__ = ['encode', 'get_serializer', 'DocType', 'XMLSerializer',
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
30 'XHTMLSerializer', 'HTMLSerializer', 'TextSerializer']
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
31 __docformat__ = 'restructuredtext en'
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
32
688
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
33 def encode(iterator, method='xml', encoding='utf-8', out=None):
462
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
34 """Encode serializer output into a string.
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
35
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
36 :param iterator: the iterator returned from serializing a stream (basically
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
37 any iterator that yields unicode objects)
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
38 :param method: the serialization method; determines how characters not
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
39 representable in the specified encoding are treated
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
40 :param encoding: how the output string should be encoded; if set to `None`,
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
41 this method returns a `unicode` object
688
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
42 :param out: a file-like object that the output should be written to
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
43 instead of being returned as one big string; note that if
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
44 this is a file or socket (or similar), the `encoding` must
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
45 not be `None` (that is, the output must be encoded)
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
46 :return: a `str` or `unicode` object (depending on the `encoding`
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
47 parameter), or `None` if the `out` parameter is provided
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
48
462
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
49 :since: version 0.4.1
688
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
50 :note: Changed in 0.5: added the `out` parameter
462
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
51 """
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
52 if encoding is not None:
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
53 errors = 'replace'
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
54 if method != 'text' and not isinstance(method, TextSerializer):
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
55 errors = 'xmlcharrefreplace'
688
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
56 _encode = lambda string: string.encode(encoding, errors)
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
57 else:
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
58 _encode = lambda string: string
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
59 if out is None:
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
60 return _encode(u''.join(list(iterator)))
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
61 for chunk in iterator:
d8571da25bc5 The `Stream.render` now accepts an optional `out` parameter that can be used to pass in a writable file-like object to use for assembling the output, instead of building a big string and returning it.
cmlenz
parents: 672
diff changeset
62 out.write(_encode(chunk))
462
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
63
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
64 def get_serializer(method='xml', **kwargs):
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
65 """Return a serializer object for the given method.
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
66
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
67 :param method: the serialization method; can be either "xml", "xhtml",
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
68 "html", "text", or a custom serializer class
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
69
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
70 Any additional keyword arguments are passed to the serializer, and thus
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
71 depend on the `method` parameter value.
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
72
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
73 :see: `XMLSerializer`, `XHTMLSerializer`, `HTMLSerializer`, `TextSerializer`
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
74 :since: version 0.4.1
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
75 """
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
76 if isinstance(method, basestring):
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
77 method = {'xml': XMLSerializer,
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
78 'xhtml': XHTMLSerializer,
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
79 'html': HTMLSerializer,
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
80 'text': TextSerializer}[method.lower()]
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
81 return method(**kwargs)
d5e2a7b58116 Add lower-level serialization functions.
cmlenz
parents: 460
diff changeset
82
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
83
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
84 class DocType(object):
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
85 """Defines a number of commonly used DOCTYPE declarations as constants."""
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
86
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
87 HTML_STRICT = (
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
88 'html', '-//W3C//DTD HTML 4.01//EN',
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
89 'http://www.w3.org/TR/html4/strict.dtd'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
90 )
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
91 HTML_TRANSITIONAL = (
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
92 'html', '-//W3C//DTD HTML 4.01 Transitional//EN',
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
93 'http://www.w3.org/TR/html4/loose.dtd'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
94 )
464
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
95 HTML_FRAMESET = (
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
96 'html', '-//W3C//DTD HTML 4.01 Frameset//EN',
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
97 'http://www.w3.org/TR/html4/frameset.dtd'
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
98 )
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
99 HTML = HTML_STRICT
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
100
464
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
101 HTML5 = ('html', None, None)
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
102
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
103 XHTML_STRICT = (
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
104 'html', '-//W3C//DTD XHTML 1.0 Strict//EN',
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
105 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
106 )
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
107 XHTML_TRANSITIONAL = (
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
108 'html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
109 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
110 )
464
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
111 XHTML_FRAMESET = (
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
112 'html', '-//W3C//DTD XHTML 1.0 Frameset//EN',
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
113 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd'
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
114 )
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
115 XHTML = XHTML_STRICT
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
116
663
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
117 SVG_FULL = (
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
118 'svg', '-//W3C//DTD SVG 1.1//EN',
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
119 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
120 )
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
121 SVG_BASIC = (
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
122 'svg', '-//W3C//DTD SVG Basic 1.1//EN',
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
123 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd'
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
124 )
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
125 SVG_TINY = (
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
126 'svg', '-//W3C//DTD SVG Tiny 1.1//EN',
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
127 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-tiny.dtd'
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
128 )
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
129 SVG = SVG_FULL
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
130
464
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
131 def get(cls, name):
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
132 """Return the ``(name, pubid, sysid)`` tuple of the ``DOCTYPE``
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
133 declaration for the specified name.
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
134
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
135 The following names are recognized in this version:
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
136 * "html" or "html-strict" for the HTML 4.01 strict DTD
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
137 * "html-transitional" for the HTML 4.01 transitional DTD
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
138 * "html-transitional" for the HTML 4.01 frameset DTD
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
139 * "html5" for the ``DOCTYPE`` proposed for HTML5
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
140 * "xhtml" or "xhtml-strict" for the XHTML 1.0 strict DTD
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
141 * "xhtml-transitional" for the XHTML 1.0 transitional DTD
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
142 * "xhtml-frameset" for the XHTML 1.0 frameset DTD
663
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
143 * "svg" or "svg-full" for the SVG 1.1 DTD
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
144 * "svg-basic" for the SVG Basic 1.1 DTD
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
145 * "svg-tiny" for the SVG Tiny 1.1 DTD
464
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
146
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
147 :param name: the name of the ``DOCTYPE``
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
148 :return: the ``(name, pubid, sysid)`` tuple for the requested
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
149 ``DOCTYPE``, or ``None`` if the name is not recognized
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
150 :since: version 0.4.1
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
151 """
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
152 return {
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
153 'html': cls.HTML, 'html-strict': cls.HTML_STRICT,
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
154 'html-transitional': DocType.HTML_TRANSITIONAL,
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
155 'html-frameset': DocType.HTML_FRAMESET,
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
156 'html5': cls.HTML5,
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
157 'xhtml': cls.XHTML, 'xhtml-strict': cls.XHTML_STRICT,
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
158 'xhtml-transitional': cls.XHTML_TRANSITIONAL,
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
159 'xhtml-frameset': cls.XHTML_FRAMESET,
663
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
160 'svg': cls.SVG, 'svg-full': cls.SVG_FULL,
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
161 'svg-basic': cls.SVG_BASIC,
c50d2705016e Add SVG DTDs to `DocType` class. Closes #161.
cmlenz
parents: 658
diff changeset
162 'svg-tiny': cls.SVG_TINY
464
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
163 }.get(name.lower())
2f13c5fc4a4d Move the mapping of doctype names to tuples out of the plugin into the `DocType` class.
cmlenz
parents: 462
diff changeset
164 get = classmethod(get)
448
1154f2aadb6c Add support for HTML5 doctype.
cmlenz
parents: 437
diff changeset
165
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
166
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
167 class XMLSerializer(object):
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
168 """Produces XML text from an event stream.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
169
230
84168828b074 Renamed Markup to Genshi in repository.
cmlenz
parents: 219
diff changeset
170 >>> from genshi.builder import tag
20
cc92d74ce9e5 Fix tests broken in [20].
cmlenz
parents: 19
diff changeset
171 >>> elem = tag.div(tag.a(href='foo'), tag.br, tag.hr(noshade=True))
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
172 >>> print ''.join(XMLSerializer()(elem.generate()))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
173 <div><a href="foo"/><br/><hr noshade="True"/></div>
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
174 """
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
175
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
176 _PRESERVE_SPACE = frozenset()
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
177
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
178 def __init__(self, doctype=None, strip_whitespace=True,
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
179 namespace_prefixes=None):
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
180 """Initialize the XML serializer.
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
181
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
182 :param doctype: a ``(name, pubid, sysid)`` tuple that represents the
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
183 DOCTYPE declaration that should be included at the top
494
942d73ba938c The `doctype` parameter for serializers can now be a string.
cmlenz
parents: 464
diff changeset
184 of the generated output, or the name of a DOCTYPE as
942d73ba938c The `doctype` parameter for serializers can now be a string.
cmlenz
parents: 464
diff changeset
185 defined in `DocType.get`
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
186 :param strip_whitespace: whether extraneous whitespace should be
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
187 stripped from the output
494
942d73ba938c The `doctype` parameter for serializers can now be a string.
cmlenz
parents: 464
diff changeset
188 :note: Changed in 0.4.2: The `doctype` parameter can now be a string.
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
189 """
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
190 self.filters = [EmptyTagFilter()]
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
191 if strip_whitespace:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
192 self.filters.append(WhitespaceFilter(self._PRESERVE_SPACE))
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
193 self.filters.append(NamespaceFlattener(prefixes=namespace_prefixes))
671
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
194 if doctype:
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
195 self.filters.append(DocTypeInserter(doctype))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
196
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
197 def __call__(self, stream):
460
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
198 have_decl = have_doctype = False
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
199 in_cdata = False
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
200
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
201 for filter_ in self.filters:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
202 stream = filter_(stream)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
203 for kind, data, pos in stream:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
204
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
205 if kind is START or kind is EMPTY:
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
206 tag, attrib = data
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
207 buf = ['<', tag]
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
208 for attr, value in attrib:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
209 buf += [' ', attr, '="', escape(value), '"']
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
210 buf.append(kind is EMPTY and '/>' or '>')
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
211 yield Markup(u''.join(buf))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
212
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
213 elif kind is END:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
214 yield Markup('</%s>' % data)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
215
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
216 elif kind is TEXT:
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
217 if in_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
218 yield data
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
219 else:
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
220 yield escape(data, quotes=False)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
221
89
80386d62814f Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents: 85
diff changeset
222 elif kind is COMMENT:
80386d62814f Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents: 85
diff changeset
223 yield Markup('<!--%s-->' % data)
80386d62814f Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents: 85
diff changeset
224
460
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
225 elif kind is XML_DECL and not have_decl:
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
226 version, encoding, standalone = data
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
227 buf = ['<?xml version="%s"' % version]
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
228 if encoding:
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
229 buf.append(' encoding="%s"' % encoding)
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
230 if standalone != -1:
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
231 standalone = standalone and 'yes' or 'no'
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
232 buf.append(' standalone="%s"' % standalone)
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
233 buf.append('?>\n')
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
234 yield Markup(u''.join(buf))
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
235 have_decl = True
75425671b437 Apply patch by Alec Thomas for processing XML declarations (#111). Thanks!
cmlenz
parents: 448
diff changeset
236
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
237 elif kind is DOCTYPE and not have_doctype:
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
238 name, pubid, sysid = data
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
239 buf = ['<!DOCTYPE %s']
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
240 if pubid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
241 buf.append(' PUBLIC "%s"')
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
242 elif sysid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
243 buf.append(' SYSTEM')
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
244 if sysid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
245 buf.append(' "%s"')
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
246 buf.append('>\n')
713
5420fe9d99a9 The `Markup` class now supports mappings for right hand of the `%` (modulo) operator in the same way the Python string classes do, except that the substituted values are escape. Also, the special constructor which took positional arguments that would be substituted was removed. Thus the `Markup` class now supports the same arguments as that of its `unicode` base class. Closes #211. Many thanks to Christian Boos for the patch!
cmlenz
parents: 689
diff changeset
247 yield Markup(u''.join(buf)) % filter(None, data)
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
248 have_doctype = True
109
230ee6a2c6b2 Reorder the conditional branches in the serializers so that the more common event kinds are on top.
cmlenz
parents: 105
diff changeset
249
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
250 elif kind is 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
251 yield Markup('<![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
252 in_cdata = True
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
253
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
254 elif kind is END_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
255 yield Markup(']]>')
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
256 in_cdata = False
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
257
105
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
258 elif kind is PI:
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
259 yield Markup('<?%s %s?>' % data)
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
260
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
261
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
262 class XHTMLSerializer(XMLSerializer):
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
263 """Produces XHTML text from an event stream.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
264
230
84168828b074 Renamed Markup to Genshi in repository.
cmlenz
parents: 219
diff changeset
265 >>> from genshi.builder import tag
20
cc92d74ce9e5 Fix tests broken in [20].
cmlenz
parents: 19
diff changeset
266 >>> elem = tag.div(tag.a(href='foo'), tag.br, tag.hr(noshade=True))
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
267 >>> print ''.join(XHTMLSerializer()(elem.generate()))
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
268 <div><a href="foo"></a><br /><hr noshade="noshade" /></div>
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
269 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
270
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
271 _EMPTY_ELEMS = frozenset(['area', 'base', 'basefont', 'br', 'col', 'frame',
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
272 'hr', 'img', 'input', 'isindex', 'link', 'meta',
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
273 'param'])
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
274 _BOOLEAN_ATTRS = frozenset(['selected', 'checked', 'compact', 'declare',
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
275 'defer', 'disabled', 'ismap', 'multiple',
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
276 'nohref', 'noresize', 'noshade', 'nowrap'])
346
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
277 _PRESERVE_SPACE = frozenset([
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
278 QName('pre'), QName('http://www.w3.org/1999/xhtml}pre'),
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
279 QName('textarea'), QName('http://www.w3.org/1999/xhtml}textarea')
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
280 ])
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
281
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
282 def __init__(self, doctype=None, strip_whitespace=True,
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
283 namespace_prefixes=None):
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
284 super(XHTMLSerializer, self).__init__(doctype, False)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
285 self.filters = [EmptyTagFilter()]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
286 if strip_whitespace:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
287 self.filters.append(WhitespaceFilter(self._PRESERVE_SPACE))
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
288 namespace_prefixes = namespace_prefixes or {}
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
289 namespace_prefixes['http://www.w3.org/1999/xhtml'] = ''
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
290 self.filters.append(NamespaceFlattener(prefixes=namespace_prefixes))
671
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
291 if doctype:
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
292 self.filters.append(DocTypeInserter(doctype))
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
293
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
294 def __call__(self, stream):
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
295 boolean_attrs = self._BOOLEAN_ATTRS
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
296 empty_elems = self._EMPTY_ELEMS
85
4938c310d904 Improve handling of DOCTYPE declarations.
cmlenz
parents: 73
diff changeset
297 have_doctype = False
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
298 in_cdata = False
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
299
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
300 for filter_ in self.filters:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
301 stream = filter_(stream)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
302 for kind, data, pos in stream:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
303
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
304 if kind is START or kind is EMPTY:
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
305 tag, attrib = data
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
306 buf = ['<', tag]
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
307 for attr, value in attrib:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
308 if attr in boolean_attrs:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
309 value = attr
524
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
310 elif attr == u'xml:lang' and u'lang' not in attrib:
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
311 buf += [' lang="', escape(value), '"']
689
3881a602048a The XHTML serializer now strips `xml:space` attributes as they are only allowed on very few tags.
cmlenz
parents: 688
diff changeset
312 elif attr == u'xml:space':
3881a602048a The XHTML serializer now strips `xml:space` attributes as they are only allowed on very few tags.
cmlenz
parents: 688
diff changeset
313 continue
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
314 buf += [' ', attr, '="', escape(value), '"']
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
315 if kind is EMPTY:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
316 if tag in empty_elems:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
317 buf.append(' />')
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
318 else:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
319 buf.append('></%s>' % tag)
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
320 else:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
321 buf.append('>')
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
322 yield Markup(u''.join(buf))
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
323
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
324 elif kind is END:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
325 yield Markup('</%s>' % data)
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
326
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
327 elif kind is TEXT:
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
328 if in_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
329 yield data
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
330 else:
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
331 yield escape(data, quotes=False)
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
332
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
333 elif kind is COMMENT:
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
334 yield Markup('<!--%s-->' % data)
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
335
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
336 elif kind is DOCTYPE and not have_doctype:
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
337 name, pubid, sysid = data
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
338 buf = ['<!DOCTYPE %s']
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
339 if pubid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
340 buf.append(' PUBLIC "%s"')
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
341 elif sysid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
342 buf.append(' SYSTEM')
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
343 if sysid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
344 buf.append(' "%s"')
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
345 buf.append('>\n')
713
5420fe9d99a9 The `Markup` class now supports mappings for right hand of the `%` (modulo) operator in the same way the Python string classes do, except that the substituted values are escape. Also, the special constructor which took positional arguments that would be substituted was removed. Thus the `Markup` class now supports the same arguments as that of its `unicode` base class. Closes #211. Many thanks to Christian Boos for the patch!
cmlenz
parents: 689
diff changeset
346 yield Markup(u''.join(buf)) % filter(None, data)
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
347 have_doctype = True
109
230ee6a2c6b2 Reorder the conditional branches in the serializers so that the more common event kinds are on top.
cmlenz
parents: 105
diff changeset
348
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
349 elif kind is 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
350 yield Markup('<![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
351 in_cdata = True
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
352
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
353 elif kind is END_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
354 yield Markup(']]>')
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
355 in_cdata = False
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
356
105
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
357 elif kind is PI:
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
358 yield Markup('<?%s %s?>' % data)
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
359
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
360
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
361 class HTMLSerializer(XHTMLSerializer):
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
362 """Produces HTML text from an event stream.
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
363
230
84168828b074 Renamed Markup to Genshi in repository.
cmlenz
parents: 219
diff changeset
364 >>> from genshi.builder import tag
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
365 >>> elem = tag.div(tag.a(href='foo'), tag.br, tag.hr(noshade=True))
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
366 >>> print ''.join(HTMLSerializer()(elem.generate()))
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
367 <div><a href="foo"></a><br><hr noshade></div>
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
368 """
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
369
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
370 _NOESCAPE_ELEMS = frozenset([
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
371 QName('script'), QName('http://www.w3.org/1999/xhtml}script'),
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
372 QName('style'), QName('http://www.w3.org/1999/xhtml}style')
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
373 ])
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
374
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
375 def __init__(self, doctype=None, strip_whitespace=True):
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
376 """Initialize the HTML serializer.
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
377
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
378 :param doctype: a ``(name, pubid, sysid)`` tuple that represents the
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
379 DOCTYPE declaration that should be included at the top
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
380 of the generated output
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
381 :param strip_whitespace: whether extraneous whitespace should be
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
382 stripped from the output
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
383 """
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
384 super(HTMLSerializer, self).__init__(doctype, False)
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
385 self.filters = [EmptyTagFilter()]
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
386 if strip_whitespace:
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
387 self.filters.append(WhitespaceFilter(self._PRESERVE_SPACE,
305
60111a041e7c Various performance-oriented tweaks.
cmlenz
parents: 280
diff changeset
388 self._NOESCAPE_ELEMS))
524
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
389 self.filters.append(NamespaceFlattener(prefixes={
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
390 'http://www.w3.org/1999/xhtml': ''
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
391 }))
671
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
392 if doctype:
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
393 self.filters.append(DocTypeInserter(doctype))
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
394
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
395 def __call__(self, stream):
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
396 boolean_attrs = self._BOOLEAN_ATTRS
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
397 empty_elems = self._EMPTY_ELEMS
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
398 noescape_elems = self._NOESCAPE_ELEMS
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
399 have_doctype = False
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
400 noescape = False
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
401
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
402 for filter_ in self.filters:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
403 stream = filter_(stream)
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
404 for kind, data, pos in stream:
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
405
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
406 if kind is START or kind is EMPTY:
96
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module.
cmlenz
parents: 89
diff changeset
407 tag, attrib = data
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
408 buf = ['<', tag]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
409 for attr, value in attrib:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
410 if attr in boolean_attrs:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
411 if value:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
412 buf += [' ', attr]
524
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
413 elif ':' in attr:
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
414 if attr == 'xml:lang' and u'lang' not in attrib:
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
415 buf += [' lang="', escape(value), '"']
7553760b58af Add special handling for `xml:lang` to HTML/XHTML serialization.
cmlenz
parents: 494
diff changeset
416 elif attr != 'xmlns':
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
417 buf += [' ', attr, '="', escape(value), '"']
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
418 buf.append('>')
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
419 if kind is EMPTY:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
420 if tag not in empty_elems:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
421 buf.append('</%s>' % tag)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
422 yield Markup(u''.join(buf))
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
423 if tag in noescape_elems:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
424 noescape = True
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
425
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
426 elif kind is END:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
427 yield Markup('</%s>' % data)
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
428 noescape = False
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
429
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
430 elif kind is TEXT:
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
431 if noescape:
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
432 yield data
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
433 else:
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
434 yield escape(data, quotes=False)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
435
89
80386d62814f Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents: 85
diff changeset
436 elif kind is COMMENT:
80386d62814f Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents: 85
diff changeset
437 yield Markup('<!--%s-->' % data)
80386d62814f Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents: 85
diff changeset
438
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
439 elif kind is DOCTYPE and not have_doctype:
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
440 name, pubid, sysid = data
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
441 buf = ['<!DOCTYPE %s']
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
442 if pubid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
443 buf.append(' PUBLIC "%s"')
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
444 elif sysid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
445 buf.append(' SYSTEM')
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
446 if sysid:
397
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
447 buf.append(' "%s"')
31742fe6d47e * Moved some utility functions from `genshi.core` to `genshi.util` (backwards compatibility preserved via imports)
cmlenz
parents: 346
diff changeset
448 buf.append('>\n')
713
5420fe9d99a9 The `Markup` class now supports mappings for right hand of the `%` (modulo) operator in the same way the Python string classes do, except that the substituted values are escape. Also, the special constructor which took positional arguments that would be substituted was removed. Thus the `Markup` class now supports the same arguments as that of its `unicode` base class. Closes #211. Many thanks to Christian Boos for the patch!
cmlenz
parents: 689
diff changeset
449 yield Markup(u''.join(buf)) % filter(None, data)
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
450 have_doctype = True
109
230ee6a2c6b2 Reorder the conditional branches in the serializers so that the more common event kinds are on top.
cmlenz
parents: 105
diff changeset
451
105
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
452 elif kind is PI:
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
453 yield Markup('<?%s %s?>' % data)
71f3db26eecb Include processing instructions in serialized streams.
cmlenz
parents: 96
diff changeset
454
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
455
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
456 class TextSerializer(object):
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
457 """Produces plain text from an event stream.
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
458
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
459 Only text events are included in the output. Unlike the other serializer,
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
460 special XML characters are not escaped:
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
461
230
84168828b074 Renamed Markup to Genshi in repository.
cmlenz
parents: 219
diff changeset
462 >>> from genshi.builder import tag
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
463 >>> elem = tag.div(tag.a('<Hello!>', href='foo'), tag.br)
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
464 >>> print elem
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
465 <div><a href="foo">&lt;Hello!&gt;</a><br/></div>
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
466 >>> print ''.join(TextSerializer()(elem.generate()))
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
467 <Hello!>
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
468
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
469 If text events contain literal markup (instances of the `Markup` class),
658
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
470 that markup is by default passed through unchanged:
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
471
658
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
472 >>> elem = tag.div(Markup('<a href="foo">Hello &amp; Bye!</a><br/>'))
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
473 >>> print elem.generate().render(TextSerializer)
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
474 <a href="foo">Hello &amp; Bye!</a><br/>
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
475
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
476 You can use the `strip_markup` to change this behavior, so that tags and
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
477 entities are stripped from the output (or in the case of entities,
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
478 replaced with the equivalent character):
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
479
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
480 >>> print elem.generate().render(TextSerializer, strip_markup=True)
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
481 Hello & Bye!
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
482 """
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
483
658
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
484 def __init__(self, strip_markup=False):
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
485 self.strip_markup = strip_markup
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
486
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
487 def __call__(self, stream):
658
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
488 strip_markup = self.strip_markup
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
489 for event in stream:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
490 if event[0] is TEXT:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
491 data = event[1]
658
5df08e5195b8 The `TextSerializer` class no longer strips all markup in text by default, so that it is still possible to use the Genshi `escape` function even with text templates. The old behavior is available via the `strip_markup` option of the serializer. Closes #146.
cmlenz
parents: 524
diff changeset
492 if strip_markup and type(data) is Markup:
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
493 data = data.striptags().stripentities()
201
c5e0a1c86173 The `TextSerializer` should produce `unicode` objects, not `Markup` objects.
cmlenz
parents: 200
diff changeset
494 yield unicode(data)
200
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
495
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41.
cmlenz
parents: 178
diff changeset
496
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
497 class EmptyTagFilter(object):
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
498 """Combines `START` and `STOP` events into `EMPTY` events for elements that
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
499 have no contents.
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
500 """
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
501
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
502 EMPTY = StreamEventKind('EMPTY')
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
503
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
504 def __call__(self, stream):
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
505 prev = (None, None, None)
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
506 for ev in stream:
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
507 if prev[0] is START:
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
508 if ev[0] is END:
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
509 prev = EMPTY, prev[1], prev[2]
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
510 yield prev
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
511 continue
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
512 else:
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
513 yield prev
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
514 if ev[0] is not START:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
515 yield ev
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
516 prev = ev
212
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
517
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
518
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
519 EMPTY = EmptyTagFilter.EMPTY
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
520
0141f45c18e1 Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents: 201
diff changeset
521
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
522 class NamespaceFlattener(object):
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
523 r"""Output stream filter that removes namespace information from the stream,
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
524 instead adding namespace attributes and prefixes as needed.
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
525
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
526 :param prefixes: optional mapping of namespace URIs to prefixes
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
527
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
528 >>> from genshi.input import XML
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
529 >>> xml = XML('''<doc xmlns="NS1" xmlns:two="NS2">
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
530 ... <two:item/>
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
531 ... </doc>''')
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
532 >>> for kind, data, pos in NamespaceFlattener()(xml):
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
533 ... print kind, repr(data)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
534 START (u'doc', Attrs([(u'xmlns', u'NS1'), (u'xmlns:two', u'NS2')]))
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
535 TEXT u'\n '
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
536 START (u'two:item', Attrs())
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
537 END u'two:item'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
538 TEXT u'\n'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
539 END u'doc'
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
540 """
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
541
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
542 def __init__(self, prefixes=None):
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
543 self.prefixes = {XML_NAMESPACE.uri: 'xml'}
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
544 if prefixes is not None:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
545 self.prefixes.update(prefixes)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
546
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
547 def __call__(self, stream):
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
548 prefixes = dict([(v, [k]) for k, v in self.prefixes.items()])
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
549 namespaces = {XML_NAMESPACE.uri: ['xml']}
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
550 def _push_ns(prefix, uri):
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
551 namespaces.setdefault(uri, []).append(prefix)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
552 prefixes.setdefault(prefix, []).append(uri)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
553
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
554 ns_attrs = []
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
555 _push_ns_attr = ns_attrs.append
437
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
556 def _make_ns_attr(prefix, uri):
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
557 return u'xmlns%s' % (prefix and ':%s' % prefix or ''), uri
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
558
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
559 def _gen_prefix():
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
560 val = 0
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
561 while 1:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
562 val += 1
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
563 yield 'ns%d' % val
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
564 _gen_prefix = _gen_prefix().next
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
565
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
566 for kind, data, pos in stream:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
567
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
568 if kind is START or kind is EMPTY:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
569 tag, attrs = data
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
570
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
571 tagname = tag.localname
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
572 tagns = tag.namespace
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
573 if tagns:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
574 if tagns in namespaces:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
575 prefix = namespaces[tagns][-1]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
576 if prefix:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
577 tagname = u'%s:%s' % (prefix, tagname)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
578 else:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
579 _push_ns_attr((u'xmlns', tagns))
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
580 _push_ns('', tagns)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
581
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
582 new_attrs = []
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
583 for attr, value in attrs:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
584 attrname = attr.localname
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
585 attrns = attr.namespace
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
586 if attrns:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
587 if attrns not in namespaces:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
588 prefix = _gen_prefix()
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
589 _push_ns(prefix, attrns)
412
bd51adc20a67 Actually write xmlns declaratons for generated attribute namespace prefixes.
cmlenz
parents: 410
diff changeset
590 _push_ns_attr(('xmlns:%s' % prefix, attrns))
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
591 else:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
592 prefix = namespaces[attrns][-1]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
593 if prefix:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
594 attrname = u'%s:%s' % (prefix, attrname)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
595 new_attrs.append((attrname, value))
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
596
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
597 yield kind, (tagname, Attrs(ns_attrs + new_attrs)), pos
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
598 del ns_attrs[:]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
599
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
600 elif kind is END:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
601 tagname = data.localname
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
602 tagns = data.namespace
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
603 if tagns:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
604 prefix = namespaces[tagns][-1]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
605 if prefix:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
606 tagname = u'%s:%s' % (prefix, tagname)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
607 yield kind, tagname, pos
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
608
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
609 elif kind is START_NS:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
610 prefix, uri = data
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
611 if uri not in namespaces:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
612 prefix = prefixes.get(uri, [prefix])[-1]
437
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
613 _push_ns_attr(_make_ns_attr(prefix, uri))
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
614 _push_ns(prefix, uri)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
615
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
616 elif kind is END_NS:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
617 if data in prefixes:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
618 uris = prefixes.get(data)
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
619 uri = uris.pop()
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
620 if not uris:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
621 del prefixes[data]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
622 if uri not in uris or uri != uris[-1]:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
623 uri_prefixes = namespaces[uri]
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
624 uri_prefixes.pop()
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
625 if not uri_prefixes:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
626 del namespaces[uri]
437
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
627 if ns_attrs:
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
628 attr = _make_ns_attr(data, uri)
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
629 if attr in ns_attrs:
821fc97d3c0a Fix for #107.
cmlenz
parents: 425
diff changeset
630 ns_attrs.remove(attr)
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
631
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
632 else:
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
633 yield kind, data, pos
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
634
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
635
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
636 class WhitespaceFilter(object):
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
637 """A filter that removes extraneous ignorable white space from the
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
638 stream.
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
639 """
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
640
305
60111a041e7c Various performance-oriented tweaks.
cmlenz
parents: 280
diff changeset
641 def __init__(self, preserve=None, noescape=None):
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
642 """Initialize the filter.
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
643
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
644 :param preserve: a set or sequence of tag names for which white-space
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
645 should be preserved
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
646 :param noescape: a set or sequence of tag names for which text content
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
647 should not be escaped
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
648
346
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
649 The `noescape` set is expected to refer to elements that cannot contain
425
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
650 further child elements (such as ``<style>`` or ``<script>`` in HTML
073640758a42 Try to use proper reStructuredText for docstrings throughout.
cmlenz
parents: 412
diff changeset
651 documents).
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
652 """
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
653 if preserve is None:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
654 preserve = []
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
655 self.preserve = frozenset(preserve)
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
656 if noescape is None:
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
657 noescape = []
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
658 self.noescape = frozenset(noescape)
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
659
219
ebceef564b79 Minor improvements to `WhitespaceFilter`.
cmlenz
parents: 213
diff changeset
660 def __call__(self, stream, ctxt=None, space=XML_NAMESPACE['space'],
ebceef564b79 Minor improvements to `WhitespaceFilter`.
cmlenz
parents: 213
diff changeset
661 trim_trailing_space=re.compile('[ \t]+(?=\n)').sub,
ebceef564b79 Minor improvements to `WhitespaceFilter`.
cmlenz
parents: 213
diff changeset
662 collapse_lines=re.compile('\n{2,}').sub):
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
663 mjoin = Markup('').join
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
664 preserve_elems = self.preserve
346
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
665 preserve = 0
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
666 noescape_elems = self.noescape
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
667 noescape = False
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
668
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
669 textbuf = []
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
670 push_text = textbuf.append
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
671 pop_text = textbuf.pop
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
672 for kind, data, pos in chain(stream, [(None, None, None)]):
410
d14d89995c29 Improve the handling of namespaces in serialization.
cmlenz
parents: 408
diff changeset
673
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
674 if kind is TEXT:
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
675 if noescape:
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
676 data = Markup(data)
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
677 push_text(data)
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
678 else:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
679 if textbuf:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
680 if len(textbuf) > 1:
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
681 text = mjoin(textbuf, escape_quotes=False)
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
682 del textbuf[:]
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
683 else:
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
684 text = escape(pop_text(), quotes=False)
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
685 if not preserve:
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
686 text = collapse_lines('\n', trim_trailing_space('', text))
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
687 yield TEXT, Markup(text), pos
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
688
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
689 if kind is START:
346
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
690 tag, attrs = data
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
691 if preserve or (tag in preserve_elems or
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
692 attrs.get(space) == 'preserve'):
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
693 preserve += 1
219
ebceef564b79 Minor improvements to `WhitespaceFilter`.
cmlenz
parents: 213
diff changeset
694 if not noescape and tag in noescape_elems:
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
695 noescape = True
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
696
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
697 elif kind is END:
346
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
698 noescape = False
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
699 if preserve:
96882a191686 Whitespace was not getting preserved in HTML `<pre>` elements that contained other HTML elements.
cmlenz
parents: 345
diff changeset
700 preserve -= 1
141
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents: 140
diff changeset
701
305
60111a041e7c Various performance-oriented tweaks.
cmlenz
parents: 280
diff changeset
702 elif kind is START_CDATA:
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
703 noescape = True
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
704
305
60111a041e7c Various performance-oriented tweaks.
cmlenz
parents: 280
diff changeset
705 elif kind is END_CDATA:
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
706 noescape = False
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
707
136
b86f496f6035 Minor performance improvements in serialization.
cmlenz
parents: 123
diff changeset
708 if kind:
123
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents: 109
diff changeset
709 yield kind, data, pos
671
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
710
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
711
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
712 class DocTypeInserter(object):
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
713 """A filter that inserts the DOCTYPE declaration in the correct location,
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
714 after the XML declaration.
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
715 """
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
716 def __init__(self, doctype):
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
717 """Initialize the filter.
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
718
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
719 :param doctype: DOCTYPE as a string or DocType object.
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
720 """
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
721 if isinstance(doctype, basestring):
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
722 doctype = DocType.get(doctype)
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
723 self.doctype_event = (DOCTYPE, doctype, (None, -1, -1))
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
724
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
725 def __call__(self, stream):
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
726 doctype_inserted = False
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
727 for kind, data, pos in stream:
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
728 if not doctype_inserted:
672
571226acaeff XML_DECL must be the absolute first item, so don't bother buffering whitespace.
athomas
parents: 671
diff changeset
729 doctype_inserted = True
571226acaeff XML_DECL must be the absolute first item, so don't bother buffering whitespace.
athomas
parents: 671
diff changeset
730 if kind is XML_DECL:
571226acaeff XML_DECL must be the absolute first item, so don't bother buffering whitespace.
athomas
parents: 671
diff changeset
731 yield (kind, data, pos)
571226acaeff XML_DECL must be the absolute first item, so don't bother buffering whitespace.
athomas
parents: 671
diff changeset
732 yield self.doctype_event
671
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
733 continue
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
734 yield self.doctype_event
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
735
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
736 yield (kind, data, pos)
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
737
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
738 if not doctype_inserted:
8a9a7a8e9478 Add a stream filter to insert the XML DOCTYPE in the correct location (ie.
athomas
parents: 669
diff changeset
739 yield self.doctype_event
Copyright (C) 2012-2017 Edgewall Software