/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/missing.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-08 21:56:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3773.
  • Revision ID: john@arbash-meinel.com-20081008215612-y9v94tqxreqoangx
Simplify the --raw mode.

I didn't realize, but the only node that is special cased is the 'root' node,
and to read it, you actually have to parse it directly, because the
compressed bytes start immediately after the end of the header, rather than
having any padding before the zlib bytes.

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