~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revision.py

  • Committer: Martin Pool
  • Date: 2005-07-04 05:12:59 UTC
  • Revision ID: mbp@sourcefrog.net-20050704051259-a001ad74f39dadb7
- New log --long option

  Patch from William Dodé

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
#
 
1
# (C) 2005 Canonical
 
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
 
# TODO: Some kind of command-line display of revision properties: 
18
 
# perhaps show them in log -v and allow them as options to the commit command.
19
 
 
20
 
 
21
 
import bzrlib.errors as errors
22
 
from bzrlib.graph import node_distances, select_farthest, all_descendants, Graph
23
 
from bzrlib.osutils import contains_whitespace
24
 
from bzrlib.progress import DummyProgress
25
 
from bzrlib.symbol_versioning import (deprecated_function,
26
 
        zero_eight,
27
 
        )
28
 
 
29
 
NULL_REVISION="null:"
30
 
CURRENT_REVISION="current:"
 
17
 
 
18
 
 
19
 
 
20
class RevisionReference(object):
 
21
    """
 
22
    Reference to a stored revision.
 
23
 
 
24
    Includes the revision_id and revision_sha1.
 
25
    """
 
26
    revision_id = None
 
27
    revision_sha1 = None
 
28
    def __init__(self, revision_id, revision_sha1):
 
29
        if revision_id == None \
 
30
           or isinstance(revision_id, basestring):
 
31
            self.revision_id = revision_id
 
32
        else:
 
33
            raise ValueError('bad revision_id %r' % revision_id)
 
34
 
 
35
        if revision_sha1 != None:
 
36
            if isinstance(revision_sha1, basestring) \
 
37
               and len(revision_sha1) == 40:
 
38
                self.revision_sha1 = revision_sha1
 
39
            else:
 
40
                raise ValueError('bad revision_sha1 %r' % revision_sha1)
 
41
                
31
42
 
32
43
 
33
44
class Revision(object):
38
49
    into the file it describes.
39
50
 
40
51
    After bzr 0.0.5 revisions are allowed to have multiple parents.
41
 
 
42
 
    parent_ids
43
 
        List of parent revision_ids
44
 
 
45
 
    properties
46
 
        Dictionary of revision properties.  These are attached to the
47
 
        revision as extra metadata.  The name must be a single 
48
 
        word; the value can be an arbitrary string.
 
52
    To support old clients this is written out in a slightly redundant
 
53
    form: the first parent as the predecessor.  This will eventually
 
54
    be dropped.
 
55
 
 
56
    parents
 
57
        List of parent revisions, each is a RevisionReference.
49
58
    """
 
59
    inventory_id = None
 
60
    inventory_sha1 = None
 
61
    revision_id = None
 
62
    timestamp = None
 
63
    message = None
 
64
    timezone = None
 
65
    committer = None
50
66
    
51
 
    def __init__(self, revision_id, properties=None, **args):
52
 
        self.revision_id = revision_id
53
 
        self.properties = properties or {}
54
 
        self._check_properties()
55
 
        self.parent_ids = []
56
 
        self.parent_sha1s = []
57
 
        """Not used anymore - legacy from for 4."""
 
67
    def __init__(self, **args):
58
68
        self.__dict__.update(args)
 
69
        self.parents = []
 
70
 
 
71
    def _get_precursor(self):
 
72
        from warnings import warn
 
73
        warn("Revision.precursor is deprecated", stacklevel=2)
 
74
        if self.parents:
 
75
            return self.parents[0].revision_id
 
76
        else:
 
77
            return None
 
78
 
 
79
 
 
80
    def _get_precursor_sha1(self):
 
81
        from warnings import warn
 
82
        warn("Revision.precursor_sha1 is deprecated", stacklevel=2)
 
83
        if self.parents:
 
84
            return self.parents[0].revision_sha1
 
85
        else:
 
86
            return None    
 
87
 
 
88
 
 
89
    def _fail(self):
 
90
        raise Exception("can't assign to precursor anymore")
 
91
 
 
92
 
 
93
    precursor = property(_get_precursor, _fail, _fail)
 
94
    precursor_sha1 = property(_get_precursor_sha1, _fail, _fail)
 
95
 
 
96
 
59
97
 
60
98
    def __repr__(self):
61
99
        return "<Revision id %s>" % self.revision_id
62
100
 
63
 
    def __eq__(self, other):
64
 
        if not isinstance(other, Revision):
65
 
            return False
66
 
        # FIXME: rbc 20050930 parent_ids are not being compared
67
 
        return (
68
 
                self.inventory_sha1 == other.inventory_sha1
69
 
                and self.revision_id == other.revision_id
70
 
                and self.timestamp == other.timestamp
71
 
                and self.message == other.message
72
 
                and self.timezone == other.timezone
73
 
                and self.committer == other.committer
74
 
                and self.properties == other.properties)
75
 
 
76
 
    def __ne__(self, other):
77
 
        return not self.__eq__(other)
78
 
 
79
 
    def _check_properties(self):
80
 
        """Verify that all revision properties are OK."""
81
 
        for name, value in self.properties.iteritems():
82
 
            if not isinstance(name, basestring) or contains_whitespace(name):
83
 
                raise ValueError("invalid property name %r" % name)
84
 
            if not isinstance(value, basestring):
85
 
                raise ValueError("invalid property value %r for %r" % 
86
 
                                 (name, value))
87
 
 
88
 
    def get_history(self, repository):
89
 
        """Return the canonical line-of-history for this revision.
90
 
 
91
 
        If ghosts are present this may differ in result from a ghost-free
92
 
        repository.
93
 
        """
94
 
        current_revision = self
95
 
        reversed_result = []
96
 
        while current_revision is not None:
97
 
            reversed_result.append(current_revision.revision_id)
98
 
            if not len (current_revision.parent_ids):
99
 
                reversed_result.append(None)
100
 
                current_revision = None
101
 
            else:
102
 
                next_revision_id = current_revision.parent_ids[0]
103
 
                current_revision = repository.get_revision(next_revision_id)
104
 
        reversed_result.reverse()
105
 
        return reversed_result
106
 
 
107
 
    def get_summary(self):
108
 
        """Get the first line of the log message for this revision.
109
 
        """
110
 
        return self.message.split('\n', 1)[0]
111
 
 
112
 
 
113
 
def is_ancestor(revision_id, candidate_id, branch):
114
 
    """Return true if candidate_id is an ancestor of revision_id.
115
 
 
116
 
    A false negative will be returned if any intermediate descendent of
117
 
    candidate_id is not present in any of the revision_sources.
118
 
    
119
 
    revisions_source is an object supporting a get_revision operation that
120
 
    behaves like Branch's.
121
 
    """
122
 
    return (candidate_id in branch.repository.get_ancestry(revision_id))
123
 
 
124
 
 
125
 
def iter_ancestors(revision_id, revision_source, only_present=False):
126
 
    ancestors = (revision_id,)
127
 
    distance = 0
128
 
    while len(ancestors) > 0:
129
 
        new_ancestors = []
130
 
        for ancestor in ancestors:
131
 
            if not only_present:
132
 
                yield ancestor, distance
133
 
            try:
134
 
                revision = revision_source.get_revision(ancestor)
135
 
            except errors.NoSuchRevision, e:
136
 
                if e.revision == revision_id:
137
 
                    raise 
138
 
                else:
139
 
                    continue
140
 
            if only_present:
141
 
                yield ancestor, distance
142
 
            new_ancestors.extend(revision.parent_ids)
143
 
        ancestors = new_ancestors
144
 
        distance += 1
145
 
 
146
 
 
147
 
def find_present_ancestors(revision_id, revision_source):
148
 
    """Return the ancestors of a revision present in a branch.
149
 
 
150
 
    It's possible that a branch won't have the complete ancestry of
151
 
    one of its revisions.  
152
 
 
153
 
    """
154
 
    found_ancestors = {}
155
 
    anc_iter = enumerate(iter_ancestors(revision_id, revision_source,
156
 
                         only_present=True))
157
 
    for anc_order, (anc_id, anc_distance) in anc_iter:
158
 
        if anc_id not in found_ancestors:
159
 
            found_ancestors[anc_id] = (anc_order, anc_distance)
160
 
    return found_ancestors
161
 
    
162
 
 
163
 
def __get_closest(intersection):
164
 
    intersection.sort()
165
 
    matches = [] 
166
 
    for entry in intersection:
167
 
        if entry[0] == intersection[0][0]:
168
 
            matches.append(entry[2])
169
 
    return matches
170
 
 
171
 
 
172
 
def revision_graph(revision, revision_source):
173
 
    """Produce a graph of the ancestry of the specified revision.
174
 
    
175
 
    :return: root, ancestors map, descendants map
176
 
    """
177
 
    revision_source.lock_read()
178
 
    try:
179
 
        return _revision_graph(revision, revision_source)
180
 
    finally:
181
 
        revision_source.unlock()
182
 
 
183
 
 
184
 
def _revision_graph(revision, revision_source):
185
 
    """See revision_graph."""
186
 
    from bzrlib.tsort import topo_sort
187
 
    graph = revision_source.get_revision_graph(revision)
188
 
    # mark all no-parent revisions as being NULL_REVISION parentage.
189
 
    for node, parents in graph.items():
190
 
        if len(parents) == 0:
191
 
            graph[node] = [NULL_REVISION]
192
 
    # add NULL_REVISION to the graph
193
 
    graph[NULL_REVISION] = []
194
 
 
195
 
    # pick a root. If there are multiple roots
196
 
    # this could pick a random one.
197
 
    topo_order = topo_sort(graph.items())
198
 
    root = topo_order[0]
199
 
 
200
 
    ancestors = {}
201
 
    descendants = {}
202
 
 
203
 
    # map the descendants of the graph.
204
 
    # and setup our set based return graph.
205
 
    for node in graph.keys():
206
 
        descendants[node] = {}
207
 
    for node, parents in graph.items():
208
 
        for parent in parents:
209
 
            descendants[parent][node] = 1
210
 
        ancestors[node] = set(parents)
211
 
 
212
 
    assert root not in descendants[root]
213
 
    assert root not in ancestors[root]
214
 
    return root, ancestors, descendants
215
 
 
216
 
 
217
 
def combined_graph(revision_a, revision_b, revision_source):
218
 
    """Produce a combined ancestry graph.
219
 
    Return graph root, ancestors map, descendants map, set of common nodes"""
220
 
    root, ancestors, descendants = revision_graph(
221
 
        revision_a, revision_source)
222
 
    root_b, ancestors_b, descendants_b = revision_graph(
223
 
        revision_b, revision_source)
224
 
    if root != root_b:
225
 
        raise errors.NoCommonRoot(revision_a, revision_b)
226
 
    common = set()
227
 
    for node, node_anc in ancestors_b.iteritems():
228
 
        if node in ancestors:
229
 
            common.add(node)
230
 
        else:
231
 
            ancestors[node] = set()
232
 
        ancestors[node].update(node_anc)
233
 
    for node, node_dec in descendants_b.iteritems():
234
 
        if node not in descendants:
235
 
            descendants[node] = {}
236
 
        descendants[node].update(node_dec)
237
 
    return root, ancestors, descendants, common
238
 
 
239
 
 
240
 
def common_ancestor(revision_a, revision_b, revision_source, 
241
 
                    pb=DummyProgress()):
242
 
    if None in (revision_a, revision_b):
243
 
        return None
244
 
    if NULL_REVISION in (revision_a, revision_b):
245
 
        return NULL_REVISION
246
 
    # trivial optimisation
247
 
    if revision_a == revision_b:
248
 
        return revision_a
249
 
    try:
250
 
        try:
251
 
            pb.update('Picking ancestor', 1, 3)
252
 
            graph = revision_source.get_revision_graph_with_ghosts(
253
 
                [revision_a, revision_b])
254
 
            # Shortcut the case where one of the tips is already included in
255
 
            # the other graphs ancestry.
256
 
            ancestry_a = graph.get_ancestry(revision_a)
257
 
            if revision_b in ancestry_a:
258
 
                return revision_b
259
 
            ancestry_b = graph.get_ancestry(revision_b)
260
 
            if revision_a in ancestry_b:
261
 
                return revision_a
262
 
            # convert to a NULL_REVISION based graph.
263
 
            ancestors = graph.get_ancestors()
264
 
            descendants = graph.get_descendants()
265
 
            common = set(ancestry_a)
266
 
            common.intersection_update(ancestry_b)
267
 
            descendants[NULL_REVISION] = {}
268
 
            ancestors[NULL_REVISION] = []
269
 
            for root in graph.roots:
270
 
                descendants[NULL_REVISION][root] = 1
271
 
                ancestors[root].append(NULL_REVISION)
272
 
            for ghost in graph.ghosts:
273
 
                # ghosts act as roots for the purpose of finding 
274
 
                # the longest paths from the root: any ghost *might*
275
 
                # be directly attached to the root, so we treat them
276
 
                # as being such.
277
 
                # ghost now descends from NULL
278
 
                descendants[NULL_REVISION][ghost] = 1
279
 
                # that is it has an ancestor of NULL
280
 
                ancestors[ghost] = [NULL_REVISION]
281
 
                # ghost is common if any of ghosts descendants are common:
282
 
                for ghost_descendant in descendants[ghost]:
283
 
                    if ghost_descendant in common:
284
 
                        common.add(ghost)
 
101
        
 
102
    def to_element(self):
 
103
        from bzrlib.xml import Element, SubElement
 
104
        
 
105
        root = Element('revision',
 
106
                       committer = self.committer,
 
107
                       timestamp = '%.9f' % self.timestamp,
 
108
                       revision_id = self.revision_id,
 
109
                       inventory_id = self.inventory_id,
 
110
                       inventory_sha1 = self.inventory_sha1,
 
111
                       )
 
112
        if self.timezone:
 
113
            root.set('timezone', str(self.timezone))
 
114
        root.text = '\n'
 
115
        
 
116
        msg = SubElement(root, 'message')
 
117
        msg.text = self.message
 
118
        msg.tail = '\n'
 
119
 
 
120
        if self.parents:
 
121
            # first parent stored as precursor for compatability with 0.0.5 and
 
122
            # earlier
 
123
            pr = self.parents[0]
 
124
            assert pr.revision_id
 
125
            root.set('precursor', pr.revision_id)
 
126
            if pr.revision_sha1:
 
127
                root.set('precursor_sha1', pr.revision_sha1)
285
128
                
286
 
            root = NULL_REVISION
287
 
            common.add(NULL_REVISION)
288
 
        except errors.NoCommonRoot:
289
 
            raise errors.NoCommonAncestor(revision_a, revision_b)
290
 
            
291
 
        pb.update('Picking ancestor', 2, 3)
292
 
        distances = node_distances (descendants, ancestors, root)
293
 
        pb.update('Picking ancestor', 3, 2)
294
 
        farthest = select_farthest(distances, common)
295
 
        if farthest is None or farthest == NULL_REVISION:
296
 
            raise errors.NoCommonAncestor(revision_a, revision_b)
297
 
    finally:
298
 
        pb.clear()
299
 
    return farthest
300
 
 
301
 
 
302
 
class MultipleRevisionSources(object):
303
 
    """Proxy that looks in multiple branches for revisions."""
304
 
    def __init__(self, *args):
305
 
        object.__init__(self)
306
 
        assert len(args) != 0
307
 
        self._revision_sources = args
308
 
 
309
 
    def revision_parents(self, revision_id):
310
 
        for source in self._revision_sources:
311
 
            try:
312
 
                return source.revision_parents(revision_id)
313
 
            except (errors.WeaveRevisionNotPresent, errors.NoSuchRevision), e:
314
 
                pass
315
 
        raise e
316
 
 
317
 
    def get_revision(self, revision_id):
318
 
        for source in self._revision_sources:
319
 
            try:
320
 
                return source.get_revision(revision_id)
321
 
            except errors.NoSuchRevision, e:
322
 
                pass
323
 
        raise e
324
 
 
325
 
    def get_revision_graph(self, revision_id):
326
 
        # we could probe incrementally until the pending
327
 
        # ghosts list stop growing, but its cheaper for now
328
 
        # to just ask for the complete graph for each repository.
329
 
        graphs = []
330
 
        for source in self._revision_sources:
331
 
            ghost_graph = source.get_revision_graph_with_ghosts()
332
 
            graphs.append(ghost_graph)
333
 
        absent = 0
334
 
        for graph in graphs:
335
 
            if not revision_id in graph.get_ancestors():
336
 
                absent += 1
337
 
        if absent == len(graphs):
338
 
            raise errors.NoSuchRevision(self._revision_sources[0], revision_id)
339
 
 
340
 
        # combine the graphs
341
 
        result = {}
342
 
        pending = set([revision_id])
343
 
        def find_parents(node_id):
344
 
            """find the parents for node_id."""
345
 
            for graph in graphs:
346
 
                ancestors = graph.get_ancestors()
347
 
                try:
348
 
                    return ancestors[node_id]
349
 
                except KeyError:
350
 
                    pass
351
 
            raise errors.NoSuchRevision(self._revision_sources[0], node_id)
352
 
        while len(pending):
353
 
            # all the graphs should have identical parent lists
354
 
            node_id = pending.pop()
355
 
            try:
356
 
                result[node_id] = find_parents(node_id)
357
 
                for parent_node in result[node_id]:
358
 
                    if not parent_node in result:
359
 
                        pending.add(parent_node)
360
 
            except errors.NoSuchRevision:
361
 
                # ghost, ignore it.
362
 
                pass
363
 
        return result
364
 
 
365
 
    def get_revision_graph_with_ghosts(self, revision_ids):
366
 
        # query all the sources for their entire graphs 
367
 
        # and then build a combined graph for just
368
 
        # revision_ids.
369
 
        graphs = []
370
 
        for source in self._revision_sources:
371
 
            ghost_graph = source.get_revision_graph_with_ghosts()
372
 
            graphs.append(ghost_graph.get_ancestors())
373
 
        for revision_id in revision_ids:
374
 
            absent = 0
375
 
            for graph in graphs:
376
 
                    if not revision_id in graph:
377
 
                        absent += 1
378
 
            if absent == len(graphs):
379
 
                raise errors.NoSuchRevision(self._revision_sources[0],
380
 
                                            revision_id)
381
 
 
382
 
        # combine the graphs
383
 
        result = Graph()
384
 
        pending = set(revision_ids)
385
 
        done = set()
386
 
        def find_parents(node_id):
387
 
            """find the parents for node_id."""
388
 
            for graph in graphs:
389
 
                try:
390
 
                    return graph[node_id]
391
 
                except KeyError:
392
 
                    pass
393
 
            raise errors.NoSuchRevision(self._revision_sources[0], node_id)
394
 
        while len(pending):
395
 
            # all the graphs should have identical parent lists
396
 
            node_id = pending.pop()
397
 
            try:
398
 
                parents = find_parents(node_id)
399
 
                for parent_node in parents:
400
 
                    # queued or done? 
401
 
                    if (parent_node not in pending and
402
 
                        parent_node not in done):
403
 
                        # no, queue
404
 
                        pending.add(parent_node)
405
 
                result.add_node(node_id, parents)
406
 
                done.add(node_id)
407
 
            except errors.NoSuchRevision:
408
 
                # ghost
409
 
                result.add_ghost(node_id)
410
 
                continue
411
 
        return result
412
 
 
413
 
    def lock_read(self):
414
 
        for source in self._revision_sources:
415
 
            source.lock_read()
416
 
 
417
 
    def unlock(self):
418
 
        for source in self._revision_sources:
419
 
            source.unlock()
420
 
 
421
 
 
422
 
@deprecated_function(zero_eight)
423
 
def get_intervening_revisions(ancestor_id, rev_id, rev_source,
424
 
                              revision_history=None):
425
 
    """Find the longest line of descent from maybe_ancestor to revision.
426
 
    Revision history is followed where possible.
427
 
 
428
 
    If ancestor_id == rev_id, list will be empty.
429
 
    Otherwise, rev_id will be the last entry.  ancestor_id will never appear.
430
 
    If ancestor_id is not an ancestor, NotAncestor will be thrown
431
 
    """
432
 
    root, ancestors, descendants = revision_graph(rev_id, rev_source)
433
 
    if len(descendants) == 0:
434
 
        raise errors.NoSuchRevision(rev_source, rev_id)
435
 
    if ancestor_id not in descendants:
436
 
        rev_source.get_revision(ancestor_id)
437
 
        raise errors.NotAncestor(rev_id, ancestor_id)
438
 
    root_descendants = all_descendants(descendants, ancestor_id)
439
 
    root_descendants.add(ancestor_id)
440
 
    if rev_id not in root_descendants:
441
 
        raise errors.NotAncestor(rev_id, ancestor_id)
442
 
    distances = node_distances(descendants, ancestors, ancestor_id,
443
 
                               root_descendants=root_descendants)
444
 
 
445
 
    def best_ancestor(rev_id):
446
 
        best = None
447
 
        for anc_id in ancestors[rev_id]:
448
 
            try:
449
 
                distance = distances[anc_id]
450
 
            except KeyError:
451
 
                continue
452
 
            if revision_history is not None and anc_id in revision_history:
453
 
                return anc_id
454
 
            elif best is None or distance > best[1]:
455
 
                best = (anc_id, distance)
456
 
        return best[0]
457
 
 
458
 
    next = rev_id
459
 
    path = []
460
 
    while next != ancestor_id:
461
 
        path.append(next)
462
 
        next = best_ancestor(next)
463
 
    path.reverse()
464
 
    return path
465
 
 
466
 
 
467
 
def is_reserved_id(revision_id):
468
 
    """Determine whether a revision id is reserved
469
 
 
470
 
    :return: True if the revision is is reserved, False otherwise
471
 
    """
472
 
    return isinstance(revision_id, basestring) and revision_id.endswith(':')
473
 
 
474
 
 
475
 
def check_not_reserved_id(revision_id):
476
 
    """Raise ReservedId if the supplied revision_id is reserved"""
477
 
    if is_reserved_id(revision_id):
478
 
        raise errors.ReservedId(revision_id)
 
129
        if self.parents:
 
130
            pelts = SubElement(root, 'parents')
 
131
            pelts.tail = pelts.text = '\n'
 
132
            for rr in self.parents:
 
133
                assert isinstance(rr, RevisionReference)
 
134
                p = SubElement(pelts, 'revision_ref')
 
135
                p.tail = '\n'
 
136
                assert rr.revision_id
 
137
                p.set('revision_id', rr.revision_id)
 
138
                if rr.revision_sha1:
 
139
                    p.set('revision_sha1', rr.revision_sha1)
 
140
 
 
141
        return root
 
142
 
 
143
 
 
144
    def from_element(cls, elt):
 
145
        return unpack_revision(elt)
 
146
 
 
147
    from_element = classmethod(from_element)
 
148
 
 
149
 
 
150
 
 
151
def unpack_revision(elt):
 
152
    """Convert XML element into Revision object."""
 
153
    # <changeset> is deprecated...
 
154
    from bzrlib.errors import BzrError
 
155
    
 
156
    if elt.tag not in ('revision', 'changeset'):
 
157
        raise BzrError("unexpected tag in revision file: %r" % elt)
 
158
 
 
159
    rev = Revision(committer = elt.get('committer'),
 
160
                   timestamp = float(elt.get('timestamp')),
 
161
                   revision_id = elt.get('revision_id'),
 
162
                   inventory_id = elt.get('inventory_id'),
 
163
                   inventory_sha1 = elt.get('inventory_sha1')
 
164
                   )
 
165
 
 
166
    precursor = elt.get('precursor')
 
167
    precursor_sha1 = elt.get('precursor_sha1')
 
168
 
 
169
    pelts = elt.find('parents')
 
170
 
 
171
    if precursor:
 
172
        # revisions written prior to 0.0.5 have a single precursor
 
173
        # give as an attribute
 
174
        rev_ref = RevisionReference(precursor, precursor_sha1)
 
175
        rev.parents.append(rev_ref)
 
176
    elif pelts:
 
177
        for p in pelts:
 
178
            assert p.tag == 'revision_ref', \
 
179
                   "bad parent node tag %r" % p.tag
 
180
            rev_ref = RevisionReference(p.get('revision_id'),
 
181
                                        p.get('revision_sha1'))
 
182
            rev.parents.append(rev_ref)
 
183
 
 
184
    v = elt.get('timezone')
 
185
    rev.timezone = v and int(v)
 
186
 
 
187
    rev.message = elt.findtext('message') # text of <message>
 
188
    return rev