genshi/genshi-test: markup/core.py annotate

annotate markup/core.py @ 215:e92135672812

A couple of minor XPath fixes.

author	cmlenz
date	Fri, 01 Sep 2006 13:45:42 +0000
parents	516a6cae0aa8
children	e4dad1145f84

rev	line source
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
821114ec4f69 Initial import. cmlenz parents: diff changeset	2 #
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 54 diff changeset	3 # Copyright (C) 2006 Edgewall Software
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	4 # All rights reserved.
821114ec4f69 Initial import. cmlenz parents: diff changeset	5 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
821114ec4f69 Initial import. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 54 diff changeset	8 # are also available at http://markup.edgewall.org/wiki/License.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	9 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	10 # This software consists of voluntary contributions made by many
821114ec4f69 Initial import. cmlenz parents: diff changeset	11 # individuals. For the exact contribution history, see the revision
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 54 diff changeset	12 # history and logs, available at http://markup.edgewall.org/log/.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	13
821114ec4f69 Initial import. cmlenz parents: diff changeset	14 """Core classes for markup processing."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	15
821114ec4f69 Initial import. cmlenz parents: diff changeset	16 import htmlentitydefs
204 516a6cae0aa8 * 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 821114ec4f69 Initial import. cmlenz parents: diff changeset	18 import re
821114ec4f69 Initial import. cmlenz parents: diff changeset	19
821114ec4f69 Initial import. cmlenz parents: diff changeset	20 __all__ = ['Stream', 'Markup', 'escape', 'unescape', 'Namespace', 'QName']
821114ec4f69 Initial import. cmlenz parents: diff changeset	21
821114ec4f69 Initial import. cmlenz parents: diff changeset	22
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	23 class StreamEventKind(str):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	24 """A kind of event on an XML stream."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	25
821114ec4f69 Initial import. cmlenz parents: diff changeset	26
821114ec4f69 Initial import. cmlenz parents: diff changeset	27 class Stream(object):
821114ec4f69 Initial import. cmlenz parents: diff changeset	28 """Represents a stream of markup events.
821114ec4f69 Initial import. cmlenz parents: diff changeset	29
821114ec4f69 Initial import. cmlenz parents: diff changeset	30 This class is basically an iterator over the events.
821114ec4f69 Initial import. cmlenz parents: diff changeset	31
821114ec4f69 Initial import. cmlenz parents: diff changeset	32 Also provided are ways to serialize the stream to text. The `serialize()`
821114ec4f69 Initial import. cmlenz parents: diff changeset	33 method will return an iterator over generated strings, while `render()`
821114ec4f69 Initial import. cmlenz parents: diff changeset	34 returns the complete generated text at once. Both accept various parameters
821114ec4f69 Initial import. cmlenz parents: diff changeset	35 that impact the way the stream is serialized.
821114ec4f69 Initial import. cmlenz parents: diff changeset	36
821114ec4f69 Initial import. cmlenz parents: diff changeset	37 Stream events are tuples of the form:
821114ec4f69 Initial import. cmlenz parents: diff changeset	38
821114ec4f69 Initial import. cmlenz parents: diff changeset	39 (kind, data, position)
821114ec4f69 Initial import. cmlenz parents: diff changeset	40
821114ec4f69 Initial import. cmlenz parents: diff changeset	41 where `kind` is the event kind (such as `START`, `END`, `TEXT`, etc), `data`
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 171 diff changeset	42 depends on the kind of event, and `position` is a `(filename, line, offset)`
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 171 diff changeset	43 tuple that contains the location of the original element or text in the
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 171 diff changeset	44 input. If the original location is unknown, `position` is `(None, -1, -1)`.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	45 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	46 __slots__ = ['events']
821114ec4f69 Initial import. cmlenz parents: diff changeset	47
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	48 START = StreamEventKind('START') # a start tag
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	49 END = StreamEventKind('END') # an end tag
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	50 TEXT = StreamEventKind('TEXT') # literal text
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 10 diff changeset	51 DOCTYPE = StreamEventKind('DOCTYPE') # doctype declaration
143 ef761afcedff CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	52 START_NS = StreamEventKind('START_NS') # start namespace mapping
ef761afcedff CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24. cmlenz parents: 141 diff changeset	53 END_NS = StreamEventKind('END_NS') # end namespace mapping
ef761afcedff 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	54 START_CDATA = StreamEventKind('START_CDATA') # start CDATA section
ef761afcedff 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	55 END_CDATA = StreamEventKind('END_CDATA') # end CDATA section
17 ad63ad459524 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 PI = StreamEventKind('PI') # processing instruction
ad63ad459524 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 COMMENT = StreamEventKind('COMMENT') # comment
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	58
821114ec4f69 Initial import. cmlenz parents: diff changeset	59 def __init__(self, events):
821114ec4f69 Initial import. cmlenz parents: diff changeset	60 """Initialize the stream with a sequence of markup events.
821114ec4f69 Initial import. cmlenz parents: diff changeset	61
27 b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	62 @param events: a sequence or iterable providing the events
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	63 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	64 self.events = events
821114ec4f69 Initial import. cmlenz parents: diff changeset	65
821114ec4f69 Initial import. cmlenz parents: diff changeset	66 def __iter__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	67 return iter(self.events)
821114ec4f69 Initial import. cmlenz parents: diff changeset	68
204 516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	69 def __or__(self, function):
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	70 """Override the "bitwise or" operator to apply filters or serializers
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	71 to the stream, providing a syntax similar to pipes on Unix shells.
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	72
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	73 Assume the following stream produced by the `HTML` function:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	74
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	75 >>> from markup.input import HTML
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	76 >>> html = HTML('''<p onclick="alert('Whoa')">Hello, world!</p>''')
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	77 >>> print html
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	78 <p onclick="alert('Whoa')">Hello, world!</p>
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	79
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	80 A filter such as the HTML sanitizer can be applied to that stream using
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	81 the pipe notation as follows:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	82
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	83 >>> from markup.filters import HTMLSanitizer
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	84 >>> sanitizer = HTMLSanitizer()
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	85 >>> print html \| sanitizer
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	86 <p>Hello, world!</p>
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	87
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	88 Filters can be any function that accepts and produces a stream (where
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	89 a stream is anything that iterators over events):
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	90
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	91 >>> def uppercase(stream):
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	92 ... for kind, data, pos in stream:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	93 ... if kind is TEXT:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	94 ... data = data.upper()
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	95 ... yield kind, data, pos
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	96 >>> print html \| sanitizer \| uppercase
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	97 <p>HELLO, WORLD!</p>
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	98
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	99 Serializers can also be used with this notation:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	100
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	101 >>> from markup.output import TextSerializer
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	102 >>> output = TextSerializer()
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	103 >>> print html \| sanitizer \| uppercase \| output
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	104 HELLO, WORLD!
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	105
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	106 Commonly, serializers should be used at the end of the "pipeline";
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	107 using them somewhere in the middle may produce unexpected results.
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	108 """
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	109 return Stream(_ensure(function(self)))
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	110
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	111 def filter(self, *filters):
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	112 """Apply filters to the stream.
113 e815c2c07572 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	113
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	114 This method returns a new stream with the given filters applied. The
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	115 filters must be callables that accept the stream object as parameter,
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	116 and return the filtered stream.
204 516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	117
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	118 The call:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	119
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	120 stream.filter(filter1, filter2)
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	121
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	122 is equivalent to:
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	123
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	124 stream \| filter1 \| filter2
113 e815c2c07572 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	125 """
204 516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	126 return reduce(operator.or_, (self,) + filters)
113 e815c2c07572 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	127
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	128 def render(self, method='xml', encoding='utf-8', **kwargs):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	129 """Return a string representation of the stream.
821114ec4f69 Initial import. cmlenz parents: diff changeset	130
821114ec4f69 Initial import. cmlenz parents: diff changeset	131 @param method: determines how the stream is serialized; can be either
200 50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	132 "xml", "xhtml", "html", "text", or a custom serializer
50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	133 class
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	134 @param encoding: how the output string should be encoded; if set to
821114ec4f69 Initial import. cmlenz parents: diff changeset	135 `None`, this method returns a `unicode` object
821114ec4f69 Initial import. cmlenz parents: diff changeset	136
821114ec4f69 Initial import. cmlenz parents: diff changeset	137 Any additional keyword arguments are passed to the serializer, and thus
821114ec4f69 Initial import. cmlenz parents: diff changeset	138 depend on the `method` parameter value.
821114ec4f69 Initial import. cmlenz parents: diff changeset	139 """
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	140 generator = self.serialize(method=method, **kwargs)
17 ad63ad459524 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	141 output = u''.join(list(generator))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	142 if encoding is not None:
200 50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	143 errors = 'replace'
50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	144 if method != 'text':
50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	145 errors = 'xmlcharrefreplace'
50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	146 return output.encode(encoding, errors)
8 ea47069a901c `Stream.render()` was masking `TypeError`s (fix based on suggestion by Matt Good). cmlenz parents: 6 diff changeset	147 return output
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	148
821114ec4f69 Initial import. cmlenz parents: diff changeset	149 def select(self, path):
821114ec4f69 Initial import. cmlenz parents: diff changeset	150 """Return a new stream that contains the events matching the given
821114ec4f69 Initial import. cmlenz parents: diff changeset	151 XPath expression.
821114ec4f69 Initial import. cmlenz parents: diff changeset	152
821114ec4f69 Initial import. cmlenz parents: diff changeset	153 @param path: a string containing the XPath expression
821114ec4f69 Initial import. cmlenz parents: diff changeset	154 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	155 from markup.path import Path
17 ad63ad459524 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	156 return Path(path).select(self)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	157
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 116 diff changeset	158 def serialize(self, method='xml', **kwargs):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	159 """Generate strings corresponding to a specific serialization of the
821114ec4f69 Initial import. cmlenz parents: diff changeset	160 stream.
821114ec4f69 Initial import. cmlenz parents: diff changeset	161
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	162 Unlike the `render()` method, this method is a generator that returns
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	163 the serialized output incrementally, as opposed to returning a single
821114ec4f69 Initial import. cmlenz parents: diff changeset	164 string.
821114ec4f69 Initial import. cmlenz parents: diff changeset	165
821114ec4f69 Initial import. cmlenz parents: diff changeset	166 @param method: determines how the stream is serialized; can be either
200 50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	167 "xml", "xhtml", "html", "text", or a custom serializer
50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	168 class
147 f7fb556f2678 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	169
f7fb556f2678 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	170 Any additional keyword arguments are passed to the serializer, and thus
f7fb556f2678 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	171 depend on the `method` parameter value.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	172 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	173 from markup import output
821114ec4f69 Initial import. cmlenz parents: diff changeset	174 cls = method
821114ec4f69 Initial import. cmlenz parents: diff changeset	175 if isinstance(method, basestring):
96 35d681a94763 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	176 cls = {'xml': output.XMLSerializer,
35d681a94763 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	177 'xhtml': output.XHTMLSerializer,
200 50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	178 'html': output.HTMLSerializer,
50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	179 'text': output.TextSerializer}[method]
204 516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	180 return cls(**kwargs)(_ensure(self))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	181
821114ec4f69 Initial import. cmlenz parents: diff changeset	182 def __str__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	183 return self.render()
821114ec4f69 Initial import. cmlenz parents: diff changeset	184
821114ec4f69 Initial import. cmlenz parents: diff changeset	185 def __unicode__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	186 return self.render(encoding=None)
821114ec4f69 Initial import. cmlenz parents: diff changeset	187
821114ec4f69 Initial import. cmlenz parents: diff changeset	188
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	189 START = Stream.START
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	190 END = Stream.END
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	191 TEXT = Stream.TEXT
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	192 DOCTYPE = Stream.DOCTYPE
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	193 START_NS = Stream.START_NS
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	194 END_NS = Stream.END_NS
143 ef761afcedff 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	195 START_CDATA = Stream.START_CDATA
ef761afcedff 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	196 END_CDATA = Stream.END_CDATA
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	197 PI = Stream.PI
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	198 COMMENT = Stream.COMMENT
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	199
111 8a4d9064f363 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	200 def _ensure(stream):
8a4d9064f363 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	201 """Ensure that every item on the stream is actually a markup event."""
8a4d9064f363 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	202 for event in stream:
145 56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	203 if type(event) is not tuple:
56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	204 if hasattr(event, 'totuple'):
56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	205 event = event.totuple()
56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	206 else:
56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	207 event = TEXT, unicode(event), (None, -1, -1)
56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 143 diff changeset	208 yield event
111 8a4d9064f363 Some fixes and more unit tests for the XPath engine. cmlenz parents: 100 diff changeset	209
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	210
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	211 class Attrs(list):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	212 """Sequence type that stores the attributes of an element.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	213
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	214 The order of the attributes is preserved, while accessing and manipulating
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	215 attributes by name is also supported.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	216
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	217 >>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	218 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	219 [(u'href', '#'), (u'title', 'Foo')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	220
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	221 >>> 'href' in attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	222 True
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	223 >>> 'tabindex' in attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	224 False
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	225
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	226 >>> attrs.get(u'title')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	227 'Foo'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	228 >>> attrs.set(u'title', 'Bar')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	229 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	230 [(u'href', '#'), (u'title', 'Bar')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	231 >>> attrs.remove(u'title')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	232 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	233 [(u'href', '#')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	234
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	235 New attributes added using the `set()` method are appended to the end of
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	236 the list:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	237
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	238 >>> attrs.set(u'accesskey', 'k')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	239 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	240 [(u'href', '#'), (u'accesskey', 'k')]
170 f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	241
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	242 An `Attrs` instance can also be initialized with keyword arguments.
170 f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	243
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	244 >>> attrs = Attrs(class_='bar', href='#', title='Foo')
171 34e0455ada92 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	245 >>> attrs.get('class')
34e0455ada92 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	246 'bar'
170 f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	247 >>> attrs.get('href')
f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	248 '#'
f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	249 >>> attrs.get('title')
f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	250 'Foo'
171 34e0455ada92 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	251
34e0455ada92 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	252 Reserved words can be used by appending a trailing underscore to the name,
34e0455ada92 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	253 and any other underscore is replaced by a dash:
34e0455ada92 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	254
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	255 >>> attrs = Attrs(class_='bar', accept_charset='utf-8')
171 34e0455ada92 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	256 >>> attrs.get('class')
34e0455ada92 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	257 'bar'
34e0455ada92 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	258 >>> attrs.get('accept-charset')
34e0455ada92 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	259 'utf-8'
34e0455ada92 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	260
34e0455ada92 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 Thus this shorthand can not be used if attribute names should contain
34e0455ada92 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	262 actual underscore characters.
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	263 """
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	264 __slots__ = []
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	265
170 f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	266 def __init__(self, attrib=None, **kwargs):
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 172 diff changeset	267 """Create the `Attrs` instance.
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	268
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	269 If the `attrib` parameter is provided, it is expected to be a sequence
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	270 of `(name, value)` tuples.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	271 """
27 b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	272 if attrib is None:
b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	273 attrib = []
b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	274 list.__init__(self, [(QName(name), value) for name, value in attrib])
170 f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	275 for name, value in kwargs.items():
171 34e0455ada92 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	276 self.set(name.rstrip('_').replace('_', '-'), value)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	277
821114ec4f69 Initial import. cmlenz parents: diff changeset	278 def __contains__(self, name):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	279 """Return whether the list includes an attribute with the specified
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	280 name.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	281 """
133 b9a0031d4bbb Minor cleanup and performance improvement for the builder module. cmlenz parents: 123 diff changeset	282 for attr, _ in self:
b9a0031d4bbb Minor cleanup and performance improvement for the builder module. cmlenz parents: 123 diff changeset	283 if attr == name:
b9a0031d4bbb Minor cleanup and performance improvement for the builder module. cmlenz parents: 123 diff changeset	284 return True
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	285
821114ec4f69 Initial import. cmlenz parents: diff changeset	286 def get(self, name, default=None):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	287 """Return the value of the attribute with the specified name, or the
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	288 value of the `default` parameter if no such attribute is found.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	289 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	290 for attr, value in self:
821114ec4f69 Initial import. cmlenz parents: diff changeset	291 if attr == name:
821114ec4f69 Initial import. cmlenz parents: diff changeset	292 return value
821114ec4f69 Initial import. cmlenz parents: diff changeset	293 return default
821114ec4f69 Initial import. cmlenz parents: diff changeset	294
5 1add946decb8 Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior). cmlenz parents: 1 diff changeset	295 def remove(self, name):
161 a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	296 """Remove the attribute with the specified name.
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	297
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	298 If no such attribute is found, this method does nothing.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	299 """
5 1add946decb8 Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior). cmlenz parents: 1 diff changeset	300 for idx, (attr, _) in enumerate(self):
1add946decb8 Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior). cmlenz parents: 1 diff changeset	301 if attr == name:
1add946decb8 Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior). cmlenz parents: 1 diff changeset	302 del self[idx]
1add946decb8 Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior). cmlenz parents: 1 diff changeset	303 break
1add946decb8 Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior). cmlenz parents: 1 diff changeset	304
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	305 def set(self, name, value):
161 a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	306 """Set the specified attribute to the given value.
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	307
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	308 If an attribute with the specified name is already in the list, the
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	309 value of the existing entry is updated. Otherwise, a new attribute is
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	310 appended to the end of the list.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	311 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	312 for idx, (attr, _) in enumerate(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	313 if attr == name:
170 f1ac0510d392 Allow initialization of `Attributes` with keyword arguments. cmlenz parents: 161 diff changeset	314 self[idx] = (QName(attr), value)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	315 break
821114ec4f69 Initial import. cmlenz parents: diff changeset	316 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	317 self.append((QName(name), value))
821114ec4f69 Initial import. cmlenz parents: diff changeset	318
77 f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 73 diff changeset	319 def totuple(self):
161 a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	320 """Return the attributes as a markup event.
a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	321
a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	322 The returned event is a TEXT event, the data is the value of all
a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	323 attributes joined together.
a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 147 diff changeset	324 """
77 f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 73 diff changeset	325 return TEXT, u''.join([x[1] for x in self]), (None, -1, -1)
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 73 diff changeset	326
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	327
116 88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	328 def plaintext(text, keeplinebreaks=True):
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	329 """Returns the text as a `unicode` string with all entities and tags
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	330 removed.
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	331 """
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	332 text = stripentities(striptags(text))
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	333 if not keeplinebreaks:
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	334 text = text.replace(u'\n', u' ')
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	335 return text
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	336
113 e815c2c07572 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	337 def stripentities(text, keepxmlentities=False):
e815c2c07572 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 """Return a copy of the given text with any character or numeric entities
e815c2c07572 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 replaced by the equivalent UTF-8 characters.
e815c2c07572 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
e815c2c07572 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 If the `keepxmlentities` parameter is provided and evaluates to `True`,
e815c2c07572 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 the core XML entities (&, ', >, < and ") are not
e815c2c07572 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 stripped.
e815c2c07572 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 """
e815c2c07572 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 def _replace_entity(match):
e815c2c07572 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 if match.group(1): # numeric entity
e815c2c07572 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 ref = match.group(1)
e815c2c07572 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 if ref.startswith('x'):
e815c2c07572 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 ref = int(ref[1:], 16)
e815c2c07572 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 else:
e815c2c07572 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 ref = int(ref, 10)
e815c2c07572 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 return unichr(ref)
e815c2c07572 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 else: # character entity
e815c2c07572 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 ref = match.group(2)
200 50eab0469148 Add serialization to plain text, based on cboos' patch. Closes #41. cmlenz parents: 182 diff changeset	355 if keepxmlentities and ref in ('amp', 'apos', 'gt', 'lt', 'quot'):
113 e815c2c07572 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	356 return '&%s;' % ref
e815c2c07572 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 try:
e815c2c07572 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 codepoint = htmlentitydefs.name2codepoint[ref]
e815c2c07572 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 return unichr(codepoint)
e815c2c07572 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 except KeyError:
e815c2c07572 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 if keepxmlentities:
e815c2c07572 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 return '&%s;' % ref
e815c2c07572 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 else:
e815c2c07572 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 return ref
e815c2c07572 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 re.sub(r'&(?:#((?:\d+)\|(?:[xX][0-9a-fA-F]+));?\|(\w+);)',
e815c2c07572 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 _replace_entity, text)
e815c2c07572 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
116 88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	368 def striptags(text):
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	369 """Return a copy of the text with all XML/HTML tags removed."""
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	370 return re.sub(r'<[^>]*?>', '', text)
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	371
113 e815c2c07572 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	372
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	373 class Markup(unicode):
821114ec4f69 Initial import. cmlenz parents: diff changeset	374 """Marks a string as being safe for inclusion in HTML/XML output without
821114ec4f69 Initial import. cmlenz parents: diff changeset	375 needing to be escaped.
821114ec4f69 Initial import. cmlenz parents: diff changeset	376 """
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	377 __slots__ = []
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	378
27 b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	379 def __new__(cls, text='', *args):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	380 if args:
136 636e0100fcaf Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	381 text %= tuple(map(escape, args))
27 b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 18 diff changeset	382 return unicode.__new__(cls, text)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	383
821114ec4f69 Initial import. cmlenz parents: diff changeset	384 def __add__(self, other):
204 516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	385 return Markup(unicode(self) + unicode(escape(other)))
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	386
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	387 def __radd__(self, other):
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	388 return Markup(unicode(escape(other)) + unicode(self))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	389
821114ec4f69 Initial import. cmlenz parents: diff changeset	390 def __mod__(self, args):
821114ec4f69 Initial import. cmlenz parents: diff changeset	391 if not isinstance(args, (list, tuple)):
821114ec4f69 Initial import. cmlenz parents: diff changeset	392 args = [args]
136 636e0100fcaf Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	393 return Markup(unicode.__mod__(self, tuple(map(escape, args))))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	394
821114ec4f69 Initial import. cmlenz parents: diff changeset	395 def __mul__(self, num):
821114ec4f69 Initial import. cmlenz parents: diff changeset	396 return Markup(unicode(self) * num)
821114ec4f69 Initial import. cmlenz parents: diff changeset	397
204 516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	398 def __rmul__(self, num):
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	399 return Markup(num * unicode(self))
516a6cae0aa8 * Implement reverse add/mul operators for `Markup` class, so that the result is also a `Markup` instance. cmlenz parents: 200 diff changeset	400
17 ad63ad459524 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	401 def __repr__(self):
ad63ad459524 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 return '<%s "%s">' % (self.__class__.__name__, self)
ad63ad459524 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	403
54 01981cbc7575 Fix a number of escaping problems: cmlenz parents: 34 diff changeset	404 def join(self, seq, escape_quotes=True):
01981cbc7575 Fix a number of escaping problems: cmlenz parents: 34 diff changeset	405 return Markup(unicode(self).join([escape(item, quotes=escape_quotes)
34 ae293292cbb1 quotes should not be escaped inside text nodes mgood parents: 27 diff changeset	406 for item in seq]))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	407
821114ec4f69 Initial import. cmlenz parents: diff changeset	408 def escape(cls, text, quotes=True):
821114ec4f69 Initial import. cmlenz parents: diff changeset	409 """Create a Markup instance from a string and escape special characters
821114ec4f69 Initial import. cmlenz parents: diff changeset	410 it may contain (<, >, & and \").
821114ec4f69 Initial import. cmlenz parents: diff changeset	411
821114ec4f69 Initial import. cmlenz parents: diff changeset	412 If the `quotes` parameter is set to `False`, the \" character is left
821114ec4f69 Initial import. cmlenz parents: diff changeset	413 as is. Escaping quotes is generally only required for strings that are
821114ec4f69 Initial import. cmlenz parents: diff changeset	414 to be used in attribute values.
821114ec4f69 Initial import. cmlenz parents: diff changeset	415 """
73 b0fd16111f2e Some more performance tweaks. cmlenz parents: 69 diff changeset	416 if not text:
b0fd16111f2e Some more performance tweaks. cmlenz parents: 69 diff changeset	417 return cls()
b0fd16111f2e Some more performance tweaks. cmlenz parents: 69 diff changeset	418 if type(text) is cls:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	419 return text
73 b0fd16111f2e Some more performance tweaks. cmlenz parents: 69 diff changeset	420 text = unicode(text).replace('&', '&') \
b0fd16111f2e Some more performance tweaks. cmlenz parents: 69 diff changeset	421 .replace('<', '<') \
b0fd16111f2e Some more performance tweaks. cmlenz parents: 69 diff changeset	422 .replace('>', '>')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	423 if quotes:
821114ec4f69 Initial import. cmlenz parents: diff changeset	424 text = text.replace('"', '"')
821114ec4f69 Initial import. cmlenz parents: diff changeset	425 return cls(text)
821114ec4f69 Initial import. cmlenz parents: diff changeset	426 escape = classmethod(escape)
821114ec4f69 Initial import. cmlenz parents: diff changeset	427
821114ec4f69 Initial import. cmlenz parents: diff changeset	428 def unescape(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	429 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	430 if not self:
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	431 return u''
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	432 return unicode(self).replace('"', '"') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	433 .replace('>', '>') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	434 .replace('<', '<') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	435 .replace('&', '&')
821114ec4f69 Initial import. cmlenz parents: diff changeset	436
116 88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	437 def stripentities(self, keepxmlentities=False):
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	438 """Return a copy of the text with any character or numeric entities
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	439 replaced by the equivalent UTF-8 characters.
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	440
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	441 If the `keepxmlentities` parameter is provided and evaluates to `True`,
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	442 the core XML entities (&, ', >, < and ") are not
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	443 stripped.
6 5da45906dda7 Simplified implementation of `py:content` directive. cmlenz parents: 5 diff changeset	444 """
116 88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	445 return Markup(stripentities(self, keepxmlentities=keepxmlentities))
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	446
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	447 def striptags(self):
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	448 """Return a copy of the text with all XML/HTML tags removed."""
88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 115 diff changeset	449 return Markup(striptags(self))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	450
821114ec4f69 Initial import. cmlenz parents: diff changeset	451
821114ec4f69 Initial import. cmlenz parents: diff changeset	452 escape = Markup.escape
821114ec4f69 Initial import. cmlenz parents: diff changeset	453
821114ec4f69 Initial import. cmlenz parents: diff changeset	454 def unescape(text):
821114ec4f69 Initial import. cmlenz parents: diff changeset	455 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	456 if not isinstance(text, Markup):
821114ec4f69 Initial import. cmlenz parents: diff changeset	457 return text
821114ec4f69 Initial import. cmlenz parents: diff changeset	458 return text.unescape()
821114ec4f69 Initial import. cmlenz parents: diff changeset	459
821114ec4f69 Initial import. cmlenz parents: diff changeset	460
821114ec4f69 Initial import. cmlenz parents: diff changeset	461 class Namespace(object):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	462 """Utility class creating and testing elements with a namespace.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	463
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	464 Internally, namespace URIs are encoded in the `QName` of any element or
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	465 attribute, the namespace URI being enclosed in curly braces. This class
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	466 helps create and test these strings.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	467
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	468 A `Namespace` object is instantiated with the namespace URI.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	469
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	470 >>> html = Namespace('http://www.w3.org/1999/xhtml')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	471 >>> html
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	472 <Namespace "http://www.w3.org/1999/xhtml">
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	473 >>> html.uri
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	474 u'http://www.w3.org/1999/xhtml'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	475
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	476 The `Namespace` object can than be used to generate `QName` objects with
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	477 that namespace:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	478
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	479 >>> html.body
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	480 u'{http://www.w3.org/1999/xhtml}body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	481 >>> html.body.localname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	482 u'body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	483 >>> html.body.namespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	484 u'http://www.w3.org/1999/xhtml'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	485
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	486 The same works using item access notation, which is useful for element or
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	487 attribute names that are not valid Python identifiers:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	488
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	489 >>> html['body']
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	490 u'{http://www.w3.org/1999/xhtml}body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	491
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	492 A `Namespace` object can also be used to test whether a specific `QName`
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	493 belongs to that namespace using the `in` operator:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	494
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	495 >>> qname = html.body
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	496 >>> qname in html
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	497 True
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	498 >>> qname in Namespace('http://www.w3.org/2002/06/xhtml2')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	499 False
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	500 """
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	501 def __init__(self, uri):
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	502 self.uri = unicode(uri)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	503
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	504 def __contains__(self, qname):
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	505 return qname.namespace == self.uri
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	506
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	507 def __eq__(self, other):
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	508 if isinstance(other, Namespace):
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	509 return self.uri == other.uri
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	510 return self.uri == other
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	511
821114ec4f69 Initial import. cmlenz parents: diff changeset	512 def __getitem__(self, name):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	513 return QName(self.uri + u'}' + name)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	514 __getattr__ = __getitem__
821114ec4f69 Initial import. cmlenz parents: diff changeset	515
821114ec4f69 Initial import. cmlenz parents: diff changeset	516 def __repr__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	517 return '<Namespace "%s">' % self.uri
821114ec4f69 Initial import. cmlenz parents: diff changeset	518
821114ec4f69 Initial import. cmlenz parents: diff changeset	519 def __str__(self):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	520 return self.uri.encode('utf-8')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	521
821114ec4f69 Initial import. cmlenz parents: diff changeset	522 def __unicode__(self):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	523 return self.uri
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	524
821114ec4f69 Initial import. cmlenz parents: diff changeset	525
147 f7fb556f2678 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	526 # The namespace used by attributes such as xml:lang and xml:space
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 140 diff changeset	527 XML_NAMESPACE = Namespace('http://www.w3.org/XML/1998/namespace')
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 140 diff changeset	528
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 140 diff changeset	529
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	530 class QName(unicode):
821114ec4f69 Initial import. cmlenz parents: diff changeset	531 """A qualified element or attribute name.
821114ec4f69 Initial import. cmlenz parents: diff changeset	532
821114ec4f69 Initial import. cmlenz parents: diff changeset	533 The unicode value of instances of this class contains the qualified name of
821114ec4f69 Initial import. cmlenz parents: diff changeset	534 the element or attribute, in the form `{namespace}localname`. The namespace
821114ec4f69 Initial import. cmlenz parents: diff changeset	535 URI can be obtained through the additional `namespace` attribute, while the
821114ec4f69 Initial import. cmlenz parents: diff changeset	536 local name can be accessed through the `localname` attribute.
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	537
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	538 >>> qname = QName('foo')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	539 >>> qname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	540 u'foo'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	541 >>> qname.localname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	542 u'foo'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	543 >>> qname.namespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	544
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	545 >>> qname = QName('http://www.w3.org/1999/xhtml}body')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	546 >>> qname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	547 u'{http://www.w3.org/1999/xhtml}body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	548 >>> qname.localname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	549 u'body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	550 >>> qname.namespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	551 u'http://www.w3.org/1999/xhtml'
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	552 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	553 __slots__ = ['namespace', 'localname']
821114ec4f69 Initial import. cmlenz parents: diff changeset	554
821114ec4f69 Initial import. cmlenz parents: diff changeset	555 def __new__(cls, qname):
100 5e9987f34e6c Ported [111] to trunk. cmlenz parents: 96 diff changeset	556 if type(qname) is cls:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	557 return qname
821114ec4f69 Initial import. cmlenz parents: diff changeset	558
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	559 parts = qname.split(u'}', 1)
100 5e9987f34e6c Ported [111] to trunk. cmlenz parents: 96 diff changeset	560 if len(parts) > 1:
136 636e0100fcaf Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	561 self = unicode.__new__(cls, u'{%s' % qname)
636e0100fcaf Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	562 self.namespace, self.localname = map(unicode, parts)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	563 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	564 self = unicode.__new__(cls, qname)
136 636e0100fcaf Minor performance improvements in serialization. cmlenz parents: 133 diff changeset	565 self.namespace, self.localname = None, unicode(qname)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	566 return self

Mercurial > genshi > genshi-test

annotate markup/core.py @ 215:e92135672812