genshi/mirror: genshi/core.py annotate

annotate genshi/core.py @ 382:2682dabbcd04 trunk

* Added documentation for the various stream event kinds. * Move generation of HTML documentation into a custom distutils command, run by `setup.py build_doc` * Added verification of doctest snippets in documentation, which can be run by `setup.py test_doc` * Fixed `repr` of `Markup` instances.

author	cmlenz
date	Fri, 01 Dec 2006 23:43:59 +0000
parents	9aa6aa18fa35
children	31742fe6d47e

rev	line source
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
5479aae32f5a Initial import. cmlenz parents: diff changeset	2 #
66 59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 54 diff changeset	3 # Copyright (C) 2006 Edgewall Software
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	4 # All rights reserved.
5479aae32f5a Initial import. cmlenz parents: diff changeset	5 #
5479aae32f5a Initial import. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
5479aae32f5a Initial import. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
230 84168828b074 Renamed Markup to Genshi in repository. cmlenz parents: 224 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: 224 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 """Core classes for markup processing."""
5479aae32f5a Initial import. cmlenz parents: diff changeset	15
5479aae32f5a Initial import. cmlenz parents: diff changeset	16 import htmlentitydefs
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	17 import operator
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	18 import re
5479aae32f5a Initial import. cmlenz parents: diff changeset	19
377 9aa6aa18fa35 Add `Attrs` class to `genshi.core.__all__`, so that it can be imported directly from the `genshi` package. cmlenz parents: 345 diff changeset	20 __all__ = ['Stream', 'Markup', 'escape', 'unescape', 'Attrs', 'Namespace',
9aa6aa18fa35 Add `Attrs` class to `genshi.core.__all__`, so that it can be imported directly from the `genshi` package. cmlenz parents: 345 diff changeset	21 'QName']
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	22
5479aae32f5a Initial import. cmlenz parents: diff changeset	23
17 74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	24 class StreamEventKind(str):
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	25 """A kind of event on an XML stream."""
279 a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	26 __slots__ = []
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	27 _instances = {}
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	28
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	29 def __new__(cls, val):
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	30 return cls._instances.setdefault(val, str.__new__(cls, val))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	31
5479aae32f5a Initial import. cmlenz parents: diff changeset	32
5479aae32f5a Initial import. cmlenz parents: diff changeset	33 class Stream(object):
5479aae32f5a Initial import. cmlenz parents: diff changeset	34 """Represents a stream of markup events.
5479aae32f5a Initial import. cmlenz parents: diff changeset	35
5479aae32f5a Initial import. cmlenz parents: diff changeset	36 This class is basically an iterator over the events.
5479aae32f5a Initial import. cmlenz parents: diff changeset	37
5479aae32f5a Initial import. cmlenz parents: diff changeset	38 Also provided are ways to serialize the stream to text. The `serialize()`
5479aae32f5a Initial import. cmlenz parents: diff changeset	39 method will return an iterator over generated strings, while `render()`
5479aae32f5a Initial import. cmlenz parents: diff changeset	40 returns the complete generated text at once. Both accept various parameters
5479aae32f5a Initial import. cmlenz parents: diff changeset	41 that impact the way the stream is serialized.
5479aae32f5a Initial import. cmlenz parents: diff changeset	42
5479aae32f5a Initial import. cmlenz parents: diff changeset	43 Stream events are tuples of the form:
5479aae32f5a Initial import. cmlenz parents: diff changeset	44
5479aae32f5a Initial import. cmlenz parents: diff changeset	45 (kind, data, position)
5479aae32f5a Initial import. cmlenz parents: diff changeset	46
5479aae32f5a Initial import. cmlenz parents: diff changeset	47 where `kind` is the event kind (such as `START`, `END`, `TEXT`, etc), `data`
172 ff4f0d89eef7 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 171 diff changeset	48 depends on the kind of event, and `position` is a `(filename, line, offset)`
ff4f0d89eef7 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 171 diff changeset	49 tuple that contains the location of the original element or text in the
ff4f0d89eef7 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 171 diff changeset	50 input. If the original location is unknown, `position` is `(None, -1, -1)`.
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	51 """
5479aae32f5a Initial import. cmlenz parents: diff changeset	52 __slots__ = ['events']
5479aae32f5a Initial import. cmlenz parents: diff changeset	53
17 74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	54 START = StreamEventKind('START') # a start tag
74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	55 END = StreamEventKind('END') # an end tag
74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	56 TEXT = StreamEventKind('TEXT') # literal text
74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	57 DOCTYPE = StreamEventKind('DOCTYPE') # doctype declaration
143 3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	58 START_NS = StreamEventKind('START_NS') # start namespace mapping
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	59 END_NS = StreamEventKind('END_NS') # end namespace mapping
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	60 START_CDATA = StreamEventKind('START_CDATA') # start CDATA section
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	61 END_CDATA = StreamEventKind('END_CDATA') # end CDATA section
17 74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	62 PI = StreamEventKind('PI') # processing instruction
74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	63 COMMENT = StreamEventKind('COMMENT') # comment
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	64
5479aae32f5a Initial import. cmlenz parents: diff changeset	65 def __init__(self, events):
5479aae32f5a Initial import. cmlenz parents: diff changeset	66 """Initialize the stream with a sequence of markup events.
5479aae32f5a Initial import. cmlenz parents: diff changeset	67
27 b4f78c05e5c9 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	68 @param events: a sequence or iterable providing the events
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	69 """
5479aae32f5a Initial import. cmlenz parents: diff changeset	70 self.events = events
5479aae32f5a Initial import. cmlenz parents: diff changeset	71
5479aae32f5a Initial import. cmlenz parents: diff changeset	72 def __iter__(self):
5479aae32f5a Initial import. cmlenz parents: diff changeset	73 return iter(self.events)
5479aae32f5a Initial import. cmlenz parents: diff changeset	74
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	75 def __or__(self, function):
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	76 """Override the "bitwise or" operator to apply filters or serializers
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	77 to the stream, providing a syntax similar to pipes on Unix shells.
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	78
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	79 Assume the following stream produced by the `HTML` function:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	80
230 84168828b074 Renamed Markup to Genshi in repository. cmlenz parents: 224 diff changeset	81 >>> from genshi.input import HTML
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	82 >>> html = HTML('''<p onclick="alert('Whoa')">Hello, world!</p>''')
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	83 >>> print html
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	84 <p onclick="alert('Whoa')">Hello, world!</p>
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	85
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	86 A filter such as the HTML sanitizer can be applied to that stream using
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	87 the pipe notation as follows:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	88
230 84168828b074 Renamed Markup to Genshi in repository. cmlenz parents: 224 diff changeset	89 >>> from genshi.filters import HTMLSanitizer
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	90 >>> sanitizer = HTMLSanitizer()
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	91 >>> print html \| sanitizer
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	92 <p>Hello, world!</p>
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	93
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	94 Filters can be any function that accepts and produces a stream (where
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	95 a stream is anything that iterators over events):
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	96
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	97 >>> def uppercase(stream):
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	98 ... for kind, data, pos in stream:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	99 ... if kind is TEXT:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	100 ... data = data.upper()
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	101 ... yield kind, data, pos
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	102 >>> print html \| sanitizer \| uppercase
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	103 <p>HELLO, WORLD!</p>
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	104
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	105 Serializers can also be used with this notation:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	106
230 84168828b074 Renamed Markup to Genshi in repository. cmlenz parents: 224 diff changeset	107 >>> from genshi.output import TextSerializer
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	108 >>> output = TextSerializer()
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	109 >>> print html \| sanitizer \| uppercase \| output
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	110 HELLO, WORLD!
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	111
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	112 Commonly, serializers should be used at the end of the "pipeline";
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	113 using them somewhere in the middle may produce unexpected results.
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	114 """
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	115 return Stream(_ensure(function(self)))
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	116
123 10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	117 def filter(self, *filters):
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	118 """Apply filters to the stream.
113 d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	119
123 10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	120 This method returns a new stream with the given filters applied. The
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	121 filters must be callables that accept the stream object as parameter,
10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	122 and return the filtered stream.
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	123
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	124 The call:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	125
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	126 stream.filter(filter1, filter2)
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	127
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	128 is equivalent to:
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	129
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	130 stream \| filter1 \| filter2
113 d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	131 """
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	132 return reduce(operator.or_, (self,) + filters)
113 d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	133
123 10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	134 def render(self, method='xml', encoding='utf-8', **kwargs):
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	135 """Return a string representation of the stream.
5479aae32f5a Initial import. cmlenz parents: diff changeset	136
5479aae32f5a Initial import. cmlenz parents: diff changeset	137 @param method: determines how the stream is serialized; can be either
200 5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	138 "xml", "xhtml", "html", "text", or a custom serializer
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	139 class
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	140 @param encoding: how the output string should be encoded; if set to
5479aae32f5a Initial import. cmlenz parents: diff changeset	141 `None`, this method returns a `unicode` object
5479aae32f5a Initial import. cmlenz parents: diff changeset	142
5479aae32f5a Initial import. cmlenz parents: diff changeset	143 Any additional keyword arguments are passed to the serializer, and thus
5479aae32f5a Initial import. cmlenz parents: diff changeset	144 depend on the `method` parameter value.
5479aae32f5a Initial import. cmlenz parents: diff changeset	145 """
123 10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	146 generator = self.serialize(method=method, **kwargs)
17 74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	147 output = u''.join(list(generator))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	148 if encoding is not None:
200 5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	149 errors = 'replace'
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	150 if method != 'text':
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	151 errors = 'xmlcharrefreplace'
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	152 return output.encode(encoding, errors)
8 3710e3d0d4a2 `Stream.render()` was masking `TypeError`s (fix based on suggestion by Matt Good). cmlenz parents: 6 diff changeset	153 return output
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	154
278 d6c58473a9d0 Fix the handling of namespace context for match templates. cmlenz parents: 230 diff changeset	155 def select(self, path, namespaces=None, variables=None):
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	156 """Return a new stream that contains the events matching the given
5479aae32f5a Initial import. cmlenz parents: diff changeset	157 XPath expression.
5479aae32f5a Initial import. cmlenz parents: diff changeset	158
5479aae32f5a Initial import. cmlenz parents: diff changeset	159 @param path: a string containing the XPath expression
5479aae32f5a Initial import. cmlenz parents: diff changeset	160 """
230 84168828b074 Renamed Markup to Genshi in repository. cmlenz parents: 224 diff changeset	161 from genshi.path import Path
278 d6c58473a9d0 Fix the handling of namespace context for match templates. cmlenz parents: 230 diff changeset	162 return Path(path).select(self, namespaces, variables)
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	163
123 10279d2eeec9 Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	164 def serialize(self, method='xml', **kwargs):
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	165 """Generate strings corresponding to a specific serialization of the
5479aae32f5a Initial import. cmlenz parents: diff changeset	166 stream.
5479aae32f5a Initial import. cmlenz parents: diff changeset	167
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	168 Unlike the `render()` method, this method is a generator that returns
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	169 the serialized output incrementally, as opposed to returning a single
5479aae32f5a Initial import. cmlenz parents: diff changeset	170 string.
5479aae32f5a Initial import. cmlenz parents: diff changeset	171
5479aae32f5a Initial import. cmlenz parents: diff changeset	172 @param method: determines how the stream is serialized; can be either
200 5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	173 "xml", "xhtml", "html", "text", or a custom serializer
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	174 class
147 a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work. cmlenz parents: 145 diff changeset	175
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work. cmlenz parents: 145 diff changeset	176 Any additional keyword arguments are passed to the serializer, and thus
a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work. cmlenz parents: 145 diff changeset	177 depend on the `method` parameter value.
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	178 """
230 84168828b074 Renamed Markup to Genshi in repository. cmlenz parents: 224 diff changeset	179 from genshi import output
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	180 cls = method
5479aae32f5a Initial import. cmlenz parents: diff changeset	181 if isinstance(method, basestring):
96 fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module. cmlenz parents: 91 diff changeset	182 cls = {'xml': output.XMLSerializer,
fa08aef181a2 Add an XHTML serialization method. Now really need to get rid of some code duplication in the `markup.output` module. cmlenz parents: 91 diff changeset	183 'xhtml': output.XHTMLSerializer,
200 5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	184 'html': output.HTMLSerializer,
5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	185 'text': output.TextSerializer}[method]
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	186 return cls(**kwargs)(_ensure(self))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	187
5479aae32f5a Initial import. cmlenz parents: diff changeset	188 def __str__(self):
5479aae32f5a Initial import. cmlenz parents: diff changeset	189 return self.render()
5479aae32f5a Initial import. cmlenz parents: diff changeset	190
5479aae32f5a Initial import. cmlenz parents: diff changeset	191 def __unicode__(self):
5479aae32f5a Initial import. cmlenz parents: diff changeset	192 return self.render(encoding=None)
5479aae32f5a Initial import. cmlenz parents: diff changeset	193
5479aae32f5a Initial import. cmlenz parents: diff changeset	194
69 c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	195 START = Stream.START
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	196 END = Stream.END
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	197 TEXT = Stream.TEXT
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	198 DOCTYPE = Stream.DOCTYPE
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	199 START_NS = Stream.START_NS
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	200 END_NS = Stream.END_NS
143 3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	201 START_CDATA = Stream.START_CDATA
3d4c214c979a CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	202 END_CDATA = Stream.END_CDATA
69 c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	203 PI = Stream.PI
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	204 COMMENT = Stream.COMMENT
c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	205
111 2368c3becc52 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	206 def _ensure(stream):
2368c3becc52 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	207 """Ensure that every item on the stream is actually a markup event."""
2368c3becc52 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	208 for event in stream:
145 47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	209 if type(event) is not tuple:
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	210 if hasattr(event, 'totuple'):
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	211 event = event.totuple()
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	212 else:
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	213 event = TEXT, unicode(event), (None, -1, -1)
47bbd9d2a5af * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	214 yield event
111 2368c3becc52 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	215
69 c40a5dcd2b55 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	216
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	217 class Attrs(tuple):
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	218 """Immutable sequence type that stores the attributes of an element.
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	219
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	220 Ordering of the attributes is preserved, while accessing by name is also
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	221 supported.
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	222
182 2f30ce3fb85e Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	223 >>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	224 >>> attrs
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	225 Attrs([(QName(u'href'), '#'), (QName(u'title'), 'Foo')])
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	226
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	227 >>> 'href' in attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	228 True
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	229 >>> 'tabindex' in attrs
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	230 False
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	231 >>> attrs.get(u'title')
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	232 'Foo'
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	233
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	234 Instances may not be manipulated directly. Instead, the operators `\|` and
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	235 `-` can be used to produce new instances that have specific attributes
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	236 added, replaced or removed.
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	237
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	238 To remove an attribute, use the `-` operator. The right hand side can be
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	239 either a string or a set/sequence of strings, identifying the name(s) of
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	240 the attribute(s) to remove:
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	241
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	242 >>> attrs - 'title'
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	243 Attrs([(QName(u'href'), '#')])
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	244 >>> attrs - ('title', 'href')
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	245 Attrs()
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	246
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	247 The original instance is not modified, but the operator can of course be
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	248 used with an assignment:
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	249
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	250 >>> attrs
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	251 Attrs([(QName(u'href'), '#'), (QName(u'title'), 'Foo')])
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	252 >>> attrs -= 'title'
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	253 >>> attrs
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	254 Attrs([(QName(u'href'), '#')])
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	255
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	256 To add a new attribute, use the `\|` operator, where the right hand value
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	257 is a sequence of `(name, value)` tuples (which includes `Attrs` instances):
170 6b265e02d099 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	258
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	259 >>> attrs \| [(u'title', 'Bar')]
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	260 Attrs([(QName(u'href'), '#'), (QName(u'title'), 'Bar')])
171 7fcf8e04514e Follow-up to [214]: allow initializing `Attributes` with attribute names that contain dashes or conflict with a reserved word (such as ?class?.) cmlenz parents: 170 diff changeset	261
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	262 If the attributes already contain an attribute with a given name, the value
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	263 of that attribute is replaced:
171 7fcf8e04514e Follow-up to [214]: allow initializing `Attributes` with attribute names that contain dashes or conflict with a reserved word (such as ?class?.) cmlenz parents: 170 diff changeset	264
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	265 >>> attrs \| [(u'href', 'http://example.org/')]
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	266 Attrs([(QName(u'href'), 'http://example.org/')])
171 7fcf8e04514e Follow-up to [214]: allow initializing `Attributes` with attribute names that contain dashes or conflict with a reserved word (such as ?class?.) cmlenz parents: 170 diff changeset	267
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	268 """
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	269 __slots__ = []
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	270
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	271 def __new__(cls, items=()):
182 2f30ce3fb85e Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	272 """Create the `Attrs` instance.
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	273
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	274 If the `items` parameter is provided, it is expected to be a sequence
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	275 of `(name, value)` tuples.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	276 """
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	277 return tuple.__new__(cls, [(QName(name), val) for name, val in items])
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	278
5479aae32f5a Initial import. cmlenz parents: diff changeset	279 def __contains__(self, name):
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	280 """Return whether the list includes an attribute with the specified
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	281 name.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	282 """
133 79f445396cd7 Minor cleanup and performance improvement for the builder module. cmlenz parents: 123 diff changeset	283 for attr, _ in self:
79f445396cd7 Minor cleanup and performance improvement for the builder module. cmlenz parents: 123 diff changeset	284 if attr == name:
79f445396cd7 Minor cleanup and performance improvement for the builder module. cmlenz parents: 123 diff changeset	285 return True
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	286
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	287 def __getslice__(self, i, j):
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	288 return Attrs(tuple.__getslice__(self, i, j))
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	289
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	290 def __or__(self, attrs):
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	291 """Return a new instance that contains the attributes in `attrs` in
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	292 addition to any already existing attributes.
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	293 """
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	294 repl = dict([(an, av) for an, av in attrs if an in self])
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	295 return Attrs([(sn, repl.get(sn, sv)) for sn, sv in self] +
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	296 [(an, av) for an, av in attrs if an not in self])
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	297
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	298 def __repr__(self):
f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	299 if not self:
f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	300 return 'Attrs()'
345 2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	301 return 'Attrs([%s])' % ', '.join([repr(item) for item in self])
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	302
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	303 def __sub__(self, names):
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	304 """Return a new instance with all attributes with a name in `names` are
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	305 removed.
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	306 """
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	307 if isinstance(names, basestring):
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	308 names = (names,)
2aa7ca37ae6a Make `Attrs` instances immutable. cmlenz parents: 326 diff changeset	309 return Attrs([(name, val) for name, val in self if name not in names])
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	310
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	311 def get(self, name, default=None):
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	312 """Return the value of the attribute with the specified name, or the
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	313 value of the `default` parameter if no such attribute is found.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	314 """
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	315 for attr, value in self:
5479aae32f5a Initial import. cmlenz parents: diff changeset	316 if attr == name:
5479aae32f5a Initial import. cmlenz parents: diff changeset	317 return value
5479aae32f5a Initial import. cmlenz parents: diff changeset	318 return default
5479aae32f5a Initial import. cmlenz parents: diff changeset	319
77 f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 73 diff changeset	320 def totuple(self):
161 7b1f07496bf7 Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	321 """Return the attributes as a markup event.
7b1f07496bf7 Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	322
7b1f07496bf7 Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	323 The returned event is a TEXT event, the data is the value of all
7b1f07496bf7 Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	324 attributes joined together.
7b1f07496bf7 Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	325 """
77 f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 73 diff changeset	326 return TEXT, u''.join([x[1] for x in self]), (None, -1, -1)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 73 diff changeset	327
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	328
116 c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	329 def plaintext(text, keeplinebreaks=True):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	330 """Returns the text as a `unicode` string with all entities and tags
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	331 removed.
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	332 """
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	333 text = stripentities(striptags(text))
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	334 if not keeplinebreaks:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	335 text = text.replace(u'\n', u' ')
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	336 return text
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	337
113 d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	338 def stripentities(text, keepxmlentities=False):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	339 """Return a copy of the given text with any character or numeric entities
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	340 replaced by the equivalent UTF-8 characters.
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	341
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	342 If the `keepxmlentities` parameter is provided and evaluates to `True`,
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	343 the core XML entities (&, ', >, < and ") are not
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	344 stripped.
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	345 """
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	346 def _replace_entity(match):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	347 if match.group(1): # numeric entity
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	348 ref = match.group(1)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	349 if ref.startswith('x'):
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	350 ref = int(ref[1:], 16)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	351 else:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	352 ref = int(ref, 10)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	353 return unichr(ref)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	354 else: # character entity
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	355 ref = match.group(2)
200 5861f4446c26 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	356 if keepxmlentities and ref in ('amp', 'apos', 'gt', 'lt', 'quot'):
113 d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	357 return '&%s;' % ref
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	358 try:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	359 codepoint = htmlentitydefs.name2codepoint[ref]
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	360 return unichr(codepoint)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	361 except KeyError:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	362 if keepxmlentities:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	363 return '&%s;' % ref
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	364 else:
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	365 return ref
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	366 return re.sub(r'&(?:#((?:\d+)\|(?:[xX][0-9a-fA-F]+));?\|(\w+);)',
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	367 _replace_entity, text)
d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	368
116 c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	369 def striptags(text):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	370 """Return a copy of the text with all XML/HTML tags removed."""
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	371 return re.sub(r'<[^>]*?>', '', text)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	372
113 d10fbba1d5e0 Removed the `sanitize()` method from the `Markup` class, and migrate the existing unit tests to `markup.tests.filters`. Provide a `Stream.filter()` method instead which can be used to conveniently apply a filter to a stream. cmlenz parents: 111 diff changeset	373
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	374 class Markup(unicode):
5479aae32f5a Initial import. cmlenz parents: diff changeset	375 """Marks a string as being safe for inclusion in HTML/XML output without
5479aae32f5a Initial import. cmlenz parents: diff changeset	376 needing to be escaped.
5479aae32f5a Initial import. cmlenz parents: diff changeset	377 """
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	378 __slots__ = []
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	379
27 b4f78c05e5c9 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	380 def __new__(cls, text='', *args):
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	381 if args:
136 b86f496f6035 Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	382 text %= tuple(map(escape, args))
27 b4f78c05e5c9 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	383 return unicode.__new__(cls, text)
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	384
5479aae32f5a Initial import. cmlenz parents: diff changeset	385 def __add__(self, other):
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	386 return Markup(unicode(self) + unicode(escape(other)))
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	387
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	388 def __radd__(self, other):
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	389 return Markup(unicode(escape(other)) + unicode(self))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	390
5479aae32f5a Initial import. cmlenz parents: diff changeset	391 def __mod__(self, args):
5479aae32f5a Initial import. cmlenz parents: diff changeset	392 if not isinstance(args, (list, tuple)):
5479aae32f5a Initial import. cmlenz parents: diff changeset	393 args = [args]
136 b86f496f6035 Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	394 return Markup(unicode.__mod__(self, tuple(map(escape, args))))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	395
5479aae32f5a Initial import. cmlenz parents: diff changeset	396 def __mul__(self, num):
5479aae32f5a Initial import. cmlenz parents: diff changeset	397 return Markup(unicode(self) * num)
5479aae32f5a Initial import. cmlenz parents: diff changeset	398
204 51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	399 def __rmul__(self, num):
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	400 return Markup(num * unicode(self))
51d4101f49ca * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	401
17 74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	402 def __repr__(self):
382 2682dabbcd04 * Added documentation for the various stream event kinds. cmlenz parents: 377 diff changeset	403 return '<%s %r>' % (self.__class__.__name__, unicode(self))
17 74cc70129d04 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	404
54 1f3cd91325d9 Fix a number of escaping problems: cmlenz parents: 34 diff changeset	405 def join(self, seq, escape_quotes=True):
1f3cd91325d9 Fix a number of escaping problems: cmlenz parents: 34 diff changeset	406 return Markup(unicode(self).join([escape(item, quotes=escape_quotes)
34 3421dd98f015 quotes should not be escaped inside text nodes mgood parents: 27 diff changeset	407 for item in seq]))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	408
5479aae32f5a Initial import. cmlenz parents: diff changeset	409 def escape(cls, text, quotes=True):
5479aae32f5a Initial import. cmlenz parents: diff changeset	410 """Create a Markup instance from a string and escape special characters
5479aae32f5a Initial import. cmlenz parents: diff changeset	411 it may contain (<, >, & and \").
5479aae32f5a Initial import. cmlenz parents: diff changeset	412
5479aae32f5a Initial import. cmlenz parents: diff changeset	413 If the `quotes` parameter is set to `False`, the \" character is left
5479aae32f5a Initial import. cmlenz parents: diff changeset	414 as is. Escaping quotes is generally only required for strings that are
5479aae32f5a Initial import. cmlenz parents: diff changeset	415 to be used in attribute values.
5479aae32f5a Initial import. cmlenz parents: diff changeset	416 """
73 1da51d718391 Some more performance tweaks. cmlenz parents: 69 diff changeset	417 if not text:
1da51d718391 Some more performance tweaks. cmlenz parents: 69 diff changeset	418 return cls()
1da51d718391 Some more performance tweaks. cmlenz parents: 69 diff changeset	419 if type(text) is cls:
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	420 return text
73 1da51d718391 Some more performance tweaks. cmlenz parents: 69 diff changeset	421 text = unicode(text).replace('&', '&') \
1da51d718391 Some more performance tweaks. cmlenz parents: 69 diff changeset	422 .replace('<', '<') \
1da51d718391 Some more performance tweaks. cmlenz parents: 69 diff changeset	423 .replace('>', '>')
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	424 if quotes:
5479aae32f5a Initial import. cmlenz parents: diff changeset	425 text = text.replace('"', '"')
5479aae32f5a Initial import. cmlenz parents: diff changeset	426 return cls(text)
5479aae32f5a Initial import. cmlenz parents: diff changeset	427 escape = classmethod(escape)
5479aae32f5a Initial import. cmlenz parents: diff changeset	428
5479aae32f5a Initial import. cmlenz parents: diff changeset	429 def unescape(self):
5479aae32f5a Initial import. cmlenz parents: diff changeset	430 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
5479aae32f5a Initial import. cmlenz parents: diff changeset	431 if not self:
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	432 return u''
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	433 return unicode(self).replace('"', '"') \
5479aae32f5a Initial import. cmlenz parents: diff changeset	434 .replace('>', '>') \
5479aae32f5a Initial import. cmlenz parents: diff changeset	435 .replace('<', '<') \
5479aae32f5a Initial import. cmlenz parents: diff changeset	436 .replace('&', '&')
5479aae32f5a Initial import. cmlenz parents: diff changeset	437
116 c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	438 def stripentities(self, keepxmlentities=False):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	439 """Return a copy of the text with any character or numeric entities
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	440 replaced by the equivalent UTF-8 characters.
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	441
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	442 If the `keepxmlentities` parameter is provided and evaluates to `True`,
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	443 the core XML entities (&, ', >, < and ") are not
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	444 stripped.
6 71e8e645fe81 Simplified implementation of `py:content` directive. cmlenz parents: 5 diff changeset	445 """
116 c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	446 return Markup(stripentities(self, keepxmlentities=keepxmlentities))
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	447
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	448 def striptags(self):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	449 """Return a copy of the text with all XML/HTML tags removed."""
c77c113846d6 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	450 return Markup(striptags(self))
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	451
5479aae32f5a Initial import. cmlenz parents: diff changeset	452
5479aae32f5a Initial import. cmlenz parents: diff changeset	453 escape = Markup.escape
5479aae32f5a Initial import. cmlenz parents: diff changeset	454
5479aae32f5a Initial import. cmlenz parents: diff changeset	455 def unescape(text):
5479aae32f5a Initial import. cmlenz parents: diff changeset	456 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
5479aae32f5a Initial import. cmlenz parents: diff changeset	457 if not isinstance(text, Markup):
5479aae32f5a Initial import. cmlenz parents: diff changeset	458 return text
5479aae32f5a Initial import. cmlenz parents: diff changeset	459 return text.unescape()
5479aae32f5a Initial import. cmlenz parents: diff changeset	460
5479aae32f5a Initial import. cmlenz parents: diff changeset	461
5479aae32f5a Initial import. cmlenz parents: diff changeset	462 class Namespace(object):
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	463 """Utility class creating and testing elements with a namespace.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	464
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	465 Internally, namespace URIs are encoded in the `QName` of any element or
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	466 attribute, the namespace URI being enclosed in curly braces. This class
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	467 helps create and test these strings.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	468
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	469 A `Namespace` object is instantiated with the namespace URI.
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	470
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	471 >>> html = Namespace('http://www.w3.org/1999/xhtml')
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	472 >>> html
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	473 <Namespace "http://www.w3.org/1999/xhtml">
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	474 >>> html.uri
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	475 u'http://www.w3.org/1999/xhtml'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	476
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	477 The `Namespace` object can than be used to generate `QName` objects with
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	478 that namespace:
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	479
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	480 >>> html.body
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	481 QName(u'http://www.w3.org/1999/xhtml}body')
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	482 >>> html.body.localname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	483 u'body'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	484 >>> html.body.namespace
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	485 u'http://www.w3.org/1999/xhtml'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	486
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	487 The same works using item access notation, which is useful for element or
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	488 attribute names that are not valid Python identifiers:
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	489
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	490 >>> html['body']
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	491 QName(u'http://www.w3.org/1999/xhtml}body')
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	492
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	493 A `Namespace` object can also be used to test whether a specific `QName`
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	494 belongs to that namespace using the `in` operator:
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	495
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	496 >>> qname = html.body
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	497 >>> qname in html
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	498 True
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	499 >>> qname in Namespace('http://www.w3.org/2002/06/xhtml2')
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	500 False
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	501 """
224 90d62225f411 Implement support for namespace prefixes in XPath expressions. cmlenz parents: 204 diff changeset	502 def __new__(cls, uri):
90d62225f411 Implement support for namespace prefixes in XPath expressions. cmlenz parents: 204 diff changeset	503 if type(uri) is cls:
90d62225f411 Implement support for namespace prefixes in XPath expressions. cmlenz parents: 204 diff changeset	504 return uri
90d62225f411 Implement support for namespace prefixes in XPath expressions. cmlenz parents: 204 diff changeset	505 return object.__new__(cls, uri)
90d62225f411 Implement support for namespace prefixes in XPath expressions. cmlenz parents: 204 diff changeset	506
279 a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	507 def __getnewargs__(self):
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	508 return (self.uri,)
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	509
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	510 def __getstate__(self):
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	511 return self.uri
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	512
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	513 def __setstate__(self, uri):
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	514 self.uri = uri
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	515
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	516 def __init__(self, uri):
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	517 self.uri = unicode(uri)
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	518
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	519 def __contains__(self, qname):
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	520 return qname.namespace == self.uri
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	521
278 d6c58473a9d0 Fix the handling of namespace context for match templates. cmlenz parents: 230 diff changeset	522 def __ne__(self, other):
d6c58473a9d0 Fix the handling of namespace context for match templates. cmlenz parents: 230 diff changeset	523 return not self == other
d6c58473a9d0 Fix the handling of namespace context for match templates. cmlenz parents: 230 diff changeset	524
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	525 def __eq__(self, other):
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	526 if isinstance(other, Namespace):
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	527 return self.uri == other.uri
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	528 return self.uri == other
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	529
5479aae32f5a Initial import. cmlenz parents: diff changeset	530 def __getitem__(self, name):
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	531 return QName(self.uri + u'}' + name)
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	532 __getattr__ = __getitem__
5479aae32f5a Initial import. cmlenz parents: diff changeset	533
5479aae32f5a Initial import. cmlenz parents: diff changeset	534 def __repr__(self):
5479aae32f5a Initial import. cmlenz parents: diff changeset	535 return '<Namespace "%s">' % self.uri
5479aae32f5a Initial import. cmlenz parents: diff changeset	536
5479aae32f5a Initial import. cmlenz parents: diff changeset	537 def __str__(self):
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	538 return self.uri.encode('utf-8')
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	539
5479aae32f5a Initial import. cmlenz parents: diff changeset	540 def __unicode__(self):
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	541 return self.uri
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	542
5479aae32f5a Initial import. cmlenz parents: diff changeset	543
147 a4a0ca41b6ad Use `xmlcharrefreplace` when encoding the output in `Stream.render()`, so that encoding the output to legacy encodings such as ASCII or ISO-8859-1 should always work. cmlenz parents: 145 diff changeset	544 # The namespace used by attributes such as xml:lang and xml:space
141 520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 140 diff changeset	545 XML_NAMESPACE = Namespace('http://www.w3.org/XML/1998/namespace')
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 140 diff changeset	546
520a5b7dd6d2 * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 140 diff changeset	547
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	548 class QName(unicode):
5479aae32f5a Initial import. cmlenz parents: diff changeset	549 """A qualified element or attribute name.
5479aae32f5a Initial import. cmlenz parents: diff changeset	550
5479aae32f5a Initial import. cmlenz parents: diff changeset	551 The unicode value of instances of this class contains the qualified name of
5479aae32f5a Initial import. cmlenz parents: diff changeset	552 the element or attribute, in the form `{namespace}localname`. The namespace
5479aae32f5a Initial import. cmlenz parents: diff changeset	553 URI can be obtained through the additional `namespace` attribute, while the
5479aae32f5a Initial import. cmlenz parents: diff changeset	554 local name can be accessed through the `localname` attribute.
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	555
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	556 >>> qname = QName('foo')
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	557 >>> qname
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	558 QName(u'foo')
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	559 >>> qname.localname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	560 u'foo'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	561 >>> qname.namespace
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	562
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	563 >>> qname = QName('http://www.w3.org/1999/xhtml}body')
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	564 >>> qname
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	565 QName(u'http://www.w3.org/1999/xhtml}body')
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	566 >>> qname.localname
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	567 u'body'
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	568 >>> qname.namespace
5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	569 u'http://www.w3.org/1999/xhtml'
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	570 """
5479aae32f5a Initial import. cmlenz parents: diff changeset	571 __slots__ = ['namespace', 'localname']
5479aae32f5a Initial import. cmlenz parents: diff changeset	572
5479aae32f5a Initial import. cmlenz parents: diff changeset	573 def __new__(cls, qname):
100 a519f581a1b1 Ported [111] to trunk. cmlenz parents: 96 diff changeset	574 if type(qname) is cls:
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	575 return qname
5479aae32f5a Initial import. cmlenz parents: diff changeset	576
18 5420cfe42d36 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	577 parts = qname.split(u'}', 1)
100 a519f581a1b1 Ported [111] to trunk. cmlenz parents: 96 diff changeset	578 if len(parts) > 1:
136 b86f496f6035 Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	579 self = unicode.__new__(cls, u'{%s' % qname)
b86f496f6035 Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	580 self.namespace, self.localname = map(unicode, parts)
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	581 else:
5479aae32f5a Initial import. cmlenz parents: diff changeset	582 self = unicode.__new__(cls, qname)
136 b86f496f6035 Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	583 self.namespace, self.localname = None, unicode(qname)
1 5479aae32f5a Initial import. cmlenz parents: diff changeset	584 return self
279 a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	585
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	586 def __getnewargs__(self):
a99666402b12 Some adjustments to make core data structures picklable (requires protocol 2). cmlenz parents: 278 diff changeset	587 return (self.lstrip('{'),)
326 f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	588
f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	589 def __repr__(self):
f999da894391 Fixed `__repr__` of the `QName`, `Attrs`, and `Expression` classes so that the output can be used as code to instantiate the object again. cmlenz parents: 279 diff changeset	590 return 'QName(%s)' % unicode.__repr__(self.lstrip('{'))

Mercurial > genshi > mirror

annotate genshi/core.py @ 382:2682dabbcd04 trunk