← 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-07-05 10:14:37 UTC
  • Revision ID: mbp@sourcefrog.net-20050705101437-c41d1d0170905106
- don't sync up on blank or hash-only lines

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
18
 
20
19
 
21
20
class RevisionReference(object):
114
113
def unpack_revision(elt):
115
114
    """Convert XML element into Revision object."""
116
115
    # <changeset> is deprecated...
 
116
    from bzrlib.errors import BzrError
 
117
    
117
118
    if elt.tag not in ('revision', 'changeset'):
118
 
        raise bzrlib.errors.BzrError("unexpected tag in revision file: %r" % elt)
 
119
        raise BzrError("unexpected tag in revision file: %r" % elt)
119
120
 
120
121
    rev = Revision(committer = elt.get('committer'),
121
122
                   timestamp = float(elt.get('timestamp')),
166
167
 
167
168
    if not REVISION_ID_RE.match(rid):
168
169
        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
 
    """Return the ancestors of a revision present in a branch.
208
 
 
209
 
    It's possible that a branch won't have the complete ancestry of
210
 
    one of its revisions.  
211
 
 
212
 
    """
213
 
    found_ancestors = {}
214
 
    count = 0
215
 
    anc_iter = enumerate(iter_ancestors(revision_id, revision_source,
216
 
                         only_present=True))
217
 
    for anc_order, (anc_id, anc_distance) in anc_iter:
218
 
        if not found_ancestors.has_key(anc_id):
219
 
            found_ancestors[anc_id] = (anc_order, anc_distance)
220
 
    return found_ancestors
221
 
    
222
 
class AmbiguousBase(bzrlib.errors.BzrError):
223
 
    def __init__(self, bases):
224
 
        msg = "The correct base is unclear, becase %s are all equally close" %\
225
 
            ", ".join(bases)
226
 
        bzrlib.errors.BzrError.__init__(self, msg)
227
 
        self.bases = bases
228
 
 
229
 
def common_ancestor(revision_a, revision_b, revision_source):
230
 
    """Find the ancestor common to both revisions that is closest to both.
231
 
    """
232
 
    from bzrlib.trace import mutter
233
 
    a_ancestors = find_present_ancestors(revision_a, revision_source)
234
 
    b_ancestors = find_present_ancestors(revision_b, revision_source)
235
 
    a_intersection = []
236
 
    b_intersection = []
237
 
    # a_order is used as a tie-breaker when two equally-good bases are found
238
 
    for revision, (a_order, a_distance) in a_ancestors.iteritems():
239
 
        if b_ancestors.has_key(revision):
240
 
            a_intersection.append((a_distance, a_order, revision))
241
 
            b_intersection.append((b_ancestors[revision][1], a_order, revision))
242
 
    mutter("a intersection: %r" % a_intersection)
243
 
    mutter("b intersection: %r" % b_intersection)
244
 
    def get_closest(intersection):
245
 
        intersection.sort()
246
 
        matches = [] 
247
 
        for entry in intersection:
248
 
            if entry[0] == intersection[0][0]:
249
 
                matches.append(entry[2])
250
 
        return matches
251
 
 
252
 
    a_closest = get_closest(a_intersection)
253
 
    if len(a_closest) == 0:
254
 
        return None
255
 
    b_closest = get_closest(b_intersection)
256
 
    assert len(b_closest) != 0
257
 
    mutter ("a_closest %r" % a_closest)
258
 
    mutter ("b_closest %r" % b_closest)
259
 
    if a_closest[0] in b_closest:
260
 
        return a_closest[0]
261
 
    elif b_closest[0] in a_closest:
262
 
        return b_closest[0]
263
 
    else:
264
 
        raise AmbiguousBase((a_closest[0], b_closest[0]))
265
 
    return a_closest[0]
266
 
 
267
 
class MultipleRevisionSources(object):
268
 
    def __init__(self, *args):
269
 
        object.__init__(self)
270
 
        assert len(args) != 0
271
 
        self._revision_sources = args
272
 
 
273
 
    def get_revision(self, revision_id):
274
 
        for source in self._revision_sources:
275
 
            try:
276
 
                return source.get_revision(revision_id)
277
 
            except bzrlib.errors.NoSuchRevision, e:
278
 
                pass
279
 
        raise e
 
170