← 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-23 04:13:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050923041353-6242de1098970ffe
- remove dud import

Show diffs side-by-side

added added

removed removed

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