/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
 
 
26
 
 
27
 
def iter_log_revisions(revisions, revision_source, verbose, rev_tag_dict=None):
28
 
    if rev_tag_dict is None:
29
 
        rev_tag_dict = {}
30
 
    for revno, rev_id, merge_depth in revisions:
 
22
import bzrlib.revision as _mod_revision
 
23
 
 
24
 
 
25
def iter_log_revisions(revisions, revision_source, verbose):
 
26
    last_tree = revision_source.revision_tree(_mod_revision.NULL_REVISION)
 
27
    last_rev_id = None
 
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
31
36
        rev = revision_source.get_revision(rev_id)
32
37
        if verbose:
33
38
            delta = revision_source.get_revision_delta(rev_id)
34
39
        else:
35
40
            delta = None
36
 
        yield log.LogRevision(rev, revno, merge_depth, delta=delta,
37
 
                              tags=rev_tag_dict.get(rev_id))
 
41
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
38
42
 
39
43
 
40
44
def find_unmerged(local_branch, remote_branch, restrict='all',
41
 
                  include_merged=None, backward=False,
 
45
                  include_merges=False, backward=False,
42
46
                  local_revid_range=None, remote_revid_range=None):
43
47
    """Find revisions from each side that have not been merged.
44
48
 
49
53
        unique revisions from both sides. If 'local', we will return None
50
54
        for the remote revisions, similarly if 'remote' we will return None for
51
55
        the local revisions.
52
 
    :param include_merged: Show mainline revisions only if False,
 
56
    :param include_merges: Show mainline revisions only if False,
53
57
        all revisions otherwise.
54
58
    :param backward: Show oldest versions first when True, newest versions
55
59
        first when False.
61
65
    :return: A list of [(revno, revision_id)] for the mainline revisions on
62
66
        each side.
63
67
    """
64
 
    if include_merged is None:
65
 
        include_merged = False
66
68
    local_branch.lock_read()
67
69
    try:
68
70
        remote_branch.lock_read()
69
71
        try:
70
72
            return _find_unmerged(
71
73
                local_branch, remote_branch, restrict=restrict,
72
 
                include_merged=include_merged, backward=backward,
 
74
                include_merges=include_merges, backward=backward,
73
75
                local_revid_range=local_revid_range,
74
76
                remote_revid_range=remote_revid_range)
75
77
        finally:
87
89
    :param tip: The tip of mainline
88
90
    :param backward: Show oldest versions first when True, newest versions
89
91
        first when False.
90
 
    :return: [(revno, revision_id, 0)] for all revisions in ancestry that
 
92
    :return: [(revno, revision_id)] for all revisions in ancestry that
91
93
        are left-hand parents from tip, or None if ancestry is None.
92
94
    """
93
95
    if ancestry is None:
94
96
        return None
95
 
    if not ancestry:  # Empty ancestry, no need to do any work
 
97
    if not ancestry: #Empty ancestry, no need to do any work
96
98
        return []
97
99
 
98
100
    # Optionally, we could make 1 call to graph.get_parent_map with all
106
108
        parent_map = graph.get_parent_map([cur])
107
109
        parents = parent_map.get(cur)
108
110
        if not parents:
109
 
            break  # Ghost, we are done
110
 
        mainline.append(
111
 
            (str(cur_revno) if cur_revno is not None else None, cur, 0))
 
111
            break # Ghost, we are done
 
112
        mainline.append((str(cur_revno), cur))
112
113
        cur = parents[0]
113
 
        if cur_revno is not None:
114
 
            cur_revno -= 1
 
114
        cur_revno -= 1
115
115
    if not backward:
116
116
        mainline.reverse()
117
117
    return mainline
133
133
    """
134
134
    if ancestry is None:
135
135
        return None
136
 
    if not ancestry:  # Empty ancestry, no need to do any work
 
136
    if not ancestry: #Empty ancestry, no need to do any work
137
137
        return []
138
138
 
139
139
    merge_sorted_revisions = branch.iter_merge_sorted_revisions()
156
156
    if revid_range is None or revs is None:
157
157
        return revs
158
158
    return [rev for rev in revs
159
 
            if graph.is_between(rev[1], revid_range[0], revid_range[1])]
 
159
        if graph.is_between(rev[1], revid_range[0], revid_range[1])]
160
160
 
161
161
 
162
162
def _find_unmerged(local_branch, remote_branch, restrict,
163
 
                   include_merged, backward,
 
163
                   include_merges, backward,
164
164
                   local_revid_range=None, remote_revid_range=None):
165
165
    """See find_unmerged.
166
166
 
167
167
    The branches should already be locked before entering.
168
168
    """
169
 
    try:
170
 
        local_revno, local_revision_id = local_branch.last_revision_info()
171
 
    except (errors.UnsupportedOperation, errors.GhostRevisionsHaveNoRevno):
172
 
        local_revno = None
173
 
        local_revision_id = local_branch.last_revision()
174
 
    try:
175
 
        remote_revno, remote_revision_id = remote_branch.last_revision_info()
176
 
    except (errors.UnsupportedOperation, errors.GhostRevisionsHaveNoRevno):
177
 
        remote_revision_id = remote_branch.last_revision()
178
 
        remote_revno = None
179
 
 
180
 
    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:
181
172
        # A simple shortcut when the tips are at the same point
182
173
        return [], []
183
174
    graph = local_branch.repository.get_graph(remote_branch.repository)
195
186
                             ' "remote": %r' % (restrict,))
196
187
        local_extra, remote_extra = graph.find_difference(local_revision_id,
197
188
                                                          remote_revision_id)
198
 
    if include_merged:
 
189
    if include_merges:
199
190
        locals = _enumerate_with_merges(local_branch, local_extra,
200
191
                                        graph, local_revno,
201
192
                                        local_revision_id, backward)
209
200
                                     local_revision_id, backward)
210
201
        remotes = _enumerate_mainline(remote_extra, graph, remote_revno,
211
202
                                      remote_revision_id, backward)
212
 
    return _filter_revs(graph, locals, local_revid_range), _filter_revs(
213
 
        graph, remotes, remote_revid_range)
 
203
    return _filter_revs(graph, locals, local_revid_range), _filter_revs(graph,
 
204
        remotes, remote_revid_range)
214
205
 
215
206
 
216
207
def sorted_revisions(revisions, history_map):
217
 
    revisions = sorted([(history_map[r], r) for r in revisions])
 
208
    revisions = [(history_map[r],r) for r in revisions]
 
209
    revisions.sort()
218
210
    return revisions