← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revision.py

  • Committer: Martin Pool
  • Date: 2005-10-06 08:11:46 UTC
  • mto: (1185.13.3)
  • mto: This revision was merged to the branch mainline in revision 1418.
  • Revision ID: mbp@sourcefrog.net-20051006081146-6be9d0613fd0d24d
- fix join of weaves where parents occur at different offsets
- test for this

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revision.py
16
16
 
17
17
 
18
18
import bzrlib.errors
19
 
from bzrlib.graph import farthest_nodes, node_distances, all_descendants
20
 
 
21
 
class RevisionReference(object):
22
 
    """
23
 
    Reference to a stored revision.
24
 
 
25
 
    Includes the revision_id and revision_sha1.
26
 
    """
27
 
    revision_id = None
28
 
    revision_sha1 = None
29
 
    def __init__(self, revision_id, revision_sha1=None):
30
 
        if revision_id == None \
31
 
           or isinstance(revision_id, basestring):
32
 
            self.revision_id = revision_id
33
 
        else:
34
 
            raise ValueError('bad revision_id %r' % revision_id)
35
 
 
36
 
        if revision_sha1 != None:
37
 
            if isinstance(revision_sha1, basestring) \
38
 
               and len(revision_sha1) == 40:
39
 
                self.revision_sha1 = revision_sha1
40
 
            else:
41
 
                raise ValueError('bad revision_sha1 %r' % revision_sha1)
42
 
                
43
 
 
 
19
from bzrlib.graph import node_distances, select_farthest, all_descendants
 
20
 
 
21
NULL_REVISION="null:"
44
22
 
45
23
class Revision(object):
46
24
    """Single revision on a branch.
51
29
 
52
30
    After bzr 0.0.5 revisions are allowed to have multiple parents.
53
31
 
54
 
    parents
55
 
        List of parent revisions, each is a RevisionReference.
 
32
    parent_ids
 
33
        List of parent revision_ids
56
34
    """
57
 
    inventory_id = None
58
 
    inventory_sha1 = None
59
 
    revision_id = None
60
 
    timestamp = None
61
 
    message = None
62
 
    timezone = None
63
 
    committer = None
64
35
    
65
 
    def __init__(self, **args):
 
36
    def __init__(self, revision_id, **args):
 
37
        self.revision_id = revision_id
66
38
        self.__dict__.update(args)
67
 
        self.parents = []
68
 
 
 
39
        self.parent_ids = []
 
40
        self.parent_sha1s = []
69
41
 
70
42
    def __repr__(self):
71
43
        return "<Revision id %s>" % self.revision_id
73
45
    def __eq__(self, other):
74
46
        if not isinstance(other, Revision):
75
47
            return False
76
 
        return (self.inventory_id == other.inventory_id
77
 
                and self.inventory_sha1 == other.inventory_sha1
 
48
        # FIXME: rbc 20050930 parent_ids are not being compared
 
49
        return (
 
50
                self.inventory_sha1 == other.inventory_sha1
78
51
                and self.revision_id == other.revision_id
79
52
                and self.timestamp == other.timestamp
80
53
                and self.message == other.message
85
58
        return not self.__eq__(other)
86
59
 
87
60
        
88
 
 
89
61
REVISION_ID_RE = None
90
62
 
91
63
def validate_revision_id(rid):
93
65
    global REVISION_ID_RE
94
66
    if not REVISION_ID_RE:
95
67
        import re
96
 
        REVISION_ID_RE = re.compile('[\w.-]+@[\w.-]+--?\d+--?[0-9a-f]+\Z')
 
68
        REVISION_ID_RE = re.compile('[\w:.-]+@[\w%.-]+--?[\w]+--?[0-9a-f]+\Z')
97
69
 
98
70
    if not REVISION_ID_RE.match(rid):
99
71
        raise ValueError("malformed revision-id %r" % rid)
100
72
 
101
 
def is_ancestor(revision_id, candidate_id, revision_source):
 
73
 
 
74
def is_ancestor(revision_id, candidate_id, branch):
102
75
    """Return true if candidate_id is an ancestor of revision_id.
 
76
 
103
77
    A false negative will be returned if any intermediate descendent of
104
78
    candidate_id is not present in any of the revision_sources.
105
79
    
106
80
    revisions_source is an object supporting a get_revision operation that
107
81
    behaves like Branch's.
108
82
    """
 
83
    return candidate_id in branch.get_ancestry(revision_id)
109
84
 
110
 
    for ancestor_id, distance in iter_ancestors(revision_id, revision_source):
111
 
        if ancestor_id == candidate_id:
112
 
            return True
113
 
    return False
114
85
 
115
86
def iter_ancestors(revision_id, revision_source, only_present=False):
116
87
    ancestors = (revision_id,)
129
100
                    continue
130
101
            if only_present:
131
102
                yield ancestor, distance
132
 
            new_ancestors.extend([p.revision_id for p in revision.parents])
 
103
            new_ancestors.extend(revision.parent_ids)
133
104
        ancestors = new_ancestors
134
105
        distance += 1
135
106
 
206
177
    while len(lines) > 0:
207
178
        new_lines = set()
208
179
        for line in lines:
209
 
            try:
210
 
                rev = revision_source.get_revision(line)
211
 
                parents = [p.revision_id for p in rev.parents]
212
 
                if len(parents) == 0:
213
 
                    root = line
214
 
            except bzrlib.errors.NoSuchRevision:
215
 
                if line == revision:
216
 
                    raise
217
 
                parents = None
 
180
            if line == NULL_REVISION:
 
181
                parents = []
 
182
                root = NULL_REVISION
 
183
            else:
 
184
                try:
 
185
                    rev = revision_source.get_revision(line)
 
186
                    parents = list(rev.parent_ids)
 
187
                    if len(parents) == 0:
 
188
                        parents = [NULL_REVISION]
 
189
                except bzrlib.errors.NoSuchRevision:
 
190
                    if line == revision:
 
191
                        raise
 
192
                    parents = None
218
193
            if parents is not None:
219
194
                for parent in parents:
220
195
                    if parent not in ancestors:
229
204
    assert root not in ancestors[root]
230
205
    return root, ancestors, descendants
231
206
 
 
207
 
232
208
def combined_graph(revision_a, revision_b, revision_source):
233
209
    """Produce a combined ancestry graph.
234
210
    Return graph root, ancestors map, descendants map, set of common nodes"""
246
222
        ancestors[node].update(node_anc)
247
223
    for node, node_dec in descendants_b.iteritems():
248
224
        if node not in descendants:
249
 
            descendants[node] = set()
 
225
            descendants[node] = {}
250
226
        descendants[node].update(node_dec)
251
227
    return root, ancestors, descendants, common
252
228
 
 
229
 
253
230
def common_ancestor(revision_a, revision_b, revision_source):
254
231
    try:
255
232
        root, ancestors, descendants, common = \
257
234
    except bzrlib.errors.NoCommonRoot:
258
235
        raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
259
236
        
260
 
    nodes = farthest_nodes(descendants, ancestors, root)
261
 
    for node in nodes:
262
 
        if node in common:
263
 
            return node
264
 
    raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
 
237
    distances = node_distances (descendants, ancestors, root)
 
238
    farthest = select_farthest(distances, common)
 
239
    if farthest is None or farthest == NULL_REVISION:
 
240
        raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
 
241
    return farthest
 
242
 
265
243
 
266
244
class MultipleRevisionSources(object):
267
245
    """Proxy that looks in multiple branches for revisions."""