~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml5.py

  • Committer: Wouter van Heyst
  • Date: 2007-01-18 18:37:21 UTC
  • mto: (2234.3.3 0.14)
  • mto: This revision was merged to the branch mainline in revision 2243.
  • Revision ID: larstiq@larstiq.dyndns.org-20070118183721-78uzxifyyyoqxja9
(Alexander Belchenko) add windows installer check for python2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#! /usr/bin/env python
2
 
 
 
1
# Copyright (C) 2005, 2006 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
    inventory,
 
23
    )
 
24
from bzrlib.xml_serializer import SubElement, Element, Serializer
19
25
from bzrlib.inventory import ROOT_ID, Inventory, InventoryEntry
20
 
from bzrlib.revision import Revision, RevisionReference        
 
26
from bzrlib.revision import Revision
21
27
from bzrlib.errors import BzrError
22
28
 
23
29
 
24
 
 
 
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()
25
90
 
26
91
 
27
92
class Serializer_v5(Serializer):
31
96
    """
32
97
    
33
98
    __slots__ = []
34
 
    
35
 
    def _pack_inventory(self, inv):
36
 
        """Convert to XML Element"""
37
 
        e = Element('inventory')
38
 
        e.text = '\n'
 
99
 
 
100
    support_altered_by_hack = True
 
101
    # This format supports the altered-by hack that reads file ids directly out
 
102
    # of the versionedfile, without doing XML parsing.
 
103
 
 
104
    def write_inventory_to_string(self, inv):
 
105
        """Just call write_inventory with a StringIO and return the value"""
 
106
        sio = cStringIO.StringIO()
 
107
        self.write_inventory(inv, sio)
 
108
        return sio.getvalue()
 
109
 
 
110
    def write_inventory(self, inv, f):
 
111
        """Write inventory to a file.
 
112
        
 
113
        :param inv: the inventory to write.
 
114
        :param f: the file to write.
 
115
        """
 
116
        _ensure_utf8_re()
 
117
        output = []
 
118
        append = output.append
 
119
        self._append_inventory_root(append, inv)
 
120
        entries = inv.iter_entries()
 
121
        # Skip the root
 
122
        root_path, root_ie = entries.next()
 
123
        for path, ie in entries:
 
124
            self._append_entry(append, ie)
 
125
        append('</inventory>\n')
 
126
        f.writelines(output)
 
127
        # Just to keep the cache from growing without bounds
 
128
        # but we may actually not want to do clear the cache
 
129
        #_clear_cache()
 
130
 
 
131
    def _append_inventory_root(self, append, inv):
 
132
        """Append the inventory root to output."""
 
133
        append('<inventory')
39
134
        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:
 
135
            append(' file_id="')
 
136
            append(_encode_and_escape(inv.root.file_id))
 
137
        append(' format="5"')
 
138
        if inv.revision_id is not None:
 
139
            append(' revision_id="')
 
140
            append(_encode_and_escape(inv.revision_id))
 
141
        append('>\n')
 
142
        
 
143
    def _append_entry(self, append, ie):
 
144
        """Convert InventoryEntry to XML element and append to output."""
 
145
        # TODO: should just be a plain assertion
 
146
        assert InventoryEntry.versionable_kind(ie.kind), \
 
147
            'unsupported entry kind %s' % ie.kind
 
148
 
 
149
        append("<")
 
150
        append(ie.kind)
 
151
        if ie.executable:
 
152
            append(' executable="yes"')
 
153
        append(' file_id="')
 
154
        append(_encode_and_escape(ie.file_id))
 
155
        append(' name="')
 
156
        append(_encode_and_escape(ie.name))
 
157
        if self._parent_condition(ie):
65
158
            assert isinstance(ie.parent_id, basestring)
66
 
            e.set('parent_id', ie.parent_id)
67
 
 
68
 
        e.tail = '\n'
69
 
 
70
 
        return e
71
 
 
 
159
            append(' parent_id="')
 
160
            append(_encode_and_escape(ie.parent_id))
 
161
        if ie.revision is not None:
 
162
            append(' revision="')
 
163
            append(_encode_and_escape(ie.revision))
 
164
        if ie.symlink_target is not None:
 
165
            append(' symlink_target="')
 
166
            append(_encode_and_escape(ie.symlink_target))
 
167
        if ie.text_sha1 is not None:
 
168
            append(' text_sha1="')
 
169
            append(ie.text_sha1)
 
170
            append('"')
 
171
        if ie.text_size is not None:
 
172
            append(' text_size="%d"' % ie.text_size)
 
173
        append(" />\n")
 
174
        return
 
175
 
 
176
    def _parent_condition(self, ie):
 
177
        return ie.parent_id != ROOT_ID
72
178
 
73
179
    def _pack_revision(self, rev):
74
180
        """Revision object -> xml tree"""
75
181
        root = Element('revision',
76
182
                       committer = rev.committer,
77
 
                       timestamp = '%.9f' % rev.timestamp,
 
183
                       timestamp = '%.3f' % rev.timestamp,
78
184
                       revision_id = rev.revision_id,
79
185
                       inventory_sha1 = rev.inventory_sha1,
 
186
                       format='5',
80
187
                       )
81
 
        if rev.timezone:
 
188
        if rev.timezone is not None:
82
189
            root.set('timezone', str(rev.timezone))
83
190
        root.text = '\n'
84
 
 
85
191
        msg = SubElement(root, 'message')
86
192
        msg.text = rev.message
87
193
        msg.tail = '\n'
88
 
 
89
 
        if rev.parents:
 
194
        if rev.parent_ids:
90
195
            pelts = SubElement(root, 'parents')
91
196
            pelts.tail = pelts.text = '\n'
92
 
            for rr in rev.parents:
93
 
                assert isinstance(rr, RevisionReference)
 
197
            for parent_id in rev.parent_ids:
 
198
                assert isinstance(parent_id, basestring)
94
199
                p = SubElement(pelts, 'revision_ref')
95
200
                p.tail = '\n'
96
 
                assert rr.revision_id
97
 
                p.set('revision_id', rr.revision_id)
98
 
 
 
201
                p.set('revision_id', parent_id)
 
202
        if rev.properties:
 
203
            self._pack_revision_properties(rev, root)
99
204
        return root
100
205
 
101
 
    
 
206
    def _pack_revision_properties(self, rev, under_element):
 
207
        top_elt = SubElement(under_element, 'properties')
 
208
        for prop_name, prop_value in sorted(rev.properties.items()):
 
209
            assert isinstance(prop_name, basestring) 
 
210
            assert isinstance(prop_value, basestring) 
 
211
            prop_elt = SubElement(top_elt, 'property')
 
212
            prop_elt.set('name', prop_name)
 
213
            prop_elt.text = prop_value
 
214
            prop_elt.tail = '\n'
 
215
        top_elt.tail = '\n'
102
216
 
103
217
    def _unpack_inventory(self, elt):
104
218
        """Construct from XML Element
105
219
        """
106
220
        assert elt.tag == 'inventory'
107
221
        root_id = elt.get('file_id') or ROOT_ID
108
 
        inv = Inventory(root_id)
 
222
        format = elt.get('format')
 
223
        if format is not None:
 
224
            if format != '5':
 
225
                raise BzrError("invalid format version %r on inventory"
 
226
                                % format)
 
227
        revision_id = elt.get('revision_id')
 
228
        if revision_id is not None:
 
229
            revision_id = cache_utf8.get_cached_unicode(revision_id)
 
230
        inv = Inventory(root_id, revision_id=revision_id)
109
231
        for e in elt:
110
232
            ie = self._unpack_entry(e)
111
233
            if ie.parent_id == ROOT_ID:
113
235
            inv.add(ie)
114
236
        return inv
115
237
 
116
 
 
117
 
    def _unpack_entry(self, elt):
 
238
    def _unpack_entry(self, elt, none_parents=False):
118
239
        kind = elt.tag
119
 
        assert kind == 'directory' or kind == 'file'
 
240
        if not InventoryEntry.versionable_kind(kind):
 
241
            raise AssertionError('unsupported entry kind %s' % kind)
 
242
 
 
243
        get_cached = cache_utf8.get_cached_unicode
120
244
 
121
245
        parent_id = elt.get('parent_id')
122
 
        if parent_id == None:
 
246
        if parent_id is None and not none_parents:
123
247
            parent_id = ROOT_ID
 
248
        # TODO: jam 20060817 At present, caching file ids costs us too 
 
249
        #       much time. It slows down overall read performances from
 
250
        #       approx 500ms to 700ms. And doesn't improve future reads.
 
251
        #       it might be because revision ids and file ids are mixing.
 
252
        #       Consider caching *just* the file ids, for a limited period
 
253
        #       of time.
 
254
        #parent_id = get_cached(parent_id)
 
255
        #file_id = get_cached(elt.get('file_id'))
 
256
        file_id = elt.get('file_id')
124
257
 
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)
 
258
        if kind == 'directory':
 
259
            ie = inventory.InventoryDirectory(file_id,
 
260
                                              elt.get('name'),
 
261
                                              parent_id)
 
262
        elif kind == 'file':
 
263
            ie = inventory.InventoryFile(file_id,
 
264
                                         elt.get('name'),
 
265
                                         parent_id)
 
266
            ie.text_sha1 = elt.get('text_sha1')
 
267
            if elt.get('executable') == 'yes':
 
268
                ie.executable = True
 
269
            v = elt.get('text_size')
 
270
            ie.text_size = v and int(v)
 
271
        elif kind == 'symlink':
 
272
            ie = inventory.InventoryLink(file_id,
 
273
                                         elt.get('name'),
 
274
                                         parent_id)
 
275
            ie.symlink_target = elt.get('symlink_target')
 
276
        else:
 
277
            raise BzrError("unknown kind %r" % kind)
 
278
        revision = elt.get('revision')
 
279
        if revision is not None:
 
280
            revision = get_cached(revision)
 
281
        ie.revision = revision
134
282
 
135
283
        return ie
136
284
 
137
 
 
138
285
    def _unpack_revision(self, elt):
139
286
        """XML Element -> Revision object"""
140
287
        assert elt.tag == 'revision'
141
 
        
 
288
        format = elt.get('format')
 
289
        if format is not None:
 
290
            if format != '5':
 
291
                raise BzrError("invalid format version %r on inventory"
 
292
                                % format)
 
293
        get_cached = cache_utf8.get_cached_unicode
142
294
        rev = Revision(committer = elt.get('committer'),
143
295
                       timestamp = float(elt.get('timestamp')),
144
 
                       revision_id = elt.get('revision_id'),
 
296
                       revision_id = get_cached(elt.get('revision_id')),
145
297
                       inventory_sha1 = elt.get('inventory_sha1')
146
298
                       )
147
 
 
148
299
        parents = elt.find('parents') or []
149
300
        for p in parents:
150
301
            assert p.tag == 'revision_ref', \
151
302
                   "bad parent node tag %r" % p.tag
152
 
            rev_ref = RevisionReference(p.get('revision_id'))
153
 
            rev.parents.append(rev_ref)
154
 
 
 
303
            rev.parent_ids.append(get_cached(p.get('revision_id')))
 
304
        self._unpack_revision_properties(elt, rev)
155
305
        v = elt.get('timezone')
156
 
        rev.timezone = v and int(v)
157
 
 
 
306
        if v is None:
 
307
            rev.timezone = 0
 
308
        else:
 
309
            rev.timezone = int(v)
158
310
        rev.message = elt.findtext('message') # text of <message>
159
311
        return rev
160
312
 
 
313
    def _unpack_revision_properties(self, elt, rev):
 
314
        """Unpack properties onto a revision."""
 
315
        props_elt = elt.find('properties')
 
316
        assert len(rev.properties) == 0
 
317
        if not props_elt:
 
318
            return
 
319
        for prop_elt in props_elt:
 
320
            assert prop_elt.tag == 'property', \
 
321
                "bad tag under properties list: %r" % prop_elt.tag
 
322
            name = prop_elt.get('name')
 
323
            value = prop_elt.text
 
324
            # If a property had an empty value ('') cElementTree reads
 
325
            # that back as None, convert it back to '', so that all
 
326
            # properties have string values
 
327
            if value is None:
 
328
                value = ''
 
329
            assert name not in rev.properties, \
 
330
                "repeated property %r" % name
 
331
            rev.properties[name] = value
161
332
 
162
333
 
163
334
serializer_v5 = Serializer_v5()