← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/missing.py

  • Committer: Martin Pool
  • Date: 2009-01-13 03:06:36 UTC
  • mfrom: (3932.2.3 1.11)
  • mto: This revision was merged to the branch mainline in revision 3937.
  • Revision ID: mbp@sourcefrog.net-20090113030636-dqx4t8yaaqgdvam5
Merge 1.11rc1

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/missing.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
19
from bzrlib import (
22
20
    log,
23
 
    symbol_versioning,
 
21
    repository as _mod_repository,
 
22
    tsort,
24
23
    )
25
24
import bzrlib.revision as _mod_revision
26
25
 
27
26
 
28
 
def iter_log_revisions(revisions, revision_source, verbose, rev_tag_dict=None):
 
27
def iter_log_revisions(revisions, revision_source, verbose):
29
28
    last_tree = revision_source.revision_tree(_mod_revision.NULL_REVISION)
30
29
    last_rev_id = None
31
 
 
32
 
    if rev_tag_dict is None:
33
 
        rev_tag_dict = {}
34
30
    for rev in revisions:
35
31
        # We need the following for backward compatibilty (hopefully
36
32
        # this will be deprecated soon :-/) -- vila 080911
41
37
            revno, rev_id, merge_depth = rev
42
38
        rev = revision_source.get_revision(rev_id)
43
39
        if verbose:
44
 
            delta = revision_source.get_revision_delta(rev_id)
 
40
            remote_tree = revision_source.revision_tree(rev_id)
 
41
            parent_rev_id = rev.parent_ids[0]
 
42
            if last_rev_id == parent_rev_id:
 
43
                parent_tree = last_tree
 
44
            else:
 
45
                parent_tree = revision_source.revision_tree(parent_rev_id)
 
46
            revision_tree = revision_source.revision_tree(rev_id)
 
47
            last_rev_id = rev_id
 
48
            last_tree = revision_tree
 
49
            delta = revision_tree.changes_from(parent_tree)
45
50
        else:
46
51
            delta = None
47
 
        yield log.LogRevision(rev, revno, merge_depth, delta=delta,
48
 
                              tags=rev_tag_dict.get(rev_id))
 
52
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
49
53
 
50
54
 
51
55
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):
 
56
                  include_merges=False, backward=False):
55
57
    """Find revisions from each side that have not been merged.
56
58
 
57
59
    :param local_branch: Compare the history of local_branch
61
63
        unique revisions from both sides. If 'local', we will return None
62
64
        for the remote revisions, similarly if 'remote' we will return None for
63
65
        the local revisions.
64
 
    :param include_merged: Show mainline revisions only if False,
 
66
    :param include_merges: Show mainline revisions only if False,
65
67
        all revisions otherwise.
66
68
    :param backward: Show oldest versions first when True, newest versions
67
 
        first when False.
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
 
69
        first when False. 
73
70
 
74
71
    :return: A list of [(revno, revision_id)] for the mainline revisions on
75
72
        each side.
76
73
    """
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
74
    local_branch.lock_read()
87
75
    try:
88
76
        remote_branch.lock_read()
89
77
        try:
90
78
            return _find_unmerged(
91
79
                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)
 
80
                include_merges=include_merges, backward=backward)
95
81
        finally:
96
82
            remote_branch.unlock()
97
83
    finally:
106
92
    :param tip_revno: The revision number for the tip revision
107
93
    :param tip: The tip of mainline
108
94
    :param backward: Show oldest versions first when True, newest versions
109
 
        first when False.
 
95
        first when False. 
110
96
    :return: [(revno, revision_id)] for all revisions in ancestry that
111
97
        are left-hand parents from tip, or None if ancestry is None.
112
98
    """
145
131
    :param tip_revno: The revision number for the tip revision
146
132
    :param tip: The tip of the ancsetry
147
133
    :param backward: Show oldest versions first when True, newest versions
148
 
        first when False.
 
134
        first when False. 
149
135
    :return: [(revno, revision_id)] for all revisions in ancestry that
150
136
        are parents from tip, or None if ancestry is None.
151
137
    """
154
140
    if not ancestry: #Empty ancestry, no need to do any work
155
141
        return []
156
142
 
157
 
    merge_sorted_revisions = branch.iter_merge_sorted_revisions()
 
143
    mainline_revs, rev_nos, start_rev_id, end_rev_id = log._get_mainline_revs(
 
144
        branch, None, tip_revno)
 
145
    if not mainline_revs:
 
146
        return []
 
147
 
 
148
    # This asks for all mainline revisions, which is size-of-history and
 
149
    # should be addressed (but currently the only way to get correct
 
150
    # revnos).
 
151
 
 
152
    # mainline_revisions always includes an extra revision at the
 
153
    # beginning, so don't request it.
 
154
    parent_map = dict(((key, value) for key, value
 
155
                       in graph.iter_ancestry(mainline_revs[1:])
 
156
                       if value is not None))
 
157
    # filter out ghosts; merge_sort errors on ghosts. 
 
158
    # XXX: is this needed here ? -- vila080910
 
159
    rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
 
160
    # XXX: what if rev_graph is empty now ? -- vila080910
 
161
    merge_sorted_revisions = tsort.merge_sort(rev_graph, tip,
 
162
                                              mainline_revs,
 
163
                                              generate_revno=True)
158
164
    # Now that we got the correct revnos, keep only the relevant
159
165
    # revisions.
160
166
    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
 
167
        (s, revid, n, d, e) for s, revid, n, d, e in merge_sorted_revisions
164
168
        if revid in ancestry]
165
169
    if not backward:
166
170
        merge_sorted_revisions = log.reverse_by_depth(merge_sorted_revisions)
170
174
    return revline
171
175
 
172
176
 
173
 
def _filter_revs(graph, revs, revid_range):
174
 
    if revid_range is None or revs is None:
175
 
        return revs
176
 
    return [rev for rev in revs
177
 
        if graph.is_between(rev[1], revid_range[0], revid_range[1])]
178
 
 
179
 
 
180
177
def _find_unmerged(local_branch, remote_branch, restrict,
181
 
                   include_merged, backward,
182
 
                   local_revid_range=None, remote_revid_range=None):
 
178
                   include_merges, backward):
183
179
    """See find_unmerged.
184
180
 
185
181
    The branches should already be locked before entering.
204
200
                             ' "remote": %r' % (restrict,))
205
201
        local_extra, remote_extra = graph.find_difference(local_revision_id,
206
202
                                                          remote_revision_id)
207
 
    if include_merged:
 
203
    if include_merges:
208
204
        locals = _enumerate_with_merges(local_branch, local_extra,
209
205
                                        graph, local_revno,
210
206
                                        local_revision_id, backward)
218
214
                                     local_revision_id, backward)
219
215
        remotes = _enumerate_mainline(remote_extra, graph, remote_revno,
220
216
                                      remote_revision_id, backward)
221
 
    return _filter_revs(graph, locals, local_revid_range), _filter_revs(graph,
222
 
        remotes, remote_revid_range)
 
217
    return locals, remotes
223
218
 
224
219
 
225
220
def sorted_revisions(revisions, history_map):