← 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: 2005-09-16 08:23:10 UTC
  • Revision ID: mbp@sourcefrog.net-20050916082310-ecb5a25c40253839
- wrap wide strings when showing exceptions

Show diffs side-by-side

added added

removed removed

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