/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/xml5.py

  • Committer: John Arbash Meinel
  • Date: 2006-08-16 23:38:03 UTC
  • mto: This revision was merged to the branch mainline in revision 1942.
  • Revision ID: john@arbash-meinel.com-20060816233803-9c192384559be0fa
Caching revision_ids costs us a little (512 vs 475), but caching file-ids costs us a lot (780 vs 512), so disabling caching of file ids for now

Show diffs side-by-side

added added

removed removed

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