← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml5.py

  • Committer: Aaron Bentley
  • Date: 2007-06-20 22:06:22 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070620220622-9lasxr96rr0e0xvn
Use a fresh versionedfile each time

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml5.py
1
 
#! /usr/bin/env python
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import cStringIO
 
18
import re
17
19
 
18
 
from bzrlib.xml import ElementTree, SubElement, Element, Serializer
 
20
from bzrlib import (
 
21
    cache_utf8,
 
22
    errors,
 
23
    inventory,
 
24
    )
 
25
from bzrlib.xml_serializer import SubElement, Element, Serializer
19
26
from bzrlib.inventory import ROOT_ID, Inventory, InventoryEntry
20
 
from bzrlib.revision import Revision, RevisionReference        
 
27
from bzrlib.revision import Revision
21
28
from bzrlib.errors import BzrError
22
29
 
23
30
 
24
 
 
 
31
_utf8_re = None
 
32
_unicode_re = None
 
33
_xml_escape_map = {
 
34
    "&":'&',
 
35
    "'":"'", # FIXME: overkill
 
36
    "\"":""",
 
37
    "<":"&lt;",
 
38
    ">":"&gt;",
 
39
    }
 
40
 
 
41
 
 
42
def _ensure_utf8_re():
 
43
    """Make sure the _utf8_re and _unicode_re regexes have been compiled."""
 
44
    global _utf8_re, _unicode_re
 
45
    if _utf8_re is None:
 
46
        _utf8_re = re.compile('[&<>\'\"]|[\x80-\xff]+')
 
47
    if _unicode_re is None:
 
48
        _unicode_re = re.compile(u'[&<>\'\"\u0080-\uffff]')
 
49
 
 
50
 
 
51
def _unicode_escape_replace(match, _map=_xml_escape_map):
 
52
    """Replace a string of non-ascii, non XML safe characters with their escape
 
53
 
 
54
    This will escape both Standard XML escapes, like <>"', etc.
 
55
    As well as escaping non ascii characters, because ElementTree did.
 
56
    This helps us remain compatible to older versions of bzr. We may change
 
57
    our policy in the future, though.
 
58
    """
 
59
    # jam 20060816 Benchmarks show that try/KeyError is faster if you
 
60
    # expect the entity to rarely miss. There is about a 10% difference
 
61
    # in overall time. But if you miss frequently, then if None is much
 
62
    # faster. For our use case, we *rarely* have a revision id, file id
 
63
    # or path name that is unicode. So use try/KeyError.
 
64
    try:
 
65
        return _map[match.group()]
 
66
    except KeyError:
 
67
        return "&#%d;" % ord(match.group())
 
68
 
 
69
 
 
70
def _utf8_escape_replace(match, _map=_xml_escape_map):
 
71
    """Escape utf8 characters into XML safe ones.
 
72
 
 
73
    This uses 2 tricks. It is either escaping "standard" characters, like "&<>,
 
74
    or it is handling characters with the high-bit set. For ascii characters,
 
75
    we just lookup the replacement in the dictionary. For everything else, we
 
76
    decode back into Unicode, and then use the XML escape code.
 
77
    """
 
78
    try:
 
79
        return _map[match.group()]
 
80
    except KeyError:
 
81
        return ''.join('&#%d;' % ord(uni_chr)
 
82
                       for uni_chr in match.group().decode('utf8'))
 
83
 
 
84
 
 
85
_to_escaped_map = {}
 
86
 
 
87
def _encode_and_escape(unicode_or_utf8_str, _map=_to_escaped_map):
 
88
    """Encode the string into utf8, and escape invalid XML characters"""
 
89
    # We frequently get entities we have not seen before, so it is better
 
90
    # to check if None, rather than try/KeyError
 
91
    text = _map.get(unicode_or_utf8_str)
 
92
    if text is None:
 
93
        if unicode_or_utf8_str.__class__ == unicode:
 
94
            # The alternative policy is to do a regular UTF8 encoding
 
95
            # and then escape only XML meta characters.
 
96
            # Performance is equivalent once you use cache_utf8. *However*
 
97
            # this makes the serialized texts incompatible with old versions
 
98
            # of bzr. So no net gain. (Perhaps the read code would handle utf8
 
99
            # better than entity escapes, but cElementTree seems to do just fine
 
100
            # either way)
 
101
            text = str(_unicode_re.sub(_unicode_escape_replace,
 
102
                                       unicode_or_utf8_str)) + '"'
 
103
        else:
 
104
            # Plain strings are considered to already be in utf-8 so we do a
 
105
            # slightly different method for escaping.
 
106
            text = _utf8_re.sub(_utf8_escape_replace,
 
107
                                unicode_or_utf8_str) + '"'
 
108
        _map[unicode_or_utf8_str] = text
 
109
    return text
 
110
 
 
111
 
 
112
def _get_utf8_or_ascii(a_str,
 
113
                       _encode_utf8=cache_utf8.encode,
 
114
                       _get_cached_ascii=cache_utf8.get_cached_ascii):
 
115
    """Return a cached version of the string.
 
116
 
 
117
    cElementTree will return a plain string if the XML is plain ascii. It only
 
118
    returns Unicode when it needs to. We want to work in utf-8 strings. So if
 
119
    cElementTree returns a plain string, we can just return the cached version.
 
120
    If it is Unicode, then we need to encode it.
 
121
 
 
122
    :param a_str: An 8-bit string or Unicode as returned by
 
123
                  cElementTree.Element.get()
 
124
    :return: A utf-8 encoded 8-bit string.
 
125
    """
 
126
    # This is fairly optimized because we know what cElementTree does, this is
 
127
    # not meant as a generic function for all cases. Because it is possible for
 
128
    # an 8-bit string to not be ascii or valid utf8.
 
129
    if a_str.__class__ == unicode:
 
130
        return _encode_utf8(a_str)
 
131
    else:
 
132
        return _get_cached_ascii(a_str)
 
133
 
 
134
 
 
135
def _clear_cache():
 
136
    """Clean out the unicode => escaped map"""
 
137
    _to_escaped_map.clear()
25
138
 
26
139
 
27
140
class Serializer_v5(Serializer):
31
144
    """
32
145
    
33
146
    __slots__ = []
34
 
    
35
 
    def _pack_inventory(self, inv):
36
 
        """Convert to XML Element"""
37
 
        e = Element('inventory')
38
 
        e.text = '\n'
 
147
 
 
148
    support_altered_by_hack = True
 
149
    # This format supports the altered-by hack that reads file ids directly out
 
150
    # of the versionedfile, without doing XML parsing.
 
151
 
 
152
    supported_kinds = set(['file', 'directory', 'symlink'])
 
153
 
 
154
    def write_inventory_to_string(self, inv):
 
155
        """Just call write_inventory with a StringIO and return the value"""
 
156
        sio = cStringIO.StringIO()
 
157
        self.write_inventory(inv, sio)
 
158
        return sio.getvalue()
 
159
 
 
160
    def write_inventory(self, inv, f):
 
161
        """Write inventory to a file.
 
162
        
 
163
        :param inv: the inventory to write.
 
164
        :param f: the file to write.
 
165
        """
 
166
        _ensure_utf8_re()
 
167
        output = []
 
168
        append = output.append
 
169
        self._append_inventory_root(append, inv)
 
170
        entries = inv.iter_entries()
 
171
        # Skip the root
 
172
        root_path, root_ie = entries.next()
 
173
        for path, ie in entries:
 
174
            self._append_entry(append, ie)
 
175
        append('</inventory>\n')
 
176
        f.writelines(output)
 
177
        # Just to keep the cache from growing without bounds
 
178
        # but we may actually not want to do clear the cache
 
179
        #_clear_cache()
 
180
 
 
181
    def _append_inventory_root(self, append, inv):
 
182
        """Append the inventory root to output."""
 
183
        append('<inventory')
39
184
        if inv.root.file_id not in (None, ROOT_ID):
40
 
            e.set('file_id', inv.root.file_id)
41
 
        for path, ie in inv.iter_entries():
42
 
            e.append(self._pack_entry(ie))
43
 
        return e
44
 
 
45
 
 
46
 
    def _pack_entry(self, ie):
47
 
        """Convert InventoryEntry to XML element"""
48
 
        assert ie.kind == 'directory' or ie.kind == 'file'
49
 
        e = Element(ie.kind)
50
 
        e.set('name', ie.name)
51
 
        e.set('file_id', ie.file_id)
52
 
 
53
 
        if ie.text_size != None:
54
 
            e.set('text_size', '%d' % ie.text_size)
55
 
 
56
 
        for f in ['text_version', 'text_sha1', 'entry_version']:
57
 
            v = getattr(ie, f)
58
 
            if v != None:
59
 
                e.set(f, v)
60
 
 
61
 
        # to be conservative, we don't externalize the root pointers
62
 
        # for now, leaving them as null in the xml form.  in a future
63
 
        # version it will be implied by nested elements.
64
 
        if ie.parent_id != ROOT_ID:
 
185
            append(' file_id="')
 
186
            append(_encode_and_escape(inv.root.file_id))
 
187
        append(' format="5"')
 
188
        if inv.revision_id is not None:
 
189
            append(' revision_id="')
 
190
            append(_encode_and_escape(inv.revision_id))
 
191
        append('>\n')
 
192
        
 
193
    def _append_entry(self, append, ie):
 
194
        """Convert InventoryEntry to XML element and append to output."""
 
195
        # TODO: should just be a plain assertion
 
196
        if ie.kind not in self.supported_kinds:
 
197
            raise errors.UnsupportedInventoryKind(ie.kind)
 
198
 
 
199
        append("<")
 
200
        append(ie.kind)
 
201
        if ie.executable:
 
202
            append(' executable="yes"')
 
203
        append(' file_id="')
 
204
        append(_encode_and_escape(ie.file_id))
 
205
        append(' name="')
 
206
        append(_encode_and_escape(ie.name))
 
207
        if self._parent_condition(ie):
65
208
            assert isinstance(ie.parent_id, basestring)
66
 
            e.set('parent_id', ie.parent_id)
67
 
 
68
 
        e.tail = '\n'
69
 
 
70
 
        return e
71
 
 
 
209
            append(' parent_id="')
 
210
            append(_encode_and_escape(ie.parent_id))
 
211
        if ie.revision is not None:
 
212
            append(' revision="')
 
213
            append(_encode_and_escape(ie.revision))
 
214
        if ie.symlink_target is not None:
 
215
            append(' symlink_target="')
 
216
            append(_encode_and_escape(ie.symlink_target))
 
217
        if ie.text_sha1 is not None:
 
218
            append(' text_sha1="')
 
219
            append(ie.text_sha1)
 
220
            append('"')
 
221
        if ie.text_size is not None:
 
222
            append(' text_size="%d"' % ie.text_size)
 
223
        if getattr(ie, 'reference_revision', None) is not None:
 
224
            append(' reference_revision="')
 
225
            append(_encode_and_escape(ie.reference_revision))
 
226
        append(" />\n")
 
227
        return
 
228
 
 
229
    def _parent_condition(self, ie):
 
230
        return ie.parent_id != ROOT_ID
72
231
 
73
232
    def _pack_revision(self, rev):
74
233
        """Revision object -> xml tree"""
 
234
        # For the XML format, we need to write them as Unicode rather than as
 
235
        # utf-8 strings. So that cElementTree can handle properly escaping
 
236
        # them.
 
237
        decode_utf8 = cache_utf8.decode
 
238
        revision_id = rev.revision_id
 
239
        if isinstance(revision_id, str):
 
240
            revision_id = decode_utf8(revision_id)
75
241
        root = Element('revision',
76
242
                       committer = rev.committer,
77
 
                       timestamp = '%.9f' % rev.timestamp,
78
 
                       revision_id = rev.revision_id,
 
243
                       timestamp = '%.3f' % rev.timestamp,
 
244
                       revision_id = revision_id,
79
245
                       inventory_sha1 = rev.inventory_sha1,
 
246
                       format='5',
80
247
                       )
81
 
        if rev.timezone:
 
248
        if rev.timezone is not None:
82
249
            root.set('timezone', str(rev.timezone))
83
250
        root.text = '\n'
84
 
 
85
251
        msg = SubElement(root, 'message')
86
252
        msg.text = rev.message
87
253
        msg.tail = '\n'
88
 
 
89
 
        if rev.parents:
 
254
        if rev.parent_ids:
90
255
            pelts = SubElement(root, 'parents')
91
256
            pelts.tail = pelts.text = '\n'
92
 
            for rr in rev.parents:
93
 
                assert isinstance(rr, RevisionReference)
 
257
            for parent_id in rev.parent_ids:
 
258
                assert isinstance(parent_id, basestring)
94
259
                p = SubElement(pelts, 'revision_ref')
95
260
                p.tail = '\n'
96
 
                assert rr.revision_id
97
 
                p.set('revision_id', rr.revision_id)
98
 
 
 
261
                if isinstance(parent_id, str):
 
262
                    parent_id = decode_utf8(parent_id)
 
263
                p.set('revision_id', parent_id)
 
264
        if rev.properties:
 
265
            self._pack_revision_properties(rev, root)
99
266
        return root
100
267
 
101
 
    
 
268
    def _pack_revision_properties(self, rev, under_element):
 
269
        top_elt = SubElement(under_element, 'properties')
 
270
        for prop_name, prop_value in sorted(rev.properties.items()):
 
271
            assert isinstance(prop_name, basestring) 
 
272
            assert isinstance(prop_value, basestring) 
 
273
            prop_elt = SubElement(top_elt, 'property')
 
274
            prop_elt.set('name', prop_name)
 
275
            prop_elt.text = prop_value
 
276
            prop_elt.tail = '\n'
 
277
        top_elt.tail = '\n'
102
278
 
103
279
    def _unpack_inventory(self, elt):
104
280
        """Construct from XML Element
105
281
        """
106
282
        assert elt.tag == 'inventory'
107
283
        root_id = elt.get('file_id') or ROOT_ID
108
 
        inv = Inventory(root_id)
 
284
        root_id = _get_utf8_or_ascii(root_id)
 
285
 
 
286
        format = elt.get('format')
 
287
        if format is not None:
 
288
            if format != '5':
 
289
                raise BzrError("invalid format version %r on inventory"
 
290
                                % format)
 
291
        revision_id = elt.get('revision_id')
 
292
        if revision_id is not None:
 
293
            revision_id = cache_utf8.encode(revision_id)
 
294
        inv = Inventory(root_id, revision_id=revision_id)
109
295
        for e in elt:
110
296
            ie = self._unpack_entry(e)
111
 
            if ie.parent_id == ROOT_ID:
 
297
            if ie.parent_id is None:
112
298
                ie.parent_id = root_id
113
299
            inv.add(ie)
114
300
        return inv
115
301
 
116
 
 
117
302
    def _unpack_entry(self, elt):
118
303
        kind = elt.tag
119
 
        assert kind == 'directory' or kind == 'file'
 
304
        if not InventoryEntry.versionable_kind(kind):
 
305
            raise AssertionError('unsupported entry kind %s' % kind)
 
306
 
 
307
        get_cached = _get_utf8_or_ascii
120
308
 
121
309
        parent_id = elt.get('parent_id')
122
 
        if parent_id == None:
123
 
            parent_id = ROOT_ID
 
310
        if parent_id is not None:
 
311
            parent_id = get_cached(parent_id)
 
312
        file_id = get_cached(elt.get('file_id'))
124
313
 
125
 
        ie = InventoryEntry(elt.get('file_id'),
126
 
                            elt.get('name'),
127
 
                            kind,
128
 
                            parent_id)
129
 
        ie.text_version = elt.get('text_version')
130
 
        ie.entry_version = elt.get('entry_version')
131
 
        ie.text_sha1 = elt.get('text_sha1')
132
 
        v = elt.get('text_size')
133
 
        ie.text_size = v and int(v)
 
314
        if kind == 'directory':
 
315
            ie = inventory.InventoryDirectory(file_id,
 
316
                                              elt.get('name'),
 
317
                                              parent_id)
 
318
        elif kind == 'file':
 
319
            ie = inventory.InventoryFile(file_id,
 
320
                                         elt.get('name'),
 
321
                                         parent_id)
 
322
            ie.text_sha1 = elt.get('text_sha1')
 
323
            if elt.get('executable') == 'yes':
 
324
                ie.executable = True
 
325
            v = elt.get('text_size')
 
326
            ie.text_size = v and int(v)
 
327
        elif kind == 'symlink':
 
328
            ie = inventory.InventoryLink(file_id,
 
329
                                         elt.get('name'),
 
330
                                         parent_id)
 
331
            ie.symlink_target = elt.get('symlink_target')
 
332
        else:
 
333
            raise errors.UnsupportedInventoryKind(kind)
 
334
        revision = elt.get('revision')
 
335
        if revision is not None:
 
336
            revision = get_cached(revision)
 
337
        ie.revision = revision
134
338
 
135
339
        return ie
136
340
 
137
 
 
138
341
    def _unpack_revision(self, elt):
139
342
        """XML Element -> Revision object"""
140
343
        assert elt.tag == 'revision'
141
 
        
 
344
        format = elt.get('format')
 
345
        if format is not None:
 
346
            if format != '5':
 
347
                raise BzrError("invalid format version %r on inventory"
 
348
                                % format)
 
349
        get_cached = _get_utf8_or_ascii
142
350
        rev = Revision(committer = elt.get('committer'),
143
351
                       timestamp = float(elt.get('timestamp')),
144
 
                       revision_id = elt.get('revision_id'),
 
352
                       revision_id = get_cached(elt.get('revision_id')),
145
353
                       inventory_sha1 = elt.get('inventory_sha1')
146
354
                       )
147
 
 
148
355
        parents = elt.find('parents') or []
149
356
        for p in parents:
150
357
            assert p.tag == 'revision_ref', \
151
358
                   "bad parent node tag %r" % p.tag
152
 
            rev_ref = RevisionReference(p.get('revision_id'))
153
 
            rev.parents.append(rev_ref)
154
 
 
 
359
            rev.parent_ids.append(get_cached(p.get('revision_id')))
 
360
        self._unpack_revision_properties(elt, rev)
155
361
        v = elt.get('timezone')
156
 
        rev.timezone = v and int(v)
157
 
 
 
362
        if v is None:
 
363
            rev.timezone = 0
 
364
        else:
 
365
            rev.timezone = int(v)
158
366
        rev.message = elt.findtext('message') # text of <message>
159
367
        return rev
160
368
 
 
369
    def _unpack_revision_properties(self, elt, rev):
 
370
        """Unpack properties onto a revision."""
 
371
        props_elt = elt.find('properties')
 
372
        assert len(rev.properties) == 0
 
373
        if not props_elt:
 
374
            return
 
375
        for prop_elt in props_elt:
 
376
            assert prop_elt.tag == 'property', \
 
377
                "bad tag under properties list: %r" % prop_elt.tag
 
378
            name = prop_elt.get('name')
 
379
            value = prop_elt.text
 
380
            # If a property had an empty value ('') cElementTree reads
 
381
            # that back as None, convert it back to '', so that all
 
382
            # properties have string values
 
383
            if value is None:
 
384
                value = ''
 
385
            assert name not in rev.properties, \
 
386
                "repeated property %r" % name
 
387
            rev.properties[name] = value
161
388
 
162
389
 
163
390
serializer_v5 = Serializer_v5()