← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/missing.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-27 23:02:21 UTC
  • mto: (3964.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3965.
  • Revision ID: ian.clatworthy@canonical.com-20090127230221-mqumav0ghxkpybba
feedback from jam's review

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
19
from bzrlib import (
20
20
    log,
21
 
    symbol_versioning,
 
21
    repository as _mod_repository,
 
22
    tsort,
22
23
    )
23
24
import bzrlib.revision as _mod_revision
24
25
 
36
37
            revno, rev_id, merge_depth = rev
37
38
        rev = revision_source.get_revision(rev_id)
38
39
        if verbose:
39
 
            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)
40
50
        else:
41
51
            delta = None
42
52
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
43
53
 
44
54
 
45
55
def find_unmerged(local_branch, remote_branch, restrict='all',
46
 
                  include_merged=None, backward=False,
47
 
                  local_revid_range=None, remote_revid_range=None,
48
 
                  include_merges=symbol_versioning.DEPRECATED_PARAMETER):
 
56
                  include_merges=False, backward=False):
49
57
    """Find revisions from each side that have not been merged.
50
58
 
51
59
    :param local_branch: Compare the history of local_branch
55
63
        unique revisions from both sides. If 'local', we will return None
56
64
        for the remote revisions, similarly if 'remote' we will return None for
57
65
        the local revisions.
58
 
    :param include_merged: Show mainline revisions only if False,
 
66
    :param include_merges: Show mainline revisions only if False,
59
67
        all revisions otherwise.
60
68
    :param backward: Show oldest versions first when True, newest versions
61
 
        first when False.
62
 
    :param local_revid_range: Revision-id range for filtering local_branch
63
 
        revisions (lower bound, upper bound)
64
 
    :param remote_revid_range: Revision-id range for filtering remote_branch
65
 
        revisions (lower bound, upper bound)
66
 
    :param include_merges: Deprecated historical alias for include_merged
 
69
        first when False. 
67
70
 
68
71
    :return: A list of [(revno, revision_id)] for the mainline revisions on
69
72
        each side.
70
73
    """
71
 
    if symbol_versioning.deprecated_passed(include_merges):
72
 
        symbol_versioning.warn(
73
 
            'include_merges was deprecated in 2.5.'
74
 
            ' Use include_merged instead.',
75
 
            DeprecationWarning, stacklevel=2)
76
 
        if include_merged is None:
77
 
            include_merged = include_merges
78
 
    if include_merged is None:
79
 
        include_merged = False
80
74
    local_branch.lock_read()
81
75
    try:
82
76
        remote_branch.lock_read()
83
77
        try:
84
78
            return _find_unmerged(
85
79
                local_branch, remote_branch, restrict=restrict,
86
 
                include_merged=include_merged, backward=backward,
87
 
                local_revid_range=local_revid_range,
88
 
                remote_revid_range=remote_revid_range)
 
80
                include_merges=include_merges, backward=backward)
89
81
        finally:
90
82
            remote_branch.unlock()
91
83
    finally:
100
92
    :param tip_revno: The revision number for the tip revision
101
93
    :param tip: The tip of mainline
102
94
    :param backward: Show oldest versions first when True, newest versions
103
 
        first when False.
 
95
        first when False. 
104
96
    :return: [(revno, revision_id)] for all revisions in ancestry that
105
97
        are left-hand parents from tip, or None if ancestry is None.
106
98
    """
139
131
    :param tip_revno: The revision number for the tip revision
140
132
    :param tip: The tip of the ancsetry
141
133
    :param backward: Show oldest versions first when True, newest versions
142
 
        first when False.
 
134
        first when False. 
143
135
    :return: [(revno, revision_id)] for all revisions in ancestry that
144
136
        are parents from tip, or None if ancestry is None.
145
137
    """
148
140
    if not ancestry: #Empty ancestry, no need to do any work
149
141
        return []
150
142
 
151
 
    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)
152
164
    # Now that we got the correct revnos, keep only the relevant
153
165
    # revisions.
154
166
    merge_sorted_revisions = [
155
 
        # log.reverse_by_depth expects seq_num to be present, but it is
156
 
        # stripped by iter_merge_sorted_revisions()
157
 
        (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
158
168
        if revid in ancestry]
159
169
    if not backward:
160
170
        merge_sorted_revisions = log.reverse_by_depth(merge_sorted_revisions)
164
174
    return revline
165
175
 
166
176
 
167
 
def _filter_revs(graph, revs, revid_range):
168
 
    if revid_range is None or revs is None:
169
 
        return revs
170
 
    return [rev for rev in revs
171
 
        if graph.is_between(rev[1], revid_range[0], revid_range[1])]
172
 
 
173
 
 
174
177
def _find_unmerged(local_branch, remote_branch, restrict,
175
 
                   include_merged, backward,
176
 
                   local_revid_range=None, remote_revid_range=None):
 
178
                   include_merges, backward):
177
179
    """See find_unmerged.
178
180
 
179
181
    The branches should already be locked before entering.
198
200
                             ' "remote": %r' % (restrict,))
199
201
        local_extra, remote_extra = graph.find_difference(local_revision_id,
200
202
                                                          remote_revision_id)
201
 
    if include_merged:
 
203
    if include_merges:
202
204
        locals = _enumerate_with_merges(local_branch, local_extra,
203
205
                                        graph, local_revno,
204
206
                                        local_revision_id, backward)
212
214
                                     local_revision_id, backward)
213
215
        remotes = _enumerate_mainline(remote_extra, graph, remote_revno,
214
216
                                      remote_revision_id, backward)
215
 
    return _filter_revs(graph, locals, local_revid_range), _filter_revs(graph,
216
 
        remotes, remote_revid_range)
 
217
    return locals, remotes
217
218
 
218
219
 
219
220
def sorted_revisions(revisions, history_map):