/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 breezy/missing.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:26:22 UTC
  • mfrom: (7167.1.4 run-flake8)
  • Revision ID: breezy.the.bot@gmail.com-20181116182622-qw3gan3hz78a2imw
Add a flake8 test.

Merged from https://code.launchpad.net/~jelmer/brz/run-flake8/+merge/358902

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/missing.py
16
16
 
17
17
"""Display what revisions are missing in 'other' from 'this' and vice versa."""
18
18
 
19
 
from bzrlib import (
 
19
from __future__ import absolute_import
 
20
 
 
21
from . import (
 
22
    errors,
20
23
    log,
21
24
    )
22
 
import bzrlib.revision as _mod_revision
23
 
 
24
 
 
25
 
def iter_log_revisions(revisions, revision_source, verbose):
 
25
from . import revision as _mod_revision
 
26
 
 
27
 
 
28
def iter_log_revisions(revisions, revision_source, verbose, rev_tag_dict=None):
26
29
    last_tree = revision_source.revision_tree(_mod_revision.NULL_REVISION)
27
30
    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
 
 
32
    if rev_tag_dict is None:
 
33
        rev_tag_dict = {}
 
34
    for revno, rev_id, merge_depth in revisions:
36
35
        rev = revision_source.get_revision(rev_id)
37
36
        if verbose:
38
37
            delta = revision_source.get_revision_delta(rev_id)
39
38
        else:
40
39
            delta = None
41
 
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
 
40
        yield log.LogRevision(rev, revno, merge_depth, delta=delta,
 
41
                              tags=rev_tag_dict.get(rev_id))
42
42
 
43
43
 
44
44
def find_unmerged(local_branch, remote_branch, restrict='all',
45
 
                  include_merges=False, backward=False,
 
45
                  include_merged=None, 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_merges: Show mainline revisions only if False,
 
56
    :param include_merged: 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
68
70
    local_branch.lock_read()
69
71
    try:
70
72
        remote_branch.lock_read()
71
73
        try:
72
74
            return _find_unmerged(
73
75
                local_branch, remote_branch, restrict=restrict,
74
 
                include_merges=include_merges, backward=backward,
 
76
                include_merged=include_merged, backward=backward,
75
77
                local_revid_range=local_revid_range,
76
78
                remote_revid_range=remote_revid_range)
77
79
        finally:
89
91
    :param tip: The tip of mainline
90
92
    :param backward: Show oldest versions first when True, newest versions
91
93
        first when False.
92
 
    :return: [(revno, revision_id)] for all revisions in ancestry that
 
94
    :return: [(revno, revision_id, 0)] for all revisions in ancestry that
93
95
        are left-hand parents from tip, or None if ancestry is None.
94
96
    """
95
97
    if ancestry is None:
109
111
        parents = parent_map.get(cur)
110
112
        if not parents:
111
113
            break # Ghost, we are done
112
 
        mainline.append((str(cur_revno), cur))
 
114
        mainline.append((str(cur_revno) if cur_revno is not None else None, cur, 0))
113
115
        cur = parents[0]
114
 
        cur_revno -= 1
 
116
        if cur_revno is not None:
 
117
            cur_revno -= 1
115
118
    if not backward:
116
119
        mainline.reverse()
117
120
    return mainline
160
163
 
161
164
 
162
165
def _find_unmerged(local_branch, remote_branch, restrict,
163
 
                   include_merges, backward,
 
166
                   include_merged, backward,
164
167
                   local_revid_range=None, remote_revid_range=None):
165
168
    """See find_unmerged.
166
169
 
167
170
    The branches should already be locked before entering.
168
171
    """
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:
 
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:
172
184
        # A simple shortcut when the tips are at the same point
173
185
        return [], []
174
186
    graph = local_branch.repository.get_graph(remote_branch.repository)
186
198
                             ' "remote": %r' % (restrict,))
187
199
        local_extra, remote_extra = graph.find_difference(local_revision_id,
188
200
                                                          remote_revision_id)
189
 
    if include_merges:
 
201
    if include_merged:
190
202
        locals = _enumerate_with_merges(local_branch, local_extra,
191
203
                                        graph, local_revno,
192
204
                                        local_revision_id, backward)
205
217
 
206
218
 
207
219
def sorted_revisions(revisions, history_map):
208
 
    revisions = [(history_map[r],r) for r in revisions]
209
 
    revisions.sort()
 
220
    revisions = sorted([(history_map[r], r) for r in revisions])
210
221
    return revisions