/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/missing.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/missing.py
16
16
 
17
17
"""Display what revisions are missing in 'other' from 'this' and vice versa."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
 
from . import (
22
 
    errors,
 
19
from bzrlib import (
23
20
    log,
24
21
    )
25
 
from . import revision as _mod_revision
26
 
 
27
 
 
28
 
def iter_log_revisions(revisions, revision_source, verbose, rev_tag_dict=None):
 
22
import bzrlib.revision as _mod_revision
 
23
 
 
24
 
 
25
def iter_log_revisions(revisions, revision_source, verbose):
29
26
    last_tree = revision_source.revision_tree(_mod_revision.NULL_REVISION)
30
27
    last_rev_id = None
31
 
 
32
 
    if rev_tag_dict is None:
33
 
        rev_tag_dict = {}
34
 
    for revno, rev_id, merge_depth in revisions:
 
28
    for rev in revisions:
 
29
        # We need the following for backward compatibilty (hopefully
 
30
        # this will be deprecated soon :-/) -- vila 080911
 
31
        if len(rev) == 2:
 
32
            revno, rev_id = rev
 
33
            merge_depth = 0
 
34
        else:
 
35
            revno, rev_id, merge_depth = rev
35
36
        rev = revision_source.get_revision(rev_id)
36
37
        if verbose:
37
38
            delta = revision_source.get_revision_delta(rev_id)
38
39
        else:
39
40
            delta = None
40
 
        yield log.LogRevision(rev, revno, merge_depth, delta=delta,
41
 
                              tags=rev_tag_dict.get(rev_id))
 
41
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
42
42
 
43
43
 
44
44
def find_unmerged(local_branch, remote_branch, restrict='all',
45
 
                  include_merged=None, backward=False,
 
45
                  include_merges=False, backward=False,
46
46
                  local_revid_range=None, remote_revid_range=None):
47
47
    """Find revisions from each side that have not been merged.
48
48
 
53
53
        unique revisions from both sides. If 'local', we will return None
54
54
        for the remote revisions, similarly if 'remote' we will return None for
55
55
        the local revisions.
56
 
    :param include_merged: Show mainline revisions only if False,
 
56
    :param include_merges: Show mainline revisions only if False,
57
57
        all revisions otherwise.
58
58
    :param backward: Show oldest versions first when True, newest versions
59
59
        first when False.
65
65
    :return: A list of [(revno, revision_id)] for the mainline revisions on
66
66
        each side.
67
67
    """
68
 
    if include_merged is None:
69
 
        include_merged = False
70
68
    local_branch.lock_read()
71
69
    try:
72
70
        remote_branch.lock_read()
73
71
        try:
74
72
            return _find_unmerged(
75
73
                local_branch, remote_branch, restrict=restrict,
76
 
                include_merged=include_merged, backward=backward,
 
74
                include_merges=include_merges, backward=backward,
77
75
                local_revid_range=local_revid_range,
78
76
                remote_revid_range=remote_revid_range)
79
77
        finally:
91
89
    :param tip: The tip of mainline
92
90
    :param backward: Show oldest versions first when True, newest versions
93
91
        first when False.
94
 
    :return: [(revno, revision_id, 0)] for all revisions in ancestry that
 
92
    :return: [(revno, revision_id)] for all revisions in ancestry that
95
93
        are left-hand parents from tip, or None if ancestry is None.
96
94
    """
97
95
    if ancestry is None:
111
109
        parents = parent_map.get(cur)
112
110
        if not parents:
113
111
            break # Ghost, we are done
114
 
        mainline.append((str(cur_revno) if cur_revno is not None else None, cur, 0))
 
112
        mainline.append((str(cur_revno), cur))
115
113
        cur = parents[0]
116
 
        if cur_revno is not None:
117
 
            cur_revno -= 1
 
114
        cur_revno -= 1
118
115
    if not backward:
119
116
        mainline.reverse()
120
117
    return mainline
163
160
 
164
161
 
165
162
def _find_unmerged(local_branch, remote_branch, restrict,
166
 
                   include_merged, backward,
 
163
                   include_merges, backward,
167
164
                   local_revid_range=None, remote_revid_range=None):
168
165
    """See find_unmerged.
169
166
 
170
167
    The branches should already be locked before entering.
171
168
    """
172
 
    try:
173
 
        local_revno, local_revision_id = local_branch.last_revision_info()
174
 
    except (errors.UnsupportedOperation, errors.GhostRevisionsHaveNoRevno):
175
 
        local_revno = None
176
 
        local_revision_id = local_branch.last_revision()
177
 
    try:
178
 
        remote_revno, remote_revision_id = remote_branch.last_revision_info()
179
 
    except (errors.UnsupportedOperation, errors.GhostRevisionsHaveNoRevno):
180
 
        remote_revision_id = remote_branch.last_revision()
181
 
        remote_revno = None
182
 
 
183
 
    if local_revision_id == remote_revision_id:
 
169
    local_revno, local_revision_id = local_branch.last_revision_info()
 
170
    remote_revno, remote_revision_id = remote_branch.last_revision_info()
 
171
    if local_revno == remote_revno and local_revision_id == remote_revision_id:
184
172
        # A simple shortcut when the tips are at the same point
185
173
        return [], []
186
174
    graph = local_branch.repository.get_graph(remote_branch.repository)
198
186
                             ' "remote": %r' % (restrict,))
199
187
        local_extra, remote_extra = graph.find_difference(local_revision_id,
200
188
                                                          remote_revision_id)
201
 
    if include_merged:
 
189
    if include_merges:
202
190
        locals = _enumerate_with_merges(local_branch, local_extra,
203
191
                                        graph, local_revno,
204
192
                                        local_revision_id, backward)
217
205
 
218
206
 
219
207
def sorted_revisions(revisions, history_map):
220
 
    revisions = sorted([(history_map[r], r) for r in revisions])
 
208
    revisions = [(history_map[r],r) for r in revisions]
 
209
    revisions.sort()
221
210
    return revisions