20
46
revision_tree = revision_source.revision_tree(rev_id)
21
47
last_rev_id = rev_id
22
48
last_tree = revision_tree
23
delta = compare_trees(revision_tree, parent_tree)
49
delta = revision_tree.changes_from(parent_tree)
26
yield revno, rev, delta
29
def find_unmerged(local_branch, remote_branch):
30
progress = ui.ui_factory.nested_progress_bar()
52
yield log.LogRevision(rev, revno, merge_depth, delta=delta)
55
def find_unmerged(local_branch, remote_branch, restrict='all',
56
include_merges=False, backward=False,
57
local_revid_range=None, remote_revid_range=None):
58
"""Find revisions from each side that have not been merged.
60
:param local_branch: Compare the history of local_branch
61
:param remote_branch: versus the history of remote_branch, and determine
62
mainline revisions which have not been merged.
63
:param restrict: ('all', 'local', 'remote') If 'all', we will return the
64
unique revisions from both sides. If 'local', we will return None
65
for the remote revisions, similarly if 'remote' we will return None for
67
:param include_merges: Show mainline revisions only if False,
68
all revisions otherwise.
69
:param backward: Show oldest versions first when True, newest versions
71
:param local_revid_range: Revision-id range for filtering local_branch
72
revisions (lower bound, upper bound)
73
:param remote_revid_range: Revision-id range for filtering remote_branch
74
revisions (lower bound, upper bound)
76
:return: A list of [(revno, revision_id)] for the mainline revisions on
31
79
local_branch.lock_read()
33
81
remote_branch.lock_read()
35
local_rev_history, local_rev_history_map = \
36
_get_history(local_branch, progress, "local", 0)
37
remote_rev_history, remote_rev_history_map = \
38
_get_history(remote_branch, progress, "remote", 1)
39
result = _shortcut(local_rev_history, remote_rev_history)
40
if result is not None:
41
local_extra, remote_extra = result
42
local_extra = sorted_revisions(local_extra,
43
local_rev_history_map)
44
remote_extra = sorted_revisions(remote_extra,
45
remote_rev_history_map)
46
return local_extra, remote_extra
48
local_ancestry = _get_ancestry(local_branch.repository, progress,
49
"local", 2, local_rev_history)
50
remote_ancestry = _get_ancestry(remote_branch.repository, progress,
51
"remote", 3, remote_rev_history)
52
progress.update('pondering', 4, 5)
53
extras = local_ancestry.symmetric_difference(remote_ancestry)
54
local_extra = extras.intersection(set(local_rev_history))
55
remote_extra = extras.intersection(set(remote_rev_history))
56
local_extra = sorted_revisions(local_extra, local_rev_history_map)
57
remote_extra = sorted_revisions(remote_extra,
58
remote_rev_history_map)
83
return _find_unmerged(
84
local_branch, remote_branch, restrict=restrict,
85
include_merges=include_merges, backward=backward,
86
local_revid_range=local_revid_range,
87
remote_revid_range=remote_revid_range)
61
89
remote_branch.unlock()
63
91
local_branch.unlock()
65
return (local_extra, remote_extra)
67
def _shortcut(local_rev_history, remote_rev_history):
68
local_history = set(local_rev_history)
69
remote_history = set(remote_rev_history)
70
if len(local_rev_history) == 0:
71
return set(), remote_history
72
elif len(remote_rev_history) == 0:
73
return local_history, set()
74
elif local_rev_history[-1] in remote_history:
75
return set(), _after(remote_rev_history, local_rev_history)
76
elif remote_rev_history[-1] in local_history:
77
return _after(local_rev_history, remote_rev_history), set()
81
def _after(larger_history, smaller_history):
82
return set(larger_history[larger_history.index(smaller_history[-1])+1:])
84
def _get_history(branch, progress, label, step):
85
progress.update('%s history' % label, step, 5)
86
rev_history = branch.revision_history()
87
rev_history_map = dict(
88
[(rev, rev_history.index(rev) + 1)
89
for rev in rev_history])
90
return rev_history, rev_history_map
92
def _get_ancestry(repository, progress, label, step, rev_history):
93
progress.update('%s ancestry' % label, step, 5)
94
if len(rev_history) > 0:
95
ancestry = set(repository.get_ancestry(rev_history[-1]))
94
def _enumerate_mainline(ancestry, graph, tip_revno, tip, backward=True):
95
"""Enumerate the mainline revisions for these revisions.
97
:param ancestry: A set of revisions that we care about
98
:param graph: A Graph which lets us find the parents for a revision
99
:param tip_revno: The revision number for the tip revision
100
:param tip: The tip of mainline
101
:param backward: Show oldest versions first when True, newest versions
103
:return: [(revno, revision_id)] for all revisions in ancestry that
104
are left-hand parents from tip, or None if ancestry is None.
108
if not ancestry: #Empty ancestry, no need to do any work
111
# Optionally, we could make 1 call to graph.get_parent_map with all
112
# ancestors. However that will often check many more parents than we
113
# actually need, and the Graph is likely to already have the parents cached
117
cur_revno = tip_revno
118
while cur in ancestry:
119
parent_map = graph.get_parent_map([cur])
120
parents = parent_map.get(cur)
122
break # Ghost, we are done
123
mainline.append((str(cur_revno), cur))
131
def _enumerate_with_merges(branch, ancestry, graph, tip_revno, tip,
133
"""Enumerate the revisions for the ancestry.
135
:param branch: The branch we care about
136
:param ancestry: A set of revisions that we care about
137
:param graph: A Graph which lets us find the parents for a revision
138
:param tip_revno: The revision number for the tip revision
139
:param tip: The tip of the ancsetry
140
:param backward: Show oldest versions first when True, newest versions
142
:return: [(revno, revision_id)] for all revisions in ancestry that
143
are parents from tip, or None if ancestry is None.
147
if not ancestry: #Empty ancestry, no need to do any work
150
mainline_revs, rev_nos, start_rev_id, end_rev_id = log._get_mainline_revs(
151
branch, None, tip_revno)
152
if not mainline_revs:
155
# This asks for all mainline revisions, which is size-of-history and
156
# should be addressed (but currently the only way to get correct
159
# mainline_revisions always includes an extra revision at the
160
# beginning, so don't request it.
161
parent_map = dict(((key, value) for key, value
162
in graph.iter_ancestry(mainline_revs[1:])
163
if value is not None))
164
# filter out ghosts; merge_sort errors on ghosts.
165
# XXX: is this needed here ? -- vila080910
166
rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
167
# XXX: what if rev_graph is empty now ? -- vila080910
168
merge_sorted_revisions = tsort.merge_sort(rev_graph, tip,
171
# Now that we got the correct revnos, keep only the relevant
173
merge_sorted_revisions = [
174
(s, revid, n, d, e) for s, revid, n, d, e in merge_sorted_revisions
175
if revid in ancestry]
177
merge_sorted_revisions = log.reverse_by_depth(merge_sorted_revisions)
179
for seq, rev_id, merge_depth, revno, end_of_merge in merge_sorted_revisions:
180
revline.append(('.'.join(map(str, revno)), rev_id, merge_depth))
184
def _filter_revs(graph, revs, revid_range):
185
if revid_range is None or revs is None:
187
return [rev for rev in revs
188
if graph.is_between(rev[1], revid_range[0], revid_range[1])]
191
def _find_unmerged(local_branch, remote_branch, restrict,
192
include_merges, backward,
193
local_revid_range=None, remote_revid_range=None):
194
"""See find_unmerged.
196
The branches should already be locked before entering.
198
local_revno, local_revision_id = local_branch.last_revision_info()
199
remote_revno, remote_revision_id = remote_branch.last_revision_info()
200
if local_revno == remote_revno and local_revision_id == remote_revision_id:
201
# A simple shortcut when the tips are at the same point
203
graph = local_branch.repository.get_graph(remote_branch.repository)
204
if restrict == 'remote':
206
remote_extra = graph.find_unique_ancestors(remote_revision_id,
208
elif restrict == 'local':
210
local_extra = graph.find_unique_ancestors(local_revision_id,
211
[remote_revision_id])
213
if restrict != 'all':
214
raise ValueError('param restrict not one of "all", "local",'
215
' "remote": %r' % (restrict,))
216
local_extra, remote_extra = graph.find_difference(local_revision_id,
219
locals = _enumerate_with_merges(local_branch, local_extra,
221
local_revision_id, backward)
222
remotes = _enumerate_with_merges(remote_branch, remote_extra,
224
remote_revision_id, backward)
226
# Now that we have unique ancestors, compute just the mainline, and
227
# generate revnos for them.
228
locals = _enumerate_mainline(local_extra, graph, local_revno,
229
local_revision_id, backward)
230
remotes = _enumerate_mainline(remote_extra, graph, remote_revno,
231
remote_revision_id, backward)
232
return _filter_revs(graph, locals, local_revid_range), _filter_revs(graph,
233
remotes, remote_revid_range)
101
236
def sorted_revisions(revisions, history_map):
102
237
revisions = [(history_map[r],r) for r in revisions]
added
removed
bzrlib/missing.py
