← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml5.py

Update news and readme

- better explanation of dependencies

Show diffs side-by-side

added added

removed removed

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