← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml_serializer.py

  • Committer: Martin Packman
  • Date: 2012-03-27 17:32:19 UTC
  • mto: (6437.54.3 2.5)
  • mto: This revision was merged to the branch mainline in revision 6525.
  • Revision ID: martin.packman@canonical.com-20120327173219-401pil42gke8j0xh
https://launchpad.net/bugs/940704
Fall back to sys.prefix not /usr when looking for .mo files

Show diffs side-by-side

added added

removed removed

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