← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml5.py

  • Committer: Martin Pool
  • Date: 2006-01-13 08:12:22 UTC
  • mfrom: (1185.63.5 bzr.patches)
  • Revision ID: mbp@sourcefrog.net-20060113081222-6b572004a2ade0cc
[merge] test_hashcache_raise from Denys

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml5.py
1
 
#! /usr/bin/env python
2
 
 
3
1
# This program is free software; you can redistribute it and/or modify
4
2
# it under the terms of the GNU General Public License as published by
5
3
# the Free Software Foundation; either version 2 of the License, or
17
15
 
18
16
from bzrlib.xml import ElementTree, SubElement, Element, Serializer
19
17
from bzrlib.inventory import ROOT_ID, Inventory, InventoryEntry
20
 
from bzrlib.revision import Revision, RevisionReference        
 
18
import bzrlib.inventory as inventory
 
19
from bzrlib.revision import Revision        
21
20
from bzrlib.errors import BzrError
22
21
 
23
22
 
24
 
 
25
 
 
26
 
 
27
23
class Serializer_v5(Serializer):
28
24
    """Version 5 serializer
29
25
 
34
30
    
35
31
    def _pack_inventory(self, inv):
36
32
        """Convert to XML Element"""
37
 
        e = Element('inventory')
 
33
        e = Element('inventory',
 
34
                    format='5')
38
35
        e.text = '\n'
39
36
        if inv.root.file_id not in (None, ROOT_ID):
40
37
            e.set('file_id', inv.root.file_id)
45
42
 
46
43
    def _pack_entry(self, ie):
47
44
        """Convert InventoryEntry to XML element"""
48
 
        assert ie.kind == 'directory' or ie.kind == 'file'
 
45
        if not InventoryEntry.versionable_kind(ie.kind):
 
46
            raise AssertionError('unsupported entry kind %s' % ie.kind)
49
47
        e = Element(ie.kind)
50
48
        e.set('name', ie.name)
51
49
        e.set('file_id', ie.file_id)
53
51
        if ie.text_size != None:
54
52
            e.set('text_size', '%d' % ie.text_size)
55
53
 
56
 
        for f in ['text_version', 'text_sha1', 'entry_version']:
 
54
        for f in ['text_sha1', 'revision', 'symlink_target']:
57
55
            v = getattr(ie, f)
58
56
            if v != None:
59
57
                e.set(f, v)
60
58
 
 
59
        if ie.executable:
 
60
            e.set('executable', 'yes')
 
61
 
61
62
        # to be conservative, we don't externalize the root pointers
62
63
        # for now, leaving them as null in the xml form.  in a future
63
64
        # version it will be implied by nested elements.
77
78
                       timestamp = '%.9f' % rev.timestamp,
78
79
                       revision_id = rev.revision_id,
79
80
                       inventory_sha1 = rev.inventory_sha1,
 
81
                       format='5',
80
82
                       )
81
83
        if rev.timezone:
82
84
            root.set('timezone', str(rev.timezone))
83
85
        root.text = '\n'
84
 
 
85
86
        msg = SubElement(root, 'message')
86
87
        msg.text = rev.message
87
88
        msg.tail = '\n'
88
 
 
89
 
        if rev.parents:
 
89
        if rev.parent_ids:
90
90
            pelts = SubElement(root, 'parents')
91
91
            pelts.tail = pelts.text = '\n'
92
 
            for rr in rev.parents:
93
 
                assert isinstance(rr, RevisionReference)
 
92
            for parent_id in rev.parent_ids:
 
93
                assert isinstance(parent_id, basestring)
94
94
                p = SubElement(pelts, 'revision_ref')
95
95
                p.tail = '\n'
96
 
                assert rr.revision_id
97
 
                p.set('revision_id', rr.revision_id)
98
 
 
 
96
                p.set('revision_id', parent_id)
 
97
        if rev.properties:
 
98
            self._pack_revision_properties(rev, root)
99
99
        return root
100
100
 
101
 
    
 
101
 
 
102
    def _pack_revision_properties(self, rev, under_element):
 
103
        top_elt = SubElement(under_element, 'properties')
 
104
        for prop_name, prop_value in sorted(rev.properties.items()):
 
105
            assert isinstance(prop_name, basestring) 
 
106
            assert isinstance(prop_value, basestring) 
 
107
            prop_elt = SubElement(top_elt, 'property')
 
108
            prop_elt.set('name', prop_name)
 
109
            prop_elt.text = prop_value
 
110
            prop_elt.tail = '\n'
 
111
        top_elt.tail = '\n'
 
112
 
102
113
 
103
114
    def _unpack_inventory(self, elt):
104
115
        """Construct from XML Element
105
116
        """
106
117
        assert elt.tag == 'inventory'
107
118
        root_id = elt.get('file_id') or ROOT_ID
 
119
        format = elt.get('format')
 
120
        if format is not None:
 
121
            if format != '5':
 
122
                raise BzrError("invalid format version %r on inventory"
 
123
                                % format)
108
124
        inv = Inventory(root_id)
109
125
        for e in elt:
110
126
            ie = self._unpack_entry(e)
116
132
 
117
133
    def _unpack_entry(self, elt):
118
134
        kind = elt.tag
119
 
        assert kind == 'directory' or kind == 'file'
 
135
        if not InventoryEntry.versionable_kind(kind):
 
136
            raise AssertionError('unsupported entry kind %s' % kind)
120
137
 
121
138
        parent_id = elt.get('parent_id')
122
139
        if parent_id == None:
123
140
            parent_id = ROOT_ID
124
141
 
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)
 
142
        if kind == 'directory':
 
143
            ie = inventory.InventoryDirectory(elt.get('file_id'),
 
144
                                              elt.get('name'),
 
145
                                              parent_id)
 
146
        elif kind == 'file':
 
147
            ie = inventory.InventoryFile(elt.get('file_id'),
 
148
                                         elt.get('name'),
 
149
                                         parent_id)
 
150
            ie.text_sha1 = elt.get('text_sha1')
 
151
            if elt.get('executable') == 'yes':
 
152
                ie.executable = True
 
153
            v = elt.get('text_size')
 
154
            ie.text_size = v and int(v)
 
155
        elif kind == 'symlink':
 
156
            ie = inventory.InventoryLink(elt.get('file_id'),
 
157
                                         elt.get('name'),
 
158
                                         parent_id)
 
159
            ie.symlink_target = elt.get('symlink_target')
 
160
        else:
 
161
            raise BzrError("unknown kind %r" % kind)
 
162
        ie.revision = elt.get('revision')
134
163
 
135
164
        return ie
136
165
 
138
167
    def _unpack_revision(self, elt):
139
168
        """XML Element -> Revision object"""
140
169
        assert elt.tag == 'revision'
141
 
        
 
170
        format = elt.get('format')
 
171
        if format is not None:
 
172
            if format != '5':
 
173
                raise BzrError("invalid format version %r on inventory"
 
174
                                % format)
142
175
        rev = Revision(committer = elt.get('committer'),
143
176
                       timestamp = float(elt.get('timestamp')),
144
177
                       revision_id = elt.get('revision_id'),
145
178
                       inventory_sha1 = elt.get('inventory_sha1')
146
179
                       )
147
 
 
148
180
        parents = elt.find('parents') or []
149
181
        for p in parents:
150
182
            assert p.tag == 'revision_ref', \
151
183
                   "bad parent node tag %r" % p.tag
152
 
            rev_ref = RevisionReference(p.get('revision_id'))
153
 
            rev.parents.append(rev_ref)
154
 
 
 
184
            rev.parent_ids.append(p.get('revision_id'))
 
185
        self._unpack_revision_properties(elt, rev)
155
186
        v = elt.get('timezone')
156
187
        rev.timezone = v and int(v)
157
 
 
158
188
        rev.message = elt.findtext('message') # text of <message>
159
189
        return rev
160
190
 
161
191
 
 
192
    def _unpack_revision_properties(self, elt, rev):
 
193
        """Unpack properties onto a revision."""
 
194
        props_elt = elt.find('properties')
 
195
        assert len(rev.properties) == 0
 
196
        if not props_elt:
 
197
            return
 
198
        for prop_elt in props_elt:
 
199
            assert prop_elt.tag == 'property', \
 
200
                "bad tag under properties list: %r" % p.tag
 
201
            name = prop_elt.get('name')
 
202
            value = prop_elt.text
 
203
            assert name not in rev.properties, \
 
204
                "repeated property %r" % p.name
 
205
            rev.properties[name] = value
 
206
 
162
207
 
163
208
serializer_v5 = Serializer_v5()