/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: Aaron Bentley
  • Date: 2007-02-16 07:02:19 UTC
  • mfrom: (2292 +trunk)
  • mto: (2255.6.1 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: aaron.bentley@utoronto.ca-20070216070219-b22k0gwnisnxawnk
Merged bzr.dev (17 tests failing)

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