/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/xml_serializer.py

  • Committer: Vincent Ladeuil
  • Date: 2007-11-24 14:20:59 UTC
  • mto: (3928.1.1 bzr.integration)
  • mto: This revision was merged to the branch mainline in revision 3929.
  • Revision ID: v.ladeuil+lp@free.fr-20071124142059-2114qtsgfdv8g9p1
Ssl files needed for the test https server.

* bzrlib/tests/ssl_certs/create_ssls.py: 
Script to create the ssl keys and certificates.

* bzrlib/tests/ssl_certs/server.crt: 
Server certificate signed by the certificate authority.

* bzrlib/tests/ssl_certs/server.csr: 
Server certificate signing request.

* bzrlib/tests/ssl_certs/server_without_pass.key: 
Server key usable without password.

* bzrlib/tests/ssl_certs/server_with_pass.key: 
Server key.

* bzrlib/tests/ssl_certs/ca.key: 
Certificate authority private key.

* bzrlib/tests/ssl_certs/ca.crt: 
Certificate authority certificate.

* bzrlib/tests/ssl_certs/__init__.py: 
Provide access to ssl files (keys and certificates). 

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml_serializer.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""XML externalization support."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
# "XML is like violence: if it doesn't solve your problem, you aren't
22
20
# using enough of it." -- various
23
21
 
24
22
# importing this module is fairly slow because it has to load several
25
23
# ElementTree bits
26
24
 
27
 
import re
 
25
from bzrlib import registry
 
26
from bzrlib.trace import mutter, warning
28
27
 
29
28
try:
30
 
    import xml.etree.cElementTree as elementtree
31
 
    ParseError = getattr(elementtree, "ParseError", SyntaxError)
 
29
    try:
 
30
        # it's in this package in python2.5
 
31
        from xml.etree.cElementTree import (ElementTree, SubElement, Element,
 
32
            XMLTreeBuilder, fromstring, tostring)
 
33
        import xml.etree as elementtree
 
34
    except ImportError:
 
35
        from cElementTree import (ElementTree, SubElement, Element,
 
36
                                  XMLTreeBuilder, fromstring, tostring)
 
37
        import elementtree
 
38
    ParseError = SyntaxError
32
39
except ImportError:
33
 
    # Fall back to pure python implementation if C extension is unavailable
34
 
    import xml.etree.ElementTree as elementtree
35
 
    try:
36
 
        from xml.etree.ElementTree import ParseError
37
 
    except ImportError:
38
 
        from xml.parsers.expat import ExpatError as ParseError
39
 
 
40
 
(ElementTree, SubElement, Element, fromstring, tostring) = (
41
 
    elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
42
 
    elementtree.fromstring, elementtree.tostring)
43
 
 
44
 
 
45
 
from .. import (
46
 
    cache_utf8,
47
 
    errors,
48
 
    lazy_regex,
49
 
    )
50
 
from ..sixish import text_type, bytesintern
51
 
from . import (
52
 
    inventory,
53
 
    serializer,
54
 
    )
55
 
 
56
 
 
57
 
class XMLSerializer(serializer.Serializer):
58
 
    """Abstract XML object serialize/deserialize"""
59
 
 
60
 
    squashes_xml_invalid_characters = True
61
 
 
62
 
    def read_inventory_from_string(self, xml_string, revision_id=None,
63
 
                                   entry_cache=None, return_from_cache=False):
 
40
    mutter('WARNING: using slower ElementTree; consider installing cElementTree'
 
41
           " and make sure it's on your PYTHONPATH")
 
42
    # this copy is shipped with bzr
 
43
    from util.elementtree.ElementTree import (ElementTree, SubElement,
 
44
                                              Element, XMLTreeBuilder,
 
45
                                              fromstring, tostring)
 
46
    import util.elementtree as elementtree
 
47
    from xml.parsers.expat import ExpatError as ParseError
 
48
 
 
49
from bzrlib import errors
 
50
 
 
51
 
 
52
class Serializer(object):
 
53
    """Abstract object serialize/deserialize"""
 
54
 
 
55
    def write_inventory(self, inv, f):
 
56
        """Write inventory to a file"""
 
57
        raise NotImplementedError(self.write_inventory)
 
58
 
 
59
    def write_inventory_to_string(self, inv):
 
60
        raise NotImplementedError(self.write_inventory_to_string)
 
61
 
 
62
    def read_inventory_from_string(self, xml_string, revision_id=None):
64
63
        """Read xml_string into an inventory object.
65
64
 
66
65
        :param xml_string: The xml to read.
67
66
        :param revision_id: If not-None, the expected revision id of the
68
67
            inventory. Some serialisers use this to set the results' root
69
 
            revision. This should be supplied for deserialising all
70
 
            from-repository inventories so that xml5 inventories that were
71
 
            serialised without a revision identifier can be given the right
72
 
            revision id (but not for working tree inventories where users can
73
 
            edit the data without triggering checksum errors or anything).
74
 
        :param entry_cache: An optional cache of InventoryEntry objects. If
75
 
            supplied we will look up entries via (file_id, revision_id) which
76
 
            should map to a valid InventoryEntry (File/Directory/etc) object.
77
 
        :param return_from_cache: Return entries directly from the cache,
78
 
            rather than copying them first. This is only safe if the caller
79
 
            promises not to mutate the returned inventory entries, but it can
80
 
            make some operations significantly faster.
 
68
            revision.
81
69
        """
82
70
        try:
83
 
            return self._unpack_inventory(fromstring(xml_string), revision_id,
84
 
                                          entry_cache=entry_cache,
85
 
                                          return_from_cache=return_from_cache)
86
 
        except ParseError as e:
 
71
            return self._unpack_inventory(fromstring(xml_string), revision_id)
 
72
        except ParseError, e:
87
73
            raise errors.UnexpectedInventoryFormat(e)
88
74
 
89
75
    def read_inventory(self, f, revision_id=None):
90
76
        try:
91
 
            try:
92
 
                return self._unpack_inventory(self._read_element(f),
93
 
                    revision_id=None)
94
 
            finally:
95
 
                f.close()
96
 
        except ParseError as e:
 
77
            return self._unpack_inventory(self._read_element(f),
 
78
                revision_id=None)
 
79
        except ParseError, e:
97
80
            raise errors.UnexpectedInventoryFormat(e)
98
81
 
99
82
    def write_revision(self, rev, f):
100
83
        self._write_element(self._pack_revision(rev), f)
101
84
 
102
85
    def write_revision_to_string(self, rev):
103
 
        return tostring(self._pack_revision(rev)) + b'\n'
 
86
        return tostring(self._pack_revision(rev)) + '\n'
104
87
 
105
88
    def read_revision(self, f):
106
89
        return self._unpack_revision(self._read_element(f))
110
93
 
111
94
    def _write_element(self, elt, f):
112
95
        ElementTree(elt).write(f, 'utf-8')
113
 
        f.write(b'\n')
 
96
        f.write('\n')
114
97
 
115
98
    def _read_element(self, f):
116
99
        return ElementTree().parse(f)
117
100
 
118
101
 
119
 
def escape_invalid_chars(message):
120
 
    """Escape the XML-invalid characters in a commit message.
121
 
 
122
 
    :param message: Commit message to escape
123
 
    :return: tuple with escaped message and number of characters escaped
124
 
    """
125
 
    if message is None:
126
 
        return None, 0
127
 
    # Python strings can include characters that can't be
128
 
    # represented in well-formed XML; escape characters that
129
 
    # aren't listed in the XML specification
130
 
    # (http://www.w3.org/TR/REC-xml/#NT-Char).
131
 
    return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
132
 
            lambda match: match.group(0).encode('unicode_escape'),
133
 
            message)
134
 
 
135
 
 
136
 
def get_utf8_or_ascii(a_str, _encode_utf8=cache_utf8.encode):
137
 
    """Return a cached version of the string.
138
 
 
139
 
    cElementTree will return a plain string if the XML is plain ascii. It only
140
 
    returns Unicode when it needs to. We want to work in utf-8 strings. So if
141
 
    cElementTree returns a plain string, we can just return the cached version.
142
 
    If it is Unicode, then we need to encode it.
143
 
 
144
 
    :param a_str: An 8-bit string or Unicode as returned by
145
 
                  cElementTree.Element.get()
146
 
    :return: A utf-8 encoded 8-bit string.
147
 
    """
148
 
    # This is fairly optimized because we know what cElementTree does, this is
149
 
    # not meant as a generic function for all cases. Because it is possible for
150
 
    # an 8-bit string to not be ascii or valid utf8.
151
 
    if a_str.__class__ is text_type:
152
 
        return _encode_utf8(a_str)
153
 
    else:
154
 
        return bytesintern(a_str)
155
 
 
156
 
 
157
 
_utf8_re = lazy_regex.lazy_compile(b'[&<>\'\"]|[\x80-\xff]+')
158
 
_unicode_re = lazy_regex.lazy_compile(u'[&<>\'\"\u0080-\uffff]')
159
 
 
160
 
 
161
 
_xml_escape_map = {
162
 
    "&": '&amp;',
163
 
    "'": "&apos;", # FIXME: overkill
164
 
    "\"": "&quot;",
165
 
    "<": "&lt;",
166
 
    ">": "&gt;",
167
 
    }
168
 
 
169
 
 
170
 
def _unicode_escape_replace(match, _map=_xml_escape_map):
171
 
    """Replace a string of non-ascii, non XML safe characters with their escape
172
 
 
173
 
    This will escape both Standard XML escapes, like <>"', etc.
174
 
    As well as escaping non ascii characters, because ElementTree did.
175
 
    This helps us remain compatible to older versions of bzr. We may change
176
 
    our policy in the future, though.
177
 
    """
178
 
    # jam 20060816 Benchmarks show that try/KeyError is faster if you
179
 
    # expect the entity to rarely miss. There is about a 10% difference
180
 
    # in overall time. But if you miss frequently, then if None is much
181
 
    # faster. For our use case, we *rarely* have a revision id, file id
182
 
    # or path name that is unicode. So use try/KeyError.
183
 
    try:
184
 
        return _map[match.group()]
185
 
    except KeyError:
186
 
        return "&#%d;" % ord(match.group())
187
 
 
188
 
 
189
 
def _utf8_escape_replace(match, _map=_xml_escape_map):
190
 
    """Escape utf8 characters into XML safe ones.
191
 
 
192
 
    This uses 2 tricks. It is either escaping "standard" characters, like "&<>,
193
 
    or it is handling characters with the high-bit set. For ascii characters,
194
 
    we just lookup the replacement in the dictionary. For everything else, we
195
 
    decode back into Unicode, and then use the XML escape code.
196
 
    """
197
 
    try:
198
 
        return _map[match.group().decode('ascii', 'replace')].encode()
199
 
    except KeyError:
200
 
        return b''.join(b'&#%d;' % ord(uni_chr)
201
 
                       for uni_chr in match.group().decode('utf8'))
202
 
 
203
 
 
204
 
_to_escaped_map = {}
205
 
 
206
 
def encode_and_escape(unicode_or_utf8_str, _map=_to_escaped_map):
207
 
    """Encode the string into utf8, and escape invalid XML characters"""
208
 
    # We frequently get entities we have not seen before, so it is better
209
 
    # to check if None, rather than try/KeyError
210
 
    text = _map.get(unicode_or_utf8_str)
211
 
    if text is None:
212
 
        if isinstance(unicode_or_utf8_str, text_type):
213
 
            # The alternative policy is to do a regular UTF8 encoding
214
 
            # and then escape only XML meta characters.
215
 
            # Performance is equivalent once you use cache_utf8. *However*
216
 
            # this makes the serialized texts incompatible with old versions
217
 
            # of bzr. So no net gain. (Perhaps the read code would handle utf8
218
 
            # better than entity escapes, but cElementTree seems to do just fine
219
 
            # either way)
220
 
            text = _unicode_re.sub(_unicode_escape_replace, unicode_or_utf8_str).encode() + b'"'
221
 
        else:
222
 
            # Plain strings are considered to already be in utf-8 so we do a
223
 
            # slightly different method for escaping.
224
 
            text = _utf8_re.sub(_utf8_escape_replace,
225
 
                                unicode_or_utf8_str) + b'"'
226
 
        _map[unicode_or_utf8_str] = text
227
 
    return text
228
 
 
229
 
 
230
 
def _clear_cache():
231
 
    """Clean out the unicode => escaped map"""
232
 
    _to_escaped_map.clear()
233
 
 
234
 
 
235
 
def unpack_inventory_entry(elt, entry_cache=None, return_from_cache=False):
236
 
    elt_get = elt.get
237
 
    file_id = elt_get('file_id')
238
 
    revision = elt_get('revision')
239
 
    # Check and see if we have already unpacked this exact entry
240
 
    # Some timings for "repo.revision_trees(last_100_revs)"
241
 
    #               bzr     mysql
242
 
    #   unmodified  4.1s    40.8s
243
 
    #   using lru   3.5s
244
 
    #   using fifo  2.83s   29.1s
245
 
    #   lru._cache  2.8s
246
 
    #   dict        2.75s   26.8s
247
 
    #   inv.add     2.5s    26.0s
248
 
    #   no_copy     2.00s   20.5s
249
 
    #   no_c,dict   1.95s   18.0s
250
 
    # Note that a cache of 10k nodes is more than sufficient to hold all of
251
 
    # the inventory for the last 100 revs for bzr, but not for mysql (20k
252
 
    # is enough for mysql, which saves the same 2s as using a dict)
253
 
 
254
 
    # Breakdown of mysql using time.clock()
255
 
    #   4.1s    2 calls to element.get for file_id, revision_id
256
 
    #   4.5s    cache_hit lookup
257
 
    #   7.1s    InventoryFile.copy()
258
 
    #   2.4s    InventoryDirectory.copy()
259
 
    #   0.4s    decoding unique entries
260
 
    #   1.6s    decoding entries after FIFO fills up
261
 
    #   0.8s    Adding nodes to FIFO (including flushes)
262
 
    #   0.1s    cache miss lookups
263
 
    # Using an LRU cache
264
 
    #   4.1s    2 calls to element.get for file_id, revision_id
265
 
    #   9.9s    cache_hit lookup
266
 
    #   10.8s   InventoryEntry.copy()
267
 
    #   0.3s    cache miss lookus
268
 
    #   1.2s    decoding entries
269
 
    #   1.0s    adding nodes to LRU
270
 
    if entry_cache is not None and revision is not None:
271
 
        key = (file_id, revision)
272
 
        try:
273
 
            # We copy it, because some operations may mutate it
274
 
            cached_ie = entry_cache[key]
275
 
        except KeyError:
276
 
            pass
277
 
        else:
278
 
            # Only copying directory entries drops us 2.85s => 2.35s
279
 
            if return_from_cache:
280
 
                if cached_ie.kind == 'directory':
281
 
                    return cached_ie.copy()
282
 
                return cached_ie
283
 
            return cached_ie.copy()
284
 
 
285
 
    kind = elt.tag
286
 
    if not inventory.InventoryEntry.versionable_kind(kind):
287
 
        raise AssertionError('unsupported entry kind %s' % kind)
288
 
 
289
 
    file_id = get_utf8_or_ascii(file_id)
290
 
    if revision is not None:
291
 
        revision = get_utf8_or_ascii(revision)
292
 
    parent_id = elt_get('parent_id')
293
 
    if parent_id is not None:
294
 
        parent_id = get_utf8_or_ascii(parent_id)
295
 
 
296
 
    if kind == 'directory':
297
 
        ie = inventory.InventoryDirectory(file_id,
298
 
                                          elt_get('name'),
299
 
                                          parent_id)
300
 
    elif kind == 'file':
301
 
        ie = inventory.InventoryFile(file_id,
302
 
                                     elt_get('name'),
303
 
                                     parent_id)
304
 
        ie.text_sha1 = elt_get('text_sha1')
305
 
        if ie.text_sha1 is not None:
306
 
            ie.text_sha1 = ie.text_sha1.encode('ascii')
307
 
        if elt_get('executable') == 'yes':
308
 
            ie.executable = True
309
 
        v = elt_get('text_size')
310
 
        ie.text_size = v and int(v)
311
 
    elif kind == 'symlink':
312
 
        ie = inventory.InventoryLink(file_id,
313
 
                                     elt_get('name'),
314
 
                                     parent_id)
315
 
        ie.symlink_target = elt_get('symlink_target')
316
 
    elif kind == 'tree-reference':
317
 
        file_id = get_utf8_or_ascii(elt.attrib['file_id'])
318
 
        name = elt.attrib['name']
319
 
        parent_id = get_utf8_or_ascii(elt.attrib['parent_id'])
320
 
        revision = get_utf8_or_ascii(elt.get('revision'))
321
 
        reference_revision = get_utf8_or_ascii(elt.get('reference_revision'))
322
 
        ie = inventory.TreeReference(file_id, name, parent_id, revision,
323
 
                                       reference_revision)
324
 
    else:
325
 
        raise errors.UnsupportedInventoryKind(kind)
326
 
    ie.revision = revision
327
 
    if revision is not None and entry_cache is not None:
328
 
        # We cache a copy() because callers like to mutate objects, and
329
 
        # that would cause the item in cache to mutate as well.
330
 
        # This has a small effect on many-inventory performance, because
331
 
        # the majority fraction is spent in cache hits, not misses.
332
 
        entry_cache[key] = ie.copy()
333
 
 
334
 
    return ie
335
 
 
336
 
 
337
 
def unpack_inventory_flat(elt, format_num, unpack_entry,
338
 
            entry_cache=None, return_from_cache=False):
339
 
    """Unpack a flat XML inventory.
340
 
 
341
 
    :param elt: XML element for the inventory
342
 
    :param format_num: Expected format number
343
 
    :param unpack_entry: Function for unpacking inventory entries
344
 
    :return: An inventory
345
 
    :raise UnexpectedInventoryFormat: When unexpected elements or data is
346
 
        encountered
347
 
    """
348
 
    if elt.tag != 'inventory':
349
 
        raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
350
 
    format = elt.get('format')
351
 
    if ((format is None and format_num is not None)
352
 
            or format.encode() != format_num):
353
 
        raise errors.UnexpectedInventoryFormat('Invalid format version %r'
354
 
                                               % format)
355
 
    revision_id = elt.get('revision_id')
356
 
    if revision_id is not None:
357
 
        revision_id = cache_utf8.encode(revision_id)
358
 
    inv = inventory.Inventory(root_id=None, revision_id=revision_id)
359
 
    for e in elt:
360
 
        ie = unpack_entry(e, entry_cache, return_from_cache)
361
 
        inv.add(ie)
362
 
    return inv
363
 
 
364
 
 
365
 
def serialize_inventory_flat(inv, append, root_id, supported_kinds, working):
366
 
    """Serialize an inventory to a flat XML file.
367
 
 
368
 
    :param inv: Inventory to serialize
369
 
    :param append: Function for writing a line of output
370
 
    :param working: If True skip history data - text_sha1, text_size,
371
 
        reference_revision, symlink_target.    self._check_revisions(inv)
372
 
    """
373
 
    entries = inv.iter_entries()
374
 
    # Skip the root
375
 
    root_path, root_ie = next(entries)
376
 
    for path, ie in entries:
377
 
        if ie.parent_id != root_id:
378
 
            parent_str = b' parent_id="'
379
 
            parent_id  = encode_and_escape(ie.parent_id)
380
 
        else:
381
 
            parent_str = b''
382
 
            parent_id  = b''
383
 
        if ie.kind == 'file':
384
 
            if ie.executable:
385
 
                executable = b' executable="yes"'
386
 
            else:
387
 
                executable = b''
388
 
            if not working:
389
 
                append(b'<file%s file_id="%s name="%s%s%s revision="%s '
390
 
                    b'text_sha1="%s" text_size="%d" />\n' % (
391
 
                    executable, encode_and_escape(ie.file_id),
392
 
                    encode_and_escape(ie.name), parent_str, parent_id,
393
 
                    encode_and_escape(ie.revision), ie.text_sha1,
394
 
                    ie.text_size))
395
 
            else:
396
 
                append(b'<file%s file_id="%s name="%s%s%s />\n' % (
397
 
                    executable, encode_and_escape(ie.file_id),
398
 
                    encode_and_escape(ie.name), parent_str, parent_id))
399
 
        elif ie.kind == 'directory':
400
 
            if not working:
401
 
                append(b'<directory file_id="%s name="%s%s%s revision="%s '
402
 
                    b'/>\n' % (
403
 
                    encode_and_escape(ie.file_id),
404
 
                    encode_and_escape(ie.name),
405
 
                    parent_str, parent_id,
406
 
                    encode_and_escape(ie.revision)))
407
 
            else:
408
 
                append(b'<directory file_id="%s name="%s%s%s />\n' % (
409
 
                    encode_and_escape(ie.file_id),
410
 
                    encode_and_escape(ie.name),
411
 
                    parent_str, parent_id))
412
 
        elif ie.kind == 'symlink':
413
 
            if not working:
414
 
                append(b'<symlink file_id="%s name="%s%s%s revision="%s '
415
 
                    b'symlink_target="%s />\n' % (
416
 
                    encode_and_escape(ie.file_id),
417
 
                    encode_and_escape(ie.name),
418
 
                    parent_str, parent_id,
419
 
                    encode_and_escape(ie.revision),
420
 
                    encode_and_escape(ie.symlink_target)))
421
 
            else:
422
 
                append(b'<symlink file_id="%s name="%s%s%s />\n' % (
423
 
                    encode_and_escape(ie.file_id),
424
 
                    encode_and_escape(ie.name),
425
 
                    parent_str, parent_id))
426
 
        elif ie.kind == 'tree-reference':
427
 
            if ie.kind not in supported_kinds:
428
 
                raise errors.UnsupportedInventoryKind(ie.kind)
429
 
            if not working:
430
 
                append(b'<tree-reference file_id="%s name="%s%s%s '
431
 
                    b'revision="%s reference_revision="%s />\n' % (
432
 
                    encode_and_escape(ie.file_id),
433
 
                    encode_and_escape(ie.name),
434
 
                    parent_str, parent_id,
435
 
                    encode_and_escape(ie.revision),
436
 
                    encode_and_escape(ie.reference_revision)))
437
 
            else:
438
 
                append(b'<tree-reference file_id="%s name="%s%s%s />\n' % (
439
 
                    encode_and_escape(ie.file_id),
440
 
                    encode_and_escape(ie.name),
441
 
                    parent_str, parent_id))
442
 
        else:
443
 
            raise errors.UnsupportedInventoryKind(ie.kind)
444
 
    append(b'</inventory>\n')
 
102
# performance tuning for elementree's serialiser. This should be
 
103
# sent upstream - RBC 20060523.
 
104
# the functions here are patched into elementtree at runtime.
 
105
import re
 
106
escape_re = re.compile("[&'\"<>]")
 
107
escape_map = {
 
108
    "&":'&amp;',
 
109
    "'":"&apos;", # FIXME: overkill
 
110
    "\"":"&quot;",
 
111
    "<":"&lt;",
 
112
    ">":"&gt;",
 
113
    }
 
114
def _escape_replace(match, map=escape_map):
 
115
    return map[match.group()]
 
116
 
 
117
def _escape_attrib(text, encoding=None, replace=None):
 
118
    # escape attribute value
 
119
    try:
 
120
        if encoding:
 
121
            try:
 
122
                text = elementtree.ElementTree._encode(text, encoding)
 
123
            except UnicodeError:
 
124
                return elementtree.ElementTree._encode_entity(text)
 
125
        if replace is None:
 
126
            return escape_re.sub(_escape_replace, text)
 
127
        else:
 
128
            text = replace(text, "&", "&amp;")
 
129
            text = replace(text, "'", "&apos;") # FIXME: overkill
 
130
            text = replace(text, "\"", "&quot;")
 
131
            text = replace(text, "<", "&lt;")
 
132
            text = replace(text, ">", "&gt;")
 
133
            return text
 
134
    except (TypeError, AttributeError):
 
135
        elementtree.ElementTree._raise_serialization_error(text)
 
136
 
 
137
elementtree.ElementTree._escape_attrib = _escape_attrib
 
138
 
 
139
escape_cdata_re = re.compile("[&<>]")
 
140
escape_cdata_map = {
 
141
    "&":'&amp;',
 
142
    "<":"&lt;",
 
143
    ">":"&gt;",
 
144
    }
 
145
def _escape_cdata_replace(match, map=escape_cdata_map):
 
146
    return map[match.group()]
 
147
 
 
148
def _escape_cdata(text, encoding=None, replace=None):
 
149
    # escape character data
 
150
    try:
 
151
        if encoding:
 
152
            try:
 
153
                text = elementtree.ElementTree._encode(text, encoding)
 
154
            except UnicodeError:
 
155
                return elementtree.ElementTree._encode_entity(text)
 
156
        if replace is None:
 
157
            return escape_cdata_re.sub(_escape_cdata_replace, text)
 
158
        else:
 
159
            text = replace(text, "&", "&amp;")
 
160
            text = replace(text, "<", "&lt;")
 
161
            text = replace(text, ">", "&gt;")
 
162
            return text
 
163
    except (TypeError, AttributeError):
 
164
        elementtree.ElementTree._raise_serialization_error(text)
 
165
 
 
166
elementtree.ElementTree._escape_cdata = _escape_cdata
 
167
 
 
168
 
 
169
class SerializerRegistry(registry.Registry):
 
170
    """Registry for serializer objects"""
 
171
 
 
172
 
 
173
format_registry = SerializerRegistry()
 
174
format_registry.register_lazy('4', 'bzrlib.xml4', 'serializer_v4')
 
175
format_registry.register_lazy('5', 'bzrlib.xml5', 'serializer_v5')
 
176
format_registry.register_lazy('6', 'bzrlib.xml6', 'serializer_v6')
 
177
format_registry.register_lazy('7', 'bzrlib.xml7', 'serializer_v7')