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

annotate markup/core.py @ 21:eca77129518a

* Include paths are now interpreted relative to the path of the including template. Closes #3. * The filename is now included as first item in the `pos` tuple of stream events. * Simplified the "basic" example so that it actually ''is'' basic. * Added a more complex example using nested relative includes in [source:/trunk/examples/includes/ examples/includes].

author	cmlenz
date	Tue, 20 Jun 2006 13:05:37 +0000
parents	4cbebb15a834
children	b8456279c444

rev	line source
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
821114ec4f69 Initial import. cmlenz parents: diff changeset	2 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	3 # Copyright (C) 2006 Christopher Lenz
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
821114ec4f69 Initial import. cmlenz parents: diff changeset	8 # are also available at http://trac.edgewall.com/license.html.
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
821114ec4f69 Initial import. cmlenz parents: diff changeset	12 # history and logs, available at http://projects.edgewall.com/trac/.
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
821114ec4f69 Initial import. cmlenz parents: diff changeset	17 import re
821114ec4f69 Initial import. cmlenz parents: diff changeset	18 from StringIO import StringIO
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`
821114ec4f69 Initial import. cmlenz parents: diff changeset	42 depends on the kind of event, and `position` is a `(line, offset)` tuple
821114ec4f69 Initial import. cmlenz parents: diff changeset	43 that contains the location of the original element or text in the input.
821114ec4f69 Initial import. cmlenz parents: diff changeset	44 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	45 __slots__ = ['events']
821114ec4f69 Initial import. cmlenz parents: diff changeset	46
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	47 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	48 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	49 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	50 PROLOG = StreamEventKind('PROLOG') # XML prolog
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
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	52 START_NS = StreamEventKind('START-NS') # start namespace mapping
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	53 END_NS = StreamEventKind('END-NS') # end namespace mapping
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	54 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	55 COMMENT = StreamEventKind('COMMENT') # comment
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	56
821114ec4f69 Initial import. cmlenz parents: diff changeset	57 def __init__(self, events):
821114ec4f69 Initial import. cmlenz parents: diff changeset	58 """Initialize the stream with a sequence of markup events.
821114ec4f69 Initial import. cmlenz parents: diff changeset	59
821114ec4f69 Initial import. cmlenz parents: diff changeset	60 @oaram events: a sequence or iterable providing the events
821114ec4f69 Initial import. cmlenz parents: diff changeset	61 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	62 self.events = events
821114ec4f69 Initial import. cmlenz parents: diff changeset	63
821114ec4f69 Initial import. cmlenz parents: diff changeset	64 def __iter__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	65 return iter(self.events)
821114ec4f69 Initial import. cmlenz parents: diff changeset	66
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	67 def render(self, method='xml', encoding='utf-8', filters=None, **kwargs):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	68 """Return a string representation of the stream.
821114ec4f69 Initial import. cmlenz parents: diff changeset	69
821114ec4f69 Initial import. cmlenz parents: diff changeset	70 @param method: determines how the stream is serialized; can be either
821114ec4f69 Initial import. cmlenz parents: diff changeset	71 'xml' or 'html', or a custom `Serializer` subclass
821114ec4f69 Initial import. cmlenz parents: diff changeset	72 @param encoding: how the output string should be encoded; if set to
821114ec4f69 Initial import. cmlenz parents: diff changeset	73 `None`, this method returns a `unicode` object
821114ec4f69 Initial import. cmlenz parents: diff changeset	74
821114ec4f69 Initial import. cmlenz parents: diff changeset	75 Any additional keyword arguments are passed to the serializer, and thus
821114ec4f69 Initial import. cmlenz parents: diff changeset	76 depend on the `method` parameter value.
821114ec4f69 Initial import. cmlenz parents: diff changeset	77 """
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	78 generator = self.serialize(method=method, filters=filters, **kwargs)
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	79 output = u''.join(list(generator))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	80 if encoding is not None:
9 3dc28e165273 Actually use the specified encoding in `Stream.render()`. cmlenz parents: 8 diff changeset	81 return output.encode(encoding)
8 ea47069a901c `Stream.render()` was masking `TypeError`s (fix based on suggestion by Matt Good). cmlenz parents: 6 diff changeset	82 return output
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	83
821114ec4f69 Initial import. cmlenz parents: diff changeset	84 def select(self, path):
821114ec4f69 Initial import. cmlenz parents: diff changeset	85 """Return a new stream that contains the events matching the given
821114ec4f69 Initial import. cmlenz parents: diff changeset	86 XPath expression.
821114ec4f69 Initial import. cmlenz parents: diff changeset	87
821114ec4f69 Initial import. cmlenz parents: diff changeset	88 @param path: a string containing the XPath expression
821114ec4f69 Initial import. cmlenz parents: diff changeset	89 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	90 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	91 return Path(path).select(self)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	92
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	93 def serialize(self, method='xml', filters=None, **kwargs):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	94 """Generate strings corresponding to a specific serialization of the
821114ec4f69 Initial import. cmlenz parents: diff changeset	95 stream.
821114ec4f69 Initial import. cmlenz parents: diff changeset	96
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	97 Unlike the `render()` method, this method is a generator that returns
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	98 the serialized output incrementally, as opposed to returning a single
821114ec4f69 Initial import. cmlenz parents: diff changeset	99 string.
821114ec4f69 Initial import. cmlenz parents: diff changeset	100
821114ec4f69 Initial import. cmlenz parents: diff changeset	101 @param method: determines how the stream is serialized; can be either
821114ec4f69 Initial import. cmlenz parents: diff changeset	102 'xml' or 'html', or a custom `Serializer` subclass
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	103 @param filters: list of filters to apply to the stream before
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	104 serialization. The default is to apply whitespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	105 reduction using `markup.filters.WhitespaceFilter`.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	106 """
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	107 from markup.filters import WhitespaceFilter
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	108 from markup import output
821114ec4f69 Initial import. cmlenz parents: diff changeset	109 cls = method
821114ec4f69 Initial import. cmlenz parents: diff changeset	110 if isinstance(method, basestring):
821114ec4f69 Initial import. cmlenz parents: diff changeset	111 cls = {'xml': output.XMLSerializer,
821114ec4f69 Initial import. cmlenz parents: diff changeset	112 'html': output.HTMLSerializer}[method]
821114ec4f69 Initial import. cmlenz parents: diff changeset	113 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	114 assert issubclass(cls, serializers.Serializer)
821114ec4f69 Initial import. cmlenz parents: diff changeset	115 serializer = cls(**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	116
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	117 stream = 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	118 if filters is None:
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	119 filters = [WhitespaceFilter()]
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	120 for filter_ in filters:
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	121 stream = filter_(iter(stream))
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	122
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	123 return serializer.serialize(stream)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	124
821114ec4f69 Initial import. cmlenz parents: diff changeset	125 def __str__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	126 return self.render()
821114ec4f69 Initial import. cmlenz parents: diff changeset	127
821114ec4f69 Initial import. cmlenz parents: diff changeset	128 def __unicode__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	129 return self.render(encoding=None)
821114ec4f69 Initial import. cmlenz parents: diff changeset	130
821114ec4f69 Initial import. cmlenz parents: diff changeset	131
821114ec4f69 Initial import. cmlenz parents: diff changeset	132 class Attributes(list):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	133 """Sequence type that stores the attributes of an element.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	134
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	135 The order of the attributes is preserved, while accessing and manipulating
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	136 attributes by name is also supported.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	137
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	138 >>> attrs = Attributes([('href', '#'), ('title', 'Foo')])
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	139 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	140 [(u'href', '#'), (u'title', 'Foo')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	141
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	142 >>> 'href' in attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	143 True
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	144 >>> 'tabindex' in attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	145 False
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	146
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	147 >>> attrs.get(u'title')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	148 'Foo'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	149 >>> attrs.set(u'title', 'Bar')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	150 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	151 [(u'href', '#'), (u'title', 'Bar')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	152 >>> attrs.remove(u'title')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	153 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	154 [(u'href', '#')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	155
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	156 New attributes added using the `set()` method are appended to the end of
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	157 the list:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	158
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	159 >>> attrs.set(u'accesskey', 'k')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	160 >>> attrs
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	161 [(u'href', '#'), (u'accesskey', 'k')]
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	162 """
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	163 __slots__ = []
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	164
821114ec4f69 Initial import. cmlenz parents: diff changeset	165 def __init__(self, attrib=None):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	166 """Create the `Attributes` instance.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	167
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	168 If the `attrib` parameter is provided, it is expected to be a sequence
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	169 of `(name, value)` tuples.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	170 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	171 list.__init__(self, map(lambda (k, v): (QName(k), v), attrib or []))
821114ec4f69 Initial import. cmlenz parents: diff changeset	172
821114ec4f69 Initial import. cmlenz parents: diff changeset	173 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	174 """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	175 name.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	176 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	177 return name in [attr for attr, value in self]
821114ec4f69 Initial import. cmlenz parents: diff changeset	178
821114ec4f69 Initial import. cmlenz parents: diff changeset	179 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	180 """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	181 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	182 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	183 for attr, value in self:
821114ec4f69 Initial import. cmlenz parents: diff changeset	184 if attr == name:
821114ec4f69 Initial import. cmlenz parents: diff changeset	185 return value
821114ec4f69 Initial import. cmlenz parents: diff changeset	186 return default
821114ec4f69 Initial import. cmlenz parents: diff changeset	187
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	188 def remove(self, name):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	189 """Removes the attribute with the specified name.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	190
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	191 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	192 """
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	193 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	194 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	195 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	196 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	197
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	198 def set(self, name, value):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	199 """Sets the specified attribute to the given value.
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	200
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	201 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	202 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	203 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	204 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	205 for idx, (attr, _) in enumerate(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	206 if attr == name:
821114ec4f69 Initial import. cmlenz parents: diff changeset	207 self[idx] = (attr, value)
821114ec4f69 Initial import. cmlenz parents: diff changeset	208 break
821114ec4f69 Initial import. cmlenz parents: diff changeset	209 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	210 self.append((QName(name), value))
821114ec4f69 Initial import. cmlenz parents: diff changeset	211
821114ec4f69 Initial import. cmlenz parents: diff changeset	212
821114ec4f69 Initial import. cmlenz parents: diff changeset	213 class Markup(unicode):
821114ec4f69 Initial import. cmlenz parents: diff changeset	214 """Marks a string as being safe for inclusion in HTML/XML output without
821114ec4f69 Initial import. cmlenz parents: diff changeset	215 needing to be escaped.
821114ec4f69 Initial import. cmlenz parents: diff changeset	216 """
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	217 __slots__ = []
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	218
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	219 def __new__(self, text='', *args):
821114ec4f69 Initial import. cmlenz parents: diff changeset	220 if args:
821114ec4f69 Initial import. cmlenz parents: diff changeset	221 text %= tuple([escape(arg) for arg in args])
821114ec4f69 Initial import. cmlenz parents: diff changeset	222 return unicode.__new__(self, text)
821114ec4f69 Initial import. cmlenz parents: diff changeset	223
821114ec4f69 Initial import. cmlenz parents: diff changeset	224 def __add__(self, other):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	225 return Markup(unicode(self) + escape(other))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	226
821114ec4f69 Initial import. cmlenz parents: diff changeset	227 def __mod__(self, args):
821114ec4f69 Initial import. cmlenz parents: diff changeset	228 if not isinstance(args, (list, tuple)):
821114ec4f69 Initial import. cmlenz parents: diff changeset	229 args = [args]
821114ec4f69 Initial import. cmlenz parents: diff changeset	230 return Markup(unicode.__mod__(self,
821114ec4f69 Initial import. cmlenz parents: diff changeset	231 tuple([escape(arg) for arg in args])))
821114ec4f69 Initial import. cmlenz parents: diff changeset	232
821114ec4f69 Initial import. cmlenz parents: diff changeset	233 def __mul__(self, num):
821114ec4f69 Initial import. cmlenz parents: diff changeset	234 return Markup(unicode(self) * num)
821114ec4f69 Initial import. cmlenz parents: diff changeset	235
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	236 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	237 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	238
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	239 def join(self, seq):
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	240 return Markup(unicode(self).join([escape(item) for item in seq]))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	241
821114ec4f69 Initial import. cmlenz parents: diff changeset	242 def stripentities(self, keepxmlentities=False):
821114ec4f69 Initial import. cmlenz parents: diff changeset	243 """Return a copy of the text with any character or numeric entities
821114ec4f69 Initial import. cmlenz parents: diff changeset	244 replaced by the equivalent UTF-8 characters.
821114ec4f69 Initial import. cmlenz parents: diff changeset	245
821114ec4f69 Initial import. cmlenz parents: diff changeset	246 If the `keepxmlentities` parameter is provided and evaluates to `True`,
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	247 the core XML entities (&, ', >, < and ") are not
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	248 stripped.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	249 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	250 def _replace_entity(match):
821114ec4f69 Initial import. cmlenz parents: diff changeset	251 if match.group(1): # numeric entity
821114ec4f69 Initial import. cmlenz parents: diff changeset	252 ref = match.group(1)
821114ec4f69 Initial import. cmlenz parents: diff changeset	253 if ref.startswith('x'):
821114ec4f69 Initial import. cmlenz parents: diff changeset	254 ref = int(ref[1:], 16)
821114ec4f69 Initial import. cmlenz parents: diff changeset	255 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	256 ref = int(ref, 10)
821114ec4f69 Initial import. cmlenz parents: diff changeset	257 return unichr(ref)
821114ec4f69 Initial import. cmlenz parents: diff changeset	258 else: # character entity
821114ec4f69 Initial import. cmlenz parents: diff changeset	259 ref = match.group(2)
821114ec4f69 Initial import. cmlenz parents: diff changeset	260 if keepxmlentities and ref in ('amp', 'apos', 'gt', 'lt', 'quot'):
821114ec4f69 Initial import. cmlenz parents: diff changeset	261 return '&%s;' % ref
821114ec4f69 Initial import. cmlenz parents: diff changeset	262 try:
821114ec4f69 Initial import. cmlenz parents: diff changeset	263 codepoint = htmlentitydefs.name2codepoint[ref]
821114ec4f69 Initial import. cmlenz parents: diff changeset	264 return unichr(codepoint)
821114ec4f69 Initial import. cmlenz parents: diff changeset	265 except KeyError:
821114ec4f69 Initial import. cmlenz parents: diff changeset	266 if keepxmlentities:
821114ec4f69 Initial import. cmlenz parents: diff changeset	267 return '&%s;' % ref
821114ec4f69 Initial import. cmlenz parents: diff changeset	268 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	269 return ref
821114ec4f69 Initial import. cmlenz parents: diff changeset	270 return Markup(re.sub(r'&(?:#((?:\d+)\|(?:[xX][0-9a-fA-F]+));?\|(\w+);)',
821114ec4f69 Initial import. cmlenz parents: diff changeset	271 _replace_entity, self))
821114ec4f69 Initial import. cmlenz parents: diff changeset	272
821114ec4f69 Initial import. cmlenz parents: diff changeset	273 def striptags(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	274 """Return a copy of the text with all XML/HTML tags removed."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	275 return Markup(re.sub(r'<[^>]*?>', '', self))
821114ec4f69 Initial import. cmlenz parents: diff changeset	276
821114ec4f69 Initial import. cmlenz parents: diff changeset	277 def escape(cls, text, quotes=True):
821114ec4f69 Initial import. cmlenz parents: diff changeset	278 """Create a Markup instance from a string and escape special characters
821114ec4f69 Initial import. cmlenz parents: diff changeset	279 it may contain (<, >, & and \").
821114ec4f69 Initial import. cmlenz parents: diff changeset	280
821114ec4f69 Initial import. cmlenz parents: diff changeset	281 If the `quotes` parameter is set to `False`, the \" character is left
821114ec4f69 Initial import. cmlenz parents: diff changeset	282 as is. Escaping quotes is generally only required for strings that are
821114ec4f69 Initial import. cmlenz parents: diff changeset	283 to be used in attribute values.
821114ec4f69 Initial import. cmlenz parents: diff changeset	284 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	285 if isinstance(text, cls):
821114ec4f69 Initial import. cmlenz parents: diff changeset	286 return text
821114ec4f69 Initial import. cmlenz parents: diff changeset	287 text = unicode(text)
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	288 if not text or isinstance(text, cls):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	289 return cls()
821114ec4f69 Initial import. cmlenz parents: diff changeset	290 text = text.replace('&', '&') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	291 .replace('<', '<') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	292 .replace('>', '>')
821114ec4f69 Initial import. cmlenz parents: diff changeset	293 if quotes:
821114ec4f69 Initial import. cmlenz parents: diff changeset	294 text = text.replace('"', '"')
821114ec4f69 Initial import. cmlenz parents: diff changeset	295 return cls(text)
821114ec4f69 Initial import. cmlenz parents: diff changeset	296 escape = classmethod(escape)
821114ec4f69 Initial import. cmlenz parents: diff changeset	297
821114ec4f69 Initial import. cmlenz parents: diff changeset	298 def unescape(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	299 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	300 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	301 return u''
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	302 return unicode(self).replace('"', '"') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	303 .replace('>', '>') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	304 .replace('<', '<') \
821114ec4f69 Initial import. cmlenz parents: diff changeset	305 .replace('&', '&')
821114ec4f69 Initial import. cmlenz parents: diff changeset	306
821114ec4f69 Initial import. cmlenz parents: diff changeset	307 def plaintext(self, keeplinebreaks=True):
6 5da45906dda7 Simplified implementation of `py:content` directive. cmlenz parents: 5 diff changeset	308 """Returns the text as a `unicode` string with all entities and tags
5da45906dda7 Simplified implementation of `py:content` directive. cmlenz parents: 5 diff changeset	309 removed.
5da45906dda7 Simplified implementation of `py:content` directive. cmlenz parents: 5 diff changeset	310 """
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	311 text = unicode(self.striptags().stripentities())
821114ec4f69 Initial import. cmlenz parents: diff changeset	312 if not keeplinebreaks:
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	313 text = text.replace(u'\n', u' ')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	314 return text
821114ec4f69 Initial import. cmlenz parents: diff changeset	315
821114ec4f69 Initial import. cmlenz parents: diff changeset	316 def sanitize(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	317 from markup.filters import HTMLSanitizer
821114ec4f69 Initial import. cmlenz parents: diff changeset	318 from markup.input import HTMLParser
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	319 text = StringIO(self.stripentities(keepxmlentities=True))
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	320 return Stream(HTMLSanitizer()(HTMLParser(text)))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	321
821114ec4f69 Initial import. cmlenz parents: diff changeset	322
821114ec4f69 Initial import. cmlenz parents: diff changeset	323 escape = Markup.escape
821114ec4f69 Initial import. cmlenz parents: diff changeset	324
821114ec4f69 Initial import. cmlenz parents: diff changeset	325 def unescape(text):
821114ec4f69 Initial import. cmlenz parents: diff changeset	326 """Reverse-escapes &, <, > and \" and returns a `unicode` object."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	327 if not isinstance(text, Markup):
821114ec4f69 Initial import. cmlenz parents: diff changeset	328 return text
821114ec4f69 Initial import. cmlenz parents: diff changeset	329 return text.unescape()
821114ec4f69 Initial import. cmlenz parents: diff changeset	330
821114ec4f69 Initial import. cmlenz parents: diff changeset	331
821114ec4f69 Initial import. cmlenz parents: diff changeset	332 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	333 """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	334
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	335 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	336 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	337 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	338
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	339 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	340
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	341 >>> 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	342 >>> html
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	343 <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	344 >>> html.uri
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	345 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	346
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	347 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	348 that namespace:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	349
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	350 >>> html.body
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	351 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	352 >>> html.body.localname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	353 u'body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	354 >>> html.body.namespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	355 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	356
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	357 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	358 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	359
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	360 >>> html['body']
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	361 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	362
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	363 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	364 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	365
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	366 >>> qname = html.body
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	367 >>> qname in html
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	368 True
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	369 >>> 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	370 False
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	371 """
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	372 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	373 self.uri = unicode(uri)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	374
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	375 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	376 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	377
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	378 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	379 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	380 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	381 return self.uri == other
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	382
821114ec4f69 Initial import. cmlenz parents: diff changeset	383 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	384 return QName(self.uri + u'}' + name)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	385
821114ec4f69 Initial import. cmlenz parents: diff changeset	386 __getattr__ = __getitem__
821114ec4f69 Initial import. cmlenz parents: diff changeset	387
821114ec4f69 Initial import. cmlenz parents: diff changeset	388 def __repr__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	389 return '<Namespace "%s">' % self.uri
821114ec4f69 Initial import. cmlenz parents: diff changeset	390
821114ec4f69 Initial import. cmlenz parents: diff changeset	391 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	392 return self.uri.encode('utf-8')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	393
821114ec4f69 Initial import. cmlenz parents: diff changeset	394 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	395 return self.uri
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	396
821114ec4f69 Initial import. cmlenz parents: diff changeset	397
821114ec4f69 Initial import. cmlenz parents: diff changeset	398 class QName(unicode):
821114ec4f69 Initial import. cmlenz parents: diff changeset	399 """A qualified element or attribute name.
821114ec4f69 Initial import. cmlenz parents: diff changeset	400
821114ec4f69 Initial import. cmlenz parents: diff changeset	401 The unicode value of instances of this class contains the qualified name of
821114ec4f69 Initial import. cmlenz parents: diff changeset	402 the element or attribute, in the form `{namespace}localname`. The namespace
821114ec4f69 Initial import. cmlenz parents: diff changeset	403 URI can be obtained through the additional `namespace` attribute, while the
821114ec4f69 Initial import. cmlenz parents: diff changeset	404 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	405
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	406 >>> qname = QName('foo')
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	407 >>> qname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	408 u'foo'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	409 >>> qname.localname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	410 u'foo'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	411 >>> qname.namespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	412
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	413 >>> 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	414 >>> qname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	415 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	416 >>> qname.localname
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	417 u'body'
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	418 >>> qname.namespace
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	419 u'http://www.w3.org/1999/xhtml'
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	420 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	421 __slots__ = ['namespace', 'localname']
821114ec4f69 Initial import. cmlenz parents: diff changeset	422
821114ec4f69 Initial import. cmlenz parents: diff changeset	423 def __new__(cls, qname):
821114ec4f69 Initial import. cmlenz parents: diff changeset	424 if isinstance(qname, QName):
821114ec4f69 Initial import. cmlenz parents: diff changeset	425 return qname
821114ec4f69 Initial import. cmlenz parents: diff changeset	426
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	427 parts = qname.split(u'}', 1)
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	428 if qname.find(u'}') > 0:
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	429 self = unicode.__new__(cls, u'{' + qname)
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	430 self.namespace = unicode(parts[0])
4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	431 self.localname = unicode(parts[1])
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	432 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	433 self = unicode.__new__(cls, qname)
821114ec4f69 Initial import. cmlenz parents: diff changeset	434 self.namespace = None
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	435 self.localname = unicode(qname)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	436 return self

Mercurial > genshi > genshi-test

annotate markup/core.py @ 21:eca77129518a