1
# Copyright (C) 2005-2010 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
17
"""XML externalization support."""
19
from __future__ import absolute_import
21
# "XML is like violence: if it doesn't solve your problem, you aren't
22
# using enough of it." -- various
24
# importing this module is fairly slow because it has to load several
30
import xml.etree.cElementTree as elementtree
31
ParseError = getattr(elementtree, "ParseError", SyntaxError)
33
# Fall back to pure python implementation if C extention is unavailable
34
import xml.etree.ElementTree as elementtree
36
from xml.etree.ElementTree import ParseError
38
from xml.parsers.expat import ExpatError as ParseError
40
(ElementTree, SubElement, Element, XMLTreeBuilder, fromstring, tostring) = (
41
elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
42
elementtree.XMLTreeBuilder, elementtree.fromstring, elementtree.tostring)
54
class XMLSerializer(serializer.Serializer):
55
"""Abstract XML object serialize/deserialize"""
57
squashes_xml_invalid_characters = True
59
def read_inventory_from_string(self, xml_string, revision_id=None,
60
entry_cache=None, return_from_cache=False):
61
"""Read xml_string into an inventory object.
63
:param xml_string: The xml to read.
64
:param revision_id: If not-None, the expected revision id of the
65
inventory. Some serialisers use this to set the results' root
66
revision. This should be supplied for deserialising all
67
from-repository inventories so that xml5 inventories that were
68
serialised without a revision identifier can be given the right
69
revision id (but not for working tree inventories where users can
70
edit the data without triggering checksum errors or anything).
71
:param entry_cache: An optional cache of InventoryEntry objects. If
72
supplied we will look up entries via (file_id, revision_id) which
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.
80
return self._unpack_inventory(fromstring(xml_string), revision_id,
81
entry_cache=entry_cache,
82
return_from_cache=return_from_cache)
84
raise errors.UnexpectedInventoryFormat(e)
86
def read_inventory(self, f, revision_id=None):
89
return self._unpack_inventory(self._read_element(f),
94
raise errors.UnexpectedInventoryFormat(e)
96
def write_revision(self, rev, f):
97
self._write_element(self._pack_revision(rev), f)
99
def write_revision_to_string(self, rev):
100
return tostring(self._pack_revision(rev)) + '\n'
102
def read_revision(self, f):
103
return self._unpack_revision(self._read_element(f))
105
def read_revision_from_string(self, xml_string):
106
return self._unpack_revision(fromstring(xml_string))
108
def _write_element(self, elt, f):
109
ElementTree(elt).write(f, 'utf-8')
112
def _read_element(self, f):
113
return ElementTree().parse(f)
116
def escape_invalid_chars(message):
117
"""Escape the XML-invalid characters in a commit message.
119
:param message: Commit message to escape
120
:return: tuple with escaped message and number of characters escaped
124
# Python strings can include characters that can't be
125
# represented in well-formed XML; escape characters that
126
# aren't listed in the XML specification
127
# (http://www.w3.org/TR/REC-xml/#NT-Char).
128
return re.subn(u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
129
lambda match: match.group(0).encode('unicode_escape'),
133
def get_utf8_or_ascii(a_str, _encode_utf8=cache_utf8.encode):
134
"""Return a cached version of the string.
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.
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.
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)
154
_utf8_re = lazy_regex.lazy_compile('[&<>\'\"]|[\x80-\xff]+')
155
_unicode_re = lazy_regex.lazy_compile(u'[&<>\'\"\u0080-\uffff]')
160
"'":"'", # FIXME: overkill
167
def _unicode_escape_replace(match, _map=_xml_escape_map):
168
"""Replace a string of non-ascii, non XML safe characters with their escape
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.
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.
181
return _map[match.group()]
183
return "&#%d;" % ord(match.group())
186
def _utf8_escape_replace(match, _map=_xml_escape_map):
187
"""Escape utf8 characters into XML safe ones.
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.
195
return _map[match.group()]
197
return ''.join('&#%d;' % ord(uni_chr)
198
for uni_chr in match.group().decode('utf8'))
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)
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
217
text = str(_unicode_re.sub(_unicode_escape_replace,
218
unicode_or_utf8_str)) + '"'
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
229
"""Clean out the unicode => escaped map"""
230
_to_escaped_map.clear()
233
def unpack_inventory_entry(elt, entry_cache=None, return_from_cache=False):
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)"
240
# unmodified 4.1s 40.8s
242
# using fifo 2.83s 29.1s
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)
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
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)
271
# We copy it, because some operations may mutate it
272
cached_ie = entry_cache[key]
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()
281
return cached_ie.copy()
284
if not inventory.InventoryEntry.versionable_kind(kind):
285
raise AssertionError('unsupported entry kind %s' % kind)
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)
294
if kind == 'directory':
295
ie = inventory.InventoryDirectory(file_id,
299
ie = inventory.InventoryFile(file_id,
302
ie.text_sha1 = elt_get('text_sha1')
303
if elt_get('executable') == 'yes':
305
v = elt_get('text_size')
306
ie.text_size = v and int(v)
307
elif kind == 'symlink':
308
ie = inventory.InventoryLink(file_id,
311
ie.symlink_target = elt_get('symlink_target')
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()
325
def unpack_inventory_flat(elt, format_num, unpack_entry,
326
entry_cache=None, return_from_cache=False):
327
"""Unpack a flat XML inventory.
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
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'
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)
347
ie = unpack_entry(e, entry_cache, return_from_cache)
352
def serialize_inventory_flat(inv, append, root_id, supported_kinds, working):
353
"""Serialize an inventory to a flat XML file.
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)
360
entries = inv.iter_entries()
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)
370
if ie.kind == 'file':
372
executable = ' executable="yes"'
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,
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':
388
append('<directory file_id="%s name="%s%s%s revision="%s '
390
encode_and_escape(ie.file_id),
391
encode_and_escape(ie.name),
392
parent_str, parent_id,
393
encode_and_escape(ie.revision)))
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':
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)))
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)
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)))
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))
430
raise errors.UnsupportedInventoryKind(ie.kind)
431
append('</inventory>\n')
added
removed
bzrlib/xml_serializer.py
