← 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-06-22 06:37:43 UTC
  • Revision ID: mbp@sourcefrog.net-20050622063743-e395f04c4db8977f
- move old blackbox code from testbzr into bzrlib.selftest.blackbox

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revision.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import bzrlib.errors
19
 
 
20
 
 
21
 
class RevisionReference(object):
 
18
 
 
19
 
 
20
from xml import XMLMixin
 
21
 
 
22
try:
 
23
    from cElementTree import Element, ElementTree, SubElement
 
24
except ImportError:
 
25
    from elementtree.ElementTree import Element, ElementTree, SubElement
 
26
 
 
27
from errors import BzrError
 
28
 
 
29
 
 
30
class RevisionReference:
22
31
    """
23
32
    Reference to a stored revision.
24
33
 
26
35
    """
27
36
    revision_id = None
28
37
    revision_sha1 = None
29
 
    def __init__(self, revision_id, revision_sha1=None):
 
38
    def __init__(self, revision_id, revision_sha1):
30
39
        if revision_id == None \
31
40
           or isinstance(revision_id, basestring):
32
41
            self.revision_id = revision_id
42
51
                
43
52
 
44
53
 
45
 
class Revision(object):
 
54
class Revision(XMLMixin):
46
55
    """Single revision on a branch.
47
56
 
48
57
    Revisions may know their revision_hash, but only once they've been
50
59
    into the file it describes.
51
60
 
52
61
    After bzr 0.0.5 revisions are allowed to have multiple parents.
 
62
    To support old clients this is written out in a slightly redundant
 
63
    form: the first parent as the predecessor.  This will eventually
 
64
    be dropped.
53
65
 
54
66
    parents
55
67
        List of parent revisions, each is a RevisionReference.
66
78
        self.__dict__.update(args)
67
79
        self.parents = []
68
80
 
 
81
    def _get_precursor(self):
 
82
        from warnings import warn
 
83
        warn("Revision.precursor is deprecated", stacklevel=2)
 
84
        if self.parents:
 
85
            return self.parents[0].revision_id
 
86
        else:
 
87
            return None
 
88
 
 
89
 
 
90
    def _get_precursor_sha1(self):
 
91
        from warnings import warn
 
92
        warn("Revision.precursor_sha1 is deprecated", stacklevel=2)
 
93
        if self.parents:
 
94
            return self.parents[0].revision_sha1
 
95
        else:
 
96
            return None    
 
97
 
 
98
 
 
99
    def _fail(self):
 
100
        raise Exception("can't assign to precursor anymore")
 
101
 
 
102
 
 
103
    precursor = property(_get_precursor, _fail, _fail)
 
104
    precursor_sha1 = property(_get_precursor_sha1, _fail, _fail)
 
105
 
 
106
 
69
107
 
70
108
    def __repr__(self):
71
109
        return "<Revision id %s>" % self.revision_id
72
110
 
73
111
        
74
112
    def to_element(self):
75
 
        from bzrlib.xml import Element, SubElement
76
 
        
77
113
        root = Element('revision',
78
114
                       committer = self.committer,
79
115
                       timestamp = '%.9f' % self.timestamp,
90
126
        msg.tail = '\n'
91
127
 
92
128
        if self.parents:
 
129
            # first parent stored as precursor for compatability with 0.0.5 and
 
130
            # earlier
 
131
            pr = self.parents[0]
 
132
            assert pr.revision_id
 
133
            root.set('precursor', pr.revision_id)
 
134
            if pr.revision_sha1:
 
135
                root.set('precursor_sha1', pr.revision_sha1)
 
136
                
 
137
        if self.parents:
93
138
            pelts = SubElement(root, 'parents')
94
139
            pelts.tail = pelts.text = '\n'
95
140
            for rr in self.parents:
115
160
    """Convert XML element into Revision object."""
116
161
    # <changeset> is deprecated...
117
162
    if elt.tag not in ('revision', 'changeset'):
118
 
        raise bzrlib.errors.BzrError("unexpected tag in revision file: %r" % elt)
 
163
        raise BzrError("unexpected tag in revision file: %r" % elt)
119
164
 
120
165
    rev = Revision(committer = elt.get('committer'),
121
166
                   timestamp = float(elt.get('timestamp')),
129
174
 
130
175
    pelts = elt.find('parents')
131
176
 
132
 
    if pelts:
 
177
    if precursor:
 
178
        # revisions written prior to 0.0.5 have a single precursor
 
179
        # give as an attribute
 
180
        rev_ref = RevisionReference(precursor, precursor_sha1)
 
181
        rev.parents.append(rev_ref)
 
182
    elif pelts:
133
183
        for p in pelts:
134
184
            assert p.tag == 'revision_ref', \
135
185
                   "bad parent node tag %r" % p.tag
137
187
                                        p.get('revision_sha1'))
138
188
            rev.parents.append(rev_ref)
139
189
 
140
 
        if precursor:
141
 
            # must be consistent
142
 
            prec_parent = rev.parents[0].revision_id
143
 
            assert prec_parent == precursor
144
 
    elif precursor:
145
 
        # revisions written prior to 0.0.5 have a single precursor
146
 
        # give as an attribute
147
 
        rev_ref = RevisionReference(precursor, precursor_sha1)
148
 
        rev.parents.append(rev_ref)
149
 
 
150
190
    v = elt.get('timezone')
151
191
    rev.timezone = v and int(v)
152
192
 
153
193
    rev.message = elt.findtext('message') # text of <message>
154
194
    return rev
155
 
 
156
 
 
157
 
 
158
 
REVISION_ID_RE = None
159
 
 
160
 
def validate_revision_id(rid):
161
 
    """Check rid is syntactically valid for a revision id."""
162
 
    global REVISION_ID_RE
163
 
    if not REVISION_ID_RE:
164
 
        import re
165
 
        REVISION_ID_RE = re.compile('[\w.-]+@[\w.-]+--?\d+--?[0-9a-f]+\Z')
166
 
 
167
 
    if not REVISION_ID_RE.match(rid):
168
 
        raise ValueError("malformed revision-id %r" % rid)
169
 
 
170
 
def is_ancestor(revision_id, candidate_id, revision_source):
171
 
    """Return true if candidate_id is an ancestor of revision_id.
172
 
    A false negative will be returned if any intermediate descendent of
173
 
    candidate_id is not present in any of the revision_sources.
174
 
    
175
 
    revisions_source is an object supporting a get_revision operation that
176
 
    behaves like Branch's.
177
 
    """
178
 
 
179
 
    for ancestor_id, distance in iter_ancestors(revision_id, revision_source):
180
 
        if ancestor_id == candidate_id:
181
 
            return True
182
 
    return False
183
 
 
184
 
def iter_ancestors(revision_id, revision_source, only_present=False):
185
 
    ancestors = (revision_id,)
186
 
    distance = 0
187
 
    while len(ancestors) > 0:
188
 
        new_ancestors = []
189
 
        for ancestor in ancestors:
190
 
            if not only_present:
191
 
                yield ancestor, distance
192
 
            try:
193
 
                revision = revision_source.get_revision(ancestor)
194
 
            except bzrlib.errors.NoSuchRevision, e:
195
 
                if e.revision == revision_id:
196
 
                    raise 
197
 
                else:
198
 
                    continue
199
 
            if only_present:
200
 
                yield ancestor, distance
201
 
            new_ancestors.extend([p.revision_id for p in revision.parents])
202
 
        ancestors = new_ancestors
203
 
        distance += 1
204
 
 
205
 
 
206
 
def find_present_ancestors(revision_id, revision_source):
207
 
    found_ancestors = {}
208
 
    count = 0
209
 
    anc_iter = enumerate(iter_ancestors(revision_id, revision_source,
210
 
                         only_present=True))
211
 
    for anc_order, (anc_id, anc_distance) in anc_iter:
212
 
        if not found_ancestors.has_key(anc_id):
213
 
            found_ancestors[anc_id] = (anc_order, anc_distance)
214
 
    return found_ancestors
215
 
    
216
 
class AmbiguousBase(bzrlib.errors.BzrError):
217
 
    def __init__(self, bases):
218
 
        msg = "The correct base is unclear, becase %s are all equally close" %\
219
 
            ", ".join(bases)
220
 
        bzrlib.errors.BzrError.__init__(self, msg)
221
 
        self.bases = bases
222
 
 
223
 
def common_ancestor(revision_a, revision_b, revision_source):
224
 
    """Find the ancestor common to both revisions that is closest to both.
225
 
    """
226
 
    from bzrlib.trace import mutter
227
 
    a_ancestors = find_present_ancestors(revision_a, revision_source)
228
 
    b_ancestors = find_present_ancestors(revision_b, revision_source)
229
 
    a_intersection = []
230
 
    b_intersection = []
231
 
    # a_order is used as a tie-breaker when two equally-good bases are found
232
 
    for revision, (a_order, a_distance) in a_ancestors.iteritems():
233
 
        if b_ancestors.has_key(revision):
234
 
            a_intersection.append((a_distance, a_order, revision))
235
 
            b_intersection.append((b_ancestors[revision][1], a_order, revision))
236
 
    mutter("a intersection: %r" % a_intersection)
237
 
    mutter("b intersection: %r" % b_intersection)
238
 
    def get_closest(intersection):
239
 
        intersection.sort()
240
 
        matches = [] 
241
 
        for entry in intersection:
242
 
            if entry[0] == intersection[0][0]:
243
 
                matches.append(entry[2])
244
 
        return matches
245
 
 
246
 
    a_closest = get_closest(a_intersection)
247
 
    if len(a_closest) == 0:
248
 
        return None
249
 
    b_closest = get_closest(b_intersection)
250
 
    assert len(b_closest) != 0
251
 
    mutter ("a_closest %r" % a_closest)
252
 
    mutter ("b_closest %r" % b_closest)
253
 
    if a_closest[0] in b_closest:
254
 
        return a_closest[0]
255
 
    elif b_closest[0] in a_closest:
256
 
        return b_closest[0]
257
 
    else:
258
 
        raise AmbiguousBase((a_closest[0], b_closest[0]))
259
 
    return a_closest[0]
260
 
 
261
 
class MultipleRevisionSources(object):
262
 
    def __init__(self, *args):
263
 
        object.__init__(self)
264
 
        assert len(args) != 0
265
 
        self._revision_sources = args
266
 
 
267
 
    def get_revision(self, revision_id):
268
 
        for source in self._revision_sources:
269
 
            try:
270
 
                return source.get_revision(revision_id)
271
 
            except bzrlib.errors.NoSuchRevision, e:
272
 
                pass
273
 
        raise e