3
A plugin for displaying what revisions are in 'other' but not in local.
11
from sets import Set as set
14
def show_missing(br_local, br_remote, verbose=False, quiet=False):
15
"""Show the revisions which exist in br_remote, that
16
do not exist in br_local.
18
from bzrlib.log import show_one_log
20
local_history = br_local.revision_history()
21
remote_history = br_remote.revision_history()
22
if local_history == remote_history:
24
print 'Trees are identical.'
26
if local_history[:len(remote_history)] == remote_history:
27
# Local is not missing anything from remote, so consider it
30
print 'Local tree has all of remote revisions (remote is missing local)'
35
# Check for divergence
36
common_idx = min(len(local_history), len(remote_history)) - 1
37
if common_idx >= 0 and local_history[common_idx] != remote_history[common_idx]:
38
print 'Trees have diverged'
40
local_rev_set = set(local_history)
42
# Find the last common revision between the two trees
44
for revno, (local_rev, remote_rev) in enumerate(zip(local_history, remote_history)):
45
if local_rev != remote_rev:
49
for rno, rev_id in enumerate(remote_history[revno:]):
50
# This assumes that you can have a revision in the
51
# local history, which does not have the same ancestry
52
# as the remote ancestry.
53
# This may or may not be possible.
54
# In the future this should also checked for merged revisions.
55
if rev_id not in local_rev_set:
56
missing_remote.append((rno+revno+1, rev_id))
58
print 'Missing %d revisions' % len(missing_remote)
62
from bzrlib.diff import compare_trees
63
from bzrlib.tree import EmptyTree
69
for revno, rev_id in missing_remote:
70
rev = br_remote.get_revision(rev_id)
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Display what revisions are missing in 'other' from 'this' and vice versa."""
19
from __future__ import absolute_import
25
import bzrlib.revision as _mod_revision
28
def iter_log_revisions(revisions, revision_source, verbose, rev_tag_dict=None):
29
last_tree = revision_source.revision_tree(_mod_revision.NULL_REVISION)
32
if rev_tag_dict is None:
35
# We need the following for backward compatibilty (hopefully
36
# this will be deprecated soon :-/) -- vila 080911
41
revno, rev_id, merge_depth = rev
42
rev = revision_source.get_revision(rev_id)
72
parent_rev_id = rev.parents[0].revision_id
73
if last_rev_id == parent_rev_id:
74
parent_tree = last_tree
76
parent_tree = br_remote.revision_tree(parent_rev_id)
77
revision_tree = br_remote.revision_tree(rev_id)
79
last_tree = revision_tree
80
delta = compare_trees(revision_tree, parent_tree)
44
delta = revision_source.get_revision_delta(rev_id)
84
show_one_log(revno, rev, delta, verbose, sys.stdout, 'original')
47
yield log.LogRevision(rev, revno, merge_depth, delta=delta,
48
tags=rev_tag_dict.get(rev_id))
51
def find_unmerged(local_branch, remote_branch, restrict='all',
52
include_merged=None, backward=False,
53
local_revid_range=None, remote_revid_range=None,
54
include_merges=symbol_versioning.DEPRECATED_PARAMETER):
55
"""Find revisions from each side that have not been merged.
57
:param local_branch: Compare the history of local_branch
58
:param remote_branch: versus the history of remote_branch, and determine
59
mainline revisions which have not been merged.
60
:param restrict: ('all', 'local', 'remote') If 'all', we will return the
61
unique revisions from both sides. If 'local', we will return None
62
for the remote revisions, similarly if 'remote' we will return None for
64
:param include_merged: Show mainline revisions only if False,
65
all revisions otherwise.
66
:param backward: Show oldest versions first when True, newest versions
68
:param local_revid_range: Revision-id range for filtering local_branch
69
revisions (lower bound, upper bound)
70
:param remote_revid_range: Revision-id range for filtering remote_branch
71
revisions (lower bound, upper bound)
72
:param include_merges: Deprecated historical alias for include_merged
74
:return: A list of [(revno, revision_id)] for the mainline revisions on
77
if symbol_versioning.deprecated_passed(include_merges):
78
symbol_versioning.warn(
79
'include_merges was deprecated in 2.5.'
80
' Use include_merged instead.',
81
DeprecationWarning, stacklevel=2)
82
if include_merged is None:
83
include_merged = include_merges
84
if include_merged is None:
85
include_merged = False
86
local_branch.lock_read()
88
remote_branch.lock_read()
90
return _find_unmerged(
91
local_branch, remote_branch, restrict=restrict,
92
include_merged=include_merged, backward=backward,
93
local_revid_range=local_revid_range,
94
remote_revid_range=remote_revid_range)
96
remote_branch.unlock()
101
def _enumerate_mainline(ancestry, graph, tip_revno, tip, backward=True):
102
"""Enumerate the mainline revisions for these revisions.
104
:param ancestry: A set of revisions that we care about
105
:param graph: A Graph which lets us find the parents for a revision
106
:param tip_revno: The revision number for the tip revision
107
:param tip: The tip of mainline
108
:param backward: Show oldest versions first when True, newest versions
110
:return: [(revno, revision_id)] for all revisions in ancestry that
111
are left-hand parents from tip, or None if ancestry is None.
115
if not ancestry: #Empty ancestry, no need to do any work
118
# Optionally, we could make 1 call to graph.get_parent_map with all
119
# ancestors. However that will often check many more parents than we
120
# actually need, and the Graph is likely to already have the parents cached
124
cur_revno = tip_revno
125
while cur in ancestry:
126
parent_map = graph.get_parent_map([cur])
127
parents = parent_map.get(cur)
129
break # Ghost, we are done
130
mainline.append((str(cur_revno), cur))
138
def _enumerate_with_merges(branch, ancestry, graph, tip_revno, tip,
140
"""Enumerate the revisions for the ancestry.
142
:param branch: The branch we care about
143
:param ancestry: A set of revisions that we care about
144
:param graph: A Graph which lets us find the parents for a revision
145
:param tip_revno: The revision number for the tip revision
146
:param tip: The tip of the ancsetry
147
:param backward: Show oldest versions first when True, newest versions
149
:return: [(revno, revision_id)] for all revisions in ancestry that
150
are parents from tip, or None if ancestry is None.
154
if not ancestry: #Empty ancestry, no need to do any work
157
merge_sorted_revisions = branch.iter_merge_sorted_revisions()
158
# Now that we got the correct revnos, keep only the relevant
160
merge_sorted_revisions = [
161
# log.reverse_by_depth expects seq_num to be present, but it is
162
# stripped by iter_merge_sorted_revisions()
163
(0, revid, n, d, e) for revid, n, d, e in merge_sorted_revisions
164
if revid in ancestry]
166
merge_sorted_revisions = log.reverse_by_depth(merge_sorted_revisions)
168
for seq, rev_id, merge_depth, revno, end_of_merge in merge_sorted_revisions:
169
revline.append(('.'.join(map(str, revno)), rev_id, merge_depth))
173
def _filter_revs(graph, revs, revid_range):
174
if revid_range is None or revs is None:
176
return [rev for rev in revs
177
if graph.is_between(rev[1], revid_range[0], revid_range[1])]
180
def _find_unmerged(local_branch, remote_branch, restrict,
181
include_merged, backward,
182
local_revid_range=None, remote_revid_range=None):
183
"""See find_unmerged.
185
The branches should already be locked before entering.
187
local_revno, local_revision_id = local_branch.last_revision_info()
188
remote_revno, remote_revision_id = remote_branch.last_revision_info()
189
if local_revno == remote_revno and local_revision_id == remote_revision_id:
190
# A simple shortcut when the tips are at the same point
192
graph = local_branch.repository.get_graph(remote_branch.repository)
193
if restrict == 'remote':
195
remote_extra = graph.find_unique_ancestors(remote_revision_id,
197
elif restrict == 'local':
199
local_extra = graph.find_unique_ancestors(local_revision_id,
200
[remote_revision_id])
202
if restrict != 'all':
203
raise ValueError('param restrict not one of "all", "local",'
204
' "remote": %r' % (restrict,))
205
local_extra, remote_extra = graph.find_difference(local_revision_id,
208
locals = _enumerate_with_merges(local_branch, local_extra,
210
local_revision_id, backward)
211
remotes = _enumerate_with_merges(remote_branch, remote_extra,
213
remote_revision_id, backward)
215
# Now that we have unique ancestors, compute just the mainline, and
216
# generate revnos for them.
217
locals = _enumerate_mainline(local_extra, graph, local_revno,
218
local_revision_id, backward)
219
remotes = _enumerate_mainline(remote_extra, graph, remote_revno,
220
remote_revision_id, backward)
221
return _filter_revs(graph, locals, local_revid_range), _filter_revs(graph,
222
remotes, remote_revid_range)
225
def sorted_revisions(revisions, history_map):
226
revisions = [(history_map[r],r) for r in revisions]
added
removed
bzrlib/missing.py
