← 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: 2007-02-08 16:28:05 UTC
  • mto: This revision was merged to the branch mainline in revision 2278.
  • Revision ID: john@arbash-meinel.com-20070208162805-dcqiqrwjh9a5lo7n
``GPGStrategy.sign()`` will now raise ``BzrBadParameterUnicode`` if
you pass a Unicode string rather than an 8-bit string. It doesn't 
make sense to sign a Unicode string, and it turns out that some 
versions of python will write out the raw Unicode bytes rather than
encoding automatically. So fail and make callers do the right thing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/missing.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Display what revisions are missing in 'other' from 'this' and vice versa."""
 
18
 
 
19
import bzrlib.ui as ui
 
20
 
 
21
 
 
22
def iter_log_data(revisions, revision_source, verbose):
 
23
    last_tree = revision_source.revision_tree(None)
 
24
    last_rev_id = None
 
25
    for revno, rev_id in revisions:
 
26
        rev = revision_source.get_revision(rev_id)
 
27
        if verbose:
 
28
            remote_tree = revision_source.revision_tree(rev_id)
 
29
            parent_rev_id = rev.parent_ids[0]
 
30
            if last_rev_id == parent_rev_id:
 
31
                parent_tree = last_tree
 
32
            else:
 
33
                parent_tree = revision_source.revision_tree(parent_rev_id)
 
34
            revision_tree = revision_source.revision_tree(rev_id)
 
35
            last_rev_id = rev_id
 
36
            last_tree = revision_tree
 
37
            delta = revision_tree.changes_from(parent_tree)
 
38
        else:
 
39
            delta = None
 
40
        yield revno, rev, delta
 
41
 
 
42
 
 
43
def find_unmerged(local_branch, remote_branch):
 
44
    progress = ui.ui_factory.nested_progress_bar()
 
45
    local_branch.lock_read()
 
46
    try:
 
47
        remote_branch.lock_read()
 
48
        try:
 
49
            local_rev_history, local_rev_history_map = \
 
50
                _get_history(local_branch, progress, "local", 0)
 
51
            remote_rev_history, remote_rev_history_map = \
 
52
                _get_history(remote_branch, progress, "remote", 1)
 
53
            result = _shortcut(local_rev_history, remote_rev_history)
 
54
            if result is not None:
 
55
                local_extra, remote_extra = result
 
56
                local_extra = sorted_revisions(local_extra, 
 
57
                                               local_rev_history_map)
 
58
                remote_extra = sorted_revisions(remote_extra, 
 
59
                                                remote_rev_history_map)
 
60
                return local_extra, remote_extra
 
61
 
 
62
            local_ancestry = _get_ancestry(local_branch.repository, progress, 
 
63
                                           "local", 2, local_rev_history)
 
64
            remote_ancestry = _get_ancestry(remote_branch.repository, progress,
 
65
                                            "remote", 3, remote_rev_history)
 
66
            progress.update('pondering', 4, 5)
 
67
            extras = local_ancestry.symmetric_difference(remote_ancestry) 
 
68
            local_extra = extras.intersection(set(local_rev_history))
 
69
            remote_extra = extras.intersection(set(remote_rev_history))
 
70
            local_extra = sorted_revisions(local_extra, local_rev_history_map)
 
71
            remote_extra = sorted_revisions(remote_extra, 
 
72
                                            remote_rev_history_map)
 
73
                    
 
74
        finally:
 
75
            remote_branch.unlock()
 
76
    finally:
 
77
        local_branch.unlock()
 
78
        progress.finished()
 
79
    return (local_extra, remote_extra)
 
80
 
 
81
def _shortcut(local_rev_history, remote_rev_history):
 
82
    local_history = set(local_rev_history)
 
83
    remote_history = set(remote_rev_history)
 
84
    if len(local_rev_history) == 0:
 
85
        return set(), remote_history
 
86
    elif len(remote_rev_history) == 0:
 
87
        return local_history, set()
 
88
    elif local_rev_history[-1] in remote_history:
 
89
        return set(), _after(remote_rev_history, local_rev_history)
 
90
    elif remote_rev_history[-1] in local_history:
 
91
        return _after(local_rev_history, remote_rev_history), set()
 
92
    else:
 
93
        return None
 
94
 
 
95
def _after(larger_history, smaller_history):
 
96
    return set(larger_history[larger_history.index(smaller_history[-1])+1:])
 
97
 
 
98
def _get_history(branch, progress, label, step):
 
99
    progress.update('%s history' % label, step, 5)
 
100
    rev_history = branch.revision_history()
 
101
    rev_history_map = dict(
 
102
        [(rev, rev_history.index(rev) + 1)
 
103
         for rev in rev_history])
 
104
    return rev_history, rev_history_map
 
105
 
 
106
def _get_ancestry(repository, progress, label, step, rev_history):
 
107
    progress.update('%s ancestry' % label, step, 5)
 
108
    if len(rev_history) > 0:
 
109
        ancestry = set(repository.get_ancestry(rev_history[-1]))
 
110
    else:
 
111
        ancestry = set()
 
112
    return ancestry
 
113
    
 
114
 
 
115
def sorted_revisions(revisions, history_map):
 
116
    revisions = [(history_map[r],r) for r in revisions]
 
117
    revisions.sort()
 
118
    return revisions