← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/missing.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-25 21:50:11 UTC
  • mfrom: (0.11.3 tools)
  • mto: This revision was merged to the branch mainline in revision 3659.
  • Revision ID: john@arbash-meinel.com-20080825215011-de9esmzgkue3e522
Merge in Lukáš's helper scripts.
Update the packaging documents to describe how to do the releases
using bzr-builddeb to package all distro platforms
simultaneously.

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 bzrlib import (
20
 
    log,
21
 
    repository as _mod_repository,
22
 
    tsort,
 
19
from bzrlib.log import (
 
20
    LogRevision,
23
21
    )
24
 
import bzrlib.revision as _mod_revision
25
22
 
26
23
 
27
24
def iter_log_revisions(revisions, revision_source, verbose):
28
 
    last_tree = revision_source.revision_tree(_mod_revision.NULL_REVISION)
 
25
    last_tree = revision_source.revision_tree(None)
29
26
    last_rev_id = None
30
 
    for rev in revisions:
31
 
        # We need the following for backward compatibilty (hopefully
32
 
        # this will be deprecated soon :-/) -- vila 080911
33
 
        if len(rev) == 2:
34
 
            revno, rev_id = rev
35
 
            merge_depth = 0
36
 
        else:
37
 
            revno, rev_id, merge_depth = rev
 
27
    for revno, rev_id in revisions:
38
28
        rev = revision_source.get_revision(rev_id)
39
29
        if verbose:
40
 
            delta = revision_source.get_revision_delta(rev_id)
 
30
            remote_tree = revision_source.revision_tree(rev_id)
 
31
            parent_rev_id = rev.parent_ids[0]
 
32
            if last_rev_id == parent_rev_id:
 
33
                parent_tree = last_tree
 
34
            else:
 
35
                parent_tree = revision_source.revision_tree(parent_rev_id)
 
36
            revision_tree = revision_source.revision_tree(rev_id)
 
37
            last_rev_id = rev_id
 
38
            last_tree = revision_tree
 
39
            delta = revision_tree.changes_from(parent_tree)
41
40
        else:
42
41
            delta = None
43
 
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
44
 
 
45
 
 
46
 
def find_unmerged(local_branch, remote_branch, restrict='all',
47
 
                  include_merges=False, backward=False,
48
 
                  local_revid_range=None, remote_revid_range=None):
 
42
        yield LogRevision(rev, revno, delta=delta)
 
43
 
 
44
 
 
45
def find_unmerged(local_branch, remote_branch, restrict='all'):
49
46
    """Find revisions from each side that have not been merged.
50
47
 
51
48
    :param local_branch: Compare the history of local_branch
55
52
        unique revisions from both sides. If 'local', we will return None
56
53
        for the remote revisions, similarly if 'remote' we will return None for
57
54
        the local revisions.
58
 
    :param include_merges: Show mainline revisions only if False,
59
 
        all revisions otherwise.
60
 
    :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
55
 
67
56
    :return: A list of [(revno, revision_id)] for the mainline revisions on
68
57
        each side.
71
60
    try:
72
61
        remote_branch.lock_read()
73
62
        try:
74
 
            return _find_unmerged(
75
 
                local_branch, remote_branch, restrict=restrict,
76
 
                include_merges=include_merges, backward=backward,
77
 
                local_revid_range=local_revid_range,
78
 
                remote_revid_range=remote_revid_range)
 
63
            return _find_unmerged(local_branch,
 
64
                remote_branch, restrict=restrict)
79
65
        finally:
80
66
            remote_branch.unlock()
81
67
    finally:
82
68
        local_branch.unlock()
83
69
 
84
70
 
85
 
def _enumerate_mainline(ancestry, graph, tip_revno, tip, backward=True):
 
71
def _enumerate_mainline(ancestry, graph, tip_revno, tip):
86
72
    """Enumerate the mainline revisions for these revisions.
87
73
 
88
74
    :param ancestry: A set of revisions that we care about
89
75
    :param graph: A Graph which lets us find the parents for a revision
90
76
    :param tip_revno: The revision number for the tip revision
91
77
    :param tip: The tip of mainline
92
 
    :param backward: Show oldest versions first when True, newest versions
93
 
        first when False.
94
78
    :return: [(revno, revision_id)] for all revisions in ancestry that
95
79
        are left-hand parents from tip, or None if ancestry is None.
96
80
    """
111
95
        parents = parent_map.get(cur)
112
96
        if not parents:
113
97
            break # Ghost, we are done
114
 
        mainline.append((str(cur_revno), cur))
 
98
        mainline.append((cur_revno, cur))
115
99
        cur = parents[0]
116
100
        cur_revno -= 1
117
 
    if not backward:
118
 
        mainline.reverse()
 
101
    mainline.reverse()
119
102
    return mainline
120
103
 
121
104
 
122
 
def _enumerate_with_merges(branch, ancestry, graph, tip_revno, tip,
123
 
                           backward=True):
124
 
    """Enumerate the revisions for the ancestry.
125
 
 
126
 
    :param branch: The branch we care about
127
 
    :param ancestry: A set of revisions that we care about
128
 
    :param graph: A Graph which lets us find the parents for a revision
129
 
    :param tip_revno: The revision number for the tip revision
130
 
    :param tip: The tip of the ancsetry
131
 
    :param backward: Show oldest versions first when True, newest versions
132
 
        first when False.
133
 
    :return: [(revno, revision_id)] for all revisions in ancestry that
134
 
        are parents from tip, or None if ancestry is None.
135
 
    """
136
 
    if ancestry is None:
137
 
        return None
138
 
    if not ancestry: #Empty ancestry, no need to do any work
139
 
        return []
140
 
 
141
 
    merge_sorted_revisions = branch.iter_merge_sorted_revisions()
142
 
    # Now that we got the correct revnos, keep only the relevant
143
 
    # revisions.
144
 
    merge_sorted_revisions = [
145
 
        # log.reverse_by_depth expects seq_num to be present, but it is
146
 
        # stripped by iter_merge_sorted_revisions()
147
 
        (0, revid, n, d, e) for revid, n, d, e in merge_sorted_revisions
148
 
        if revid in ancestry]
149
 
    if not backward:
150
 
        merge_sorted_revisions = log.reverse_by_depth(merge_sorted_revisions)
151
 
    revline = []
152
 
    for seq, rev_id, merge_depth, revno, end_of_merge in merge_sorted_revisions:
153
 
        revline.append(('.'.join(map(str, revno)), rev_id, merge_depth))
154
 
    return revline
155
 
 
156
 
 
157
 
def _filter_revs(graph, revs, revid_range):
158
 
    if revid_range is None or revs is None:
159
 
        return revs
160
 
    return [rev for rev in revs
161
 
        if graph.is_between(rev[1], revid_range[0], revid_range[1])]
162
 
 
163
 
 
164
 
def _find_unmerged(local_branch, remote_branch, restrict,
165
 
                   include_merges, backward,
166
 
                   local_revid_range=None, remote_revid_range=None):
 
105
def _find_unmerged(local_branch, remote_branch, restrict):
167
106
    """See find_unmerged.
168
107
 
169
108
    The branches should already be locked before entering.
173
112
    if local_revno == remote_revno and local_revision_id == remote_revision_id:
174
113
        # A simple shortcut when the tips are at the same point
175
114
        return [], []
176
 
    graph = local_branch.repository.get_graph(remote_branch.repository)
 
115
    graph = local_branch.repository.get_graph(
 
116
                remote_branch.repository)
177
117
    if restrict == 'remote':
178
118
        local_extra = None
179
 
        remote_extra = graph.find_unique_ancestors(remote_revision_id,
180
 
                                                   [local_revision_id])
 
119
        remote_extra = graph.find_unique_ancestors(
 
120
            remote_revision_id, [local_revision_id])
181
121
    elif restrict == 'local':
182
122
        remote_extra = None
183
 
        local_extra = graph.find_unique_ancestors(local_revision_id,
184
 
                                                  [remote_revision_id])
 
123
        local_extra = graph.find_unique_ancestors(
 
124
            local_revision_id, [remote_revision_id])
185
125
    else:
186
126
        if restrict != 'all':
187
127
            raise ValueError('param restrict not one of "all", "local",'
188
128
                             ' "remote": %r' % (restrict,))
189
 
        local_extra, remote_extra = graph.find_difference(local_revision_id,
190
 
                                                          remote_revision_id)
191
 
    if include_merges:
192
 
        locals = _enumerate_with_merges(local_branch, local_extra,
193
 
                                        graph, local_revno,
194
 
                                        local_revision_id, backward)
195
 
        remotes = _enumerate_with_merges(remote_branch, remote_extra,
196
 
                                         graph, remote_revno,
197
 
                                         remote_revision_id, backward)
198
 
    else:
199
 
        # Now that we have unique ancestors, compute just the mainline, and
200
 
        # generate revnos for them.
201
 
        locals = _enumerate_mainline(local_extra, graph, local_revno,
202
 
                                     local_revision_id, backward)
203
 
        remotes = _enumerate_mainline(remote_extra, graph, remote_revno,
204
 
                                      remote_revision_id, backward)
205
 
    return _filter_revs(graph, locals, local_revid_range), _filter_revs(graph,
206
 
        remotes, remote_revid_range)
 
129
        local_extra, remote_extra = graph.find_difference(
 
130
            local_revision_id, remote_revision_id)
 
131
    # Now that we have unique ancestors, compute just the mainline, and
 
132
    # generate revnos for them.
 
133
    local_mainline = _enumerate_mainline(local_extra, graph, local_revno,
 
134
                                         local_revision_id)
 
135
    remote_mainline = _enumerate_mainline(remote_extra, graph, remote_revno,
 
136
                                          remote_revision_id)
 
137
    return local_mainline, remote_mainline
207
138
 
208
139
 
209
140
def sorted_revisions(revisions, history_map):