← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/status.py

  • Committer: Ian Clatworthy
  • Date: 2009-09-09 11:43:10 UTC
  • mto: (4634.37.2 prepare-2.0)
  • mto: This revision was merged to the branch mainline in revision 4689.
  • Revision ID: ian.clatworthy@canonical.com-20090909114310-glw7tv76i5gnx9pt
put rules back in Makefile supporting plain-style docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/status.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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import sys
18
18
 
19
19
from bzrlib import (
20
20
    delta as _mod_delta,
 
21
    log,
 
22
    osutils,
21
23
    tree,
 
24
    tsort,
 
25
    revision as _mod_revision,
22
26
    )
23
 
from bzrlib.diff import _raise_if_nonexistent
24
27
import bzrlib.errors as errors
25
 
from bzrlib.log import line_log
26
28
from bzrlib.osutils import is_inside_any
27
29
from bzrlib.symbol_versioning import (deprecated_function,
28
30
        )
29
 
from bzrlib.trace import warning
 
31
from bzrlib.trace import mutter, warning
30
32
 
31
33
# TODO: when showing single-line logs, truncate to the width of the terminal
32
34
# if known, but only if really going to the terminal (not into a file)
39
41
                     show_pending=True,
40
42
                     revision=None,
41
43
                     short=False,
 
44
                     verbose=False,
42
45
                     versioned=False):
43
46
    """Display summary of changes.
44
47
 
45
 
    By default this compares the working tree to a previous revision. 
46
 
    If the revision argument is given, summarizes changes between the 
 
48
    By default this compares the working tree to a previous revision.
 
49
    If the revision argument is given, summarizes changes between the
47
50
    working tree and another, or between two revisions.
48
51
 
49
 
    The result is written out as Unicode and to_file should be able 
 
52
    The result is written out as Unicode and to_file should be able
50
53
    to encode that.
51
54
 
52
55
    If showing the status of a working tree, extra information is included
53
56
    about unknown files, conflicts, and pending merges.
54
57
 
55
 
    :param show_unchanged: Deprecated parameter. If set, includes unchanged 
 
58
    :param show_unchanged: Deprecated parameter. If set, includes unchanged
56
59
        files.
57
60
    :param specific_files: If set, a list of filenames whose status should be
58
 
        shown.  It is an error to give a filename that is not in the working 
 
61
        shown.  It is an error to give a filename that is not in the working
59
62
        tree, or in the working inventory or in the basis inventory.
60
63
    :param show_ids: If set, includes each file's id.
61
64
    :param to_file: If set, write to this file (default stdout.)
62
65
    :param show_pending: If set, write pending merges.
63
 
    :param revision: If None the compare latest revision with working tree
64
 
        If not None it must be a RevisionSpec list.
65
 
        If one revision show compared it with working tree.
66
 
        If two revisions show status between first and second.
 
66
    :param revision: If None, compare latest revision with working tree
 
67
        If not None, it must be a RevisionSpec list.
 
68
        If one revision, compare with working tree.
 
69
        If two revisions, show status between first and second.
67
70
    :param short: If True, gives short SVN-style status lines.
 
71
    :param verbose: If True, show all merged revisions, not just
 
72
        the merge tips
68
73
    :param versioned: If True, only shows versioned files.
69
74
    """
70
75
    if show_unchanged is not None:
71
 
        warn("show_status_trees with show_unchanged has been deprecated "
 
76
        warn("show_tree_status with show_unchanged has been deprecated "
72
77
             "since bzrlib 0.9", DeprecationWarning, stacklevel=2)
73
78
 
74
79
    if to_file is None:
75
80
        to_file = sys.stdout
76
 
    
 
81
 
77
82
    wt.lock_read()
78
83
    try:
79
84
        new_is_working_tree = True
84
89
            old = new.basis_tree()
85
90
        elif len(revision) > 0:
86
91
            try:
87
 
                rev_id = revision[0].in_history(wt.branch).rev_id
88
 
                old = wt.branch.repository.revision_tree(rev_id)
 
92
                old = revision[0].as_tree(wt.branch)
89
93
            except errors.NoSuchRevision, e:
90
94
                raise errors.BzrCommandError(str(e))
91
95
            if (len(revision) > 1) and (revision[1].spec is not None):
92
96
                try:
93
 
                    rev_id = revision[1].in_history(wt.branch).rev_id
94
 
                    new = wt.branch.repository.revision_tree(rev_id)
 
97
                    new = revision[1].as_tree(wt.branch)
95
98
                    new_is_working_tree = False
96
99
                except errors.NoSuchRevision, e:
97
100
                    raise errors.BzrCommandError(str(e))
100
103
        old.lock_read()
101
104
        new.lock_read()
102
105
        try:
103
 
            _raise_if_nonexistent(specific_files, old, new)
 
106
            specific_files, nonexistents \
 
107
                = _filter_nonexistent(specific_files, old, new)
104
108
            want_unversioned = not versioned
105
109
            if short:
106
 
                changes = new._iter_changes(old, show_unchanged, specific_files,
 
110
                changes = new.iter_changes(old, show_unchanged, specific_files,
107
111
                    require_versioned=False, want_unversioned=want_unversioned)
108
112
                reporter = _mod_delta._ChangeReporter(output_file=to_file,
109
113
                    unversioned_filter=new.is_ignored)
127
131
                conflicts = conflicts.select_conflicts(new, specific_files,
128
132
                    ignore_misses=True, recurse=True)[1]
129
133
            if len(conflicts) > 0 and not short:
130
 
                print >> to_file, "conflicts:"
 
134
                to_file.write("conflicts:\n")
131
135
            for conflict in conflicts:
132
136
                if short:
133
137
                    prefix = 'C  '
134
138
                else:
135
139
                    prefix = ' '
136
 
                print >> to_file, "%s %s" % (prefix, conflict)
137
 
            if new_is_working_tree and show_pending:
138
 
                show_pending_merges(new, to_file, short)
 
140
                to_file.write("%s %s\n" % (prefix, conflict))
 
141
            # Show files that were requested but don't exist (and are
 
142
            # not versioned).  We don't involve delta in this; these
 
143
            # paths are really the province of just the status
 
144
            # command, since they have more to do with how it was
 
145
            # invoked than with the tree it's operating on.
 
146
            if nonexistents and not short:
 
147
                to_file.write("nonexistent:\n")
 
148
            for nonexistent in nonexistents:
 
149
                # We could calculate prefix outside the loop but, given
 
150
                # how rarely this ought to happen, it's OK and arguably
 
151
                # slightly faster to do it here (ala conflicts above)
 
152
                if short:
 
153
                    prefix = 'X  '
 
154
                else:
 
155
                    prefix = ' '
 
156
                to_file.write("%s %s\n" % (prefix, nonexistent))
 
157
            if (new_is_working_tree and show_pending):
 
158
                show_pending_merges(new, to_file, short, verbose=verbose)
 
159
            if nonexistents:
 
160
                raise errors.PathsDoNotExist(nonexistents)
139
161
        finally:
140
162
            old.unlock()
141
163
            new.unlock()
142
164
    finally:
143
165
        wt.unlock()
144
166
 
145
 
def show_pending_merges(new, to_file, short=False):
 
167
 
 
168
def _get_sorted_revisions(tip_revision, revision_ids, parent_map):
 
169
    """Get an iterator which will return the revisions in merge sorted order.
 
170
 
 
171
    This will build up a list of all nodes, such that only nodes in the list
 
172
    are referenced. It then uses MergeSorter to return them in 'merge-sorted'
 
173
    order.
 
174
 
 
175
    :param revision_ids: A set of revision_ids
 
176
    :param parent_map: The parent information for each node. Revisions which
 
177
        are considered ghosts should not be present in the map.
 
178
    :return: iterator from MergeSorter.iter_topo_order()
 
179
    """
 
180
    # MergeSorter requires that all nodes be present in the graph, so get rid
 
181
    # of any references pointing outside of this graph.
 
182
    parent_graph = {}
 
183
    for revision_id in revision_ids:
 
184
        if revision_id not in parent_map: # ghost
 
185
            parent_graph[revision_id] = []
 
186
        else:
 
187
            # Only include parents which are in this sub-graph
 
188
            parent_graph[revision_id] = [p for p in parent_map[revision_id]
 
189
                                            if p in revision_ids]
 
190
    sorter = tsort.MergeSorter(parent_graph, tip_revision)
 
191
    return sorter.iter_topo_order()
 
192
 
 
193
 
 
194
def show_pending_merges(new, to_file, short=False, verbose=False):
146
195
    """Write out a display of pending merges in a working tree."""
147
196
    parents = new.get_parent_ids()
148
197
    if len(parents) < 2:
149
198
        return
 
199
 
 
200
    # we need one extra space for terminals that wrap on last char
 
201
    term_width = osutils.terminal_width() - 1
 
202
    if short:
 
203
        first_prefix = 'P   '
 
204
        sub_prefix = 'P.   '
 
205
    else:
 
206
        first_prefix = '  '
 
207
        sub_prefix = '    '
 
208
 
150
209
    pending = parents[1:]
151
210
    branch = new.branch
152
211
    last_revision = parents[0]
153
212
    if not short:
154
 
        print >>to_file, 'pending merges:'
155
 
    if last_revision is not None:
156
 
        try:
157
 
            ignore = set(branch.repository.get_ancestry(last_revision,
158
 
                                                        topo_sorted=False))
159
 
        except errors.NoSuchRevision:
160
 
            # the last revision is a ghost : assume everything is new 
161
 
            # except for it
162
 
            ignore = set([None, last_revision])
163
 
    else:
164
 
        ignore = set([None])
165
 
    # TODO: this could be improved using merge_sorted - we'd get the same 
166
 
    # output rather than one level of indent.
 
213
        if verbose:
 
214
            to_file.write('pending merges:\n')
 
215
        else:
 
216
            to_file.write('pending merge tips: (use -v to see all merge revisions)\n')
 
217
    graph = branch.repository.get_graph()
 
218
    other_revisions = [last_revision]
 
219
    log_formatter = log.LineLogFormatter(to_file)
167
220
    for merge in pending:
168
 
        ignore.add(merge)
169
 
        try:
170
 
            from bzrlib.osutils import terminal_width
171
 
            width = terminal_width()
172
 
            m_revision = branch.repository.get_revision(merge)
173
 
            if short:
174
 
                prefix = 'P  '
175
 
            else:
176
 
                prefix = ' '
177
 
            print >> to_file, prefix, line_log(m_revision, width - 4)
178
 
            inner_merges = branch.repository.get_ancestry(merge)
179
 
            assert inner_merges[0] is None
180
 
            inner_merges.pop(0)
181
 
            inner_merges.reverse()
182
 
            for mmerge in inner_merges:
183
 
                if mmerge in ignore:
184
 
                    continue
185
 
                mm_revision = branch.repository.get_revision(mmerge)
186
 
                if short:
187
 
                    prefix = 'P.  '
 
221
        try:
 
222
            rev = branch.repository.get_revisions([merge])[0]
 
223
        except errors.NoSuchRevision:
 
224
            # If we are missing a revision, just print out the revision id
 
225
            to_file.write(first_prefix + '(ghost) ' + merge + '\n')
 
226
            other_revisions.append(merge)
 
227
            continue
 
228
 
 
229
        # Log the merge, as it gets a slightly different formatting
 
230
        log_message = log_formatter.log_string(None, rev,
 
231
                        term_width - len(first_prefix))
 
232
        to_file.write(first_prefix + log_message + '\n')
 
233
        if not verbose:
 
234
            continue
 
235
 
 
236
        # Find all of the revisions in the merge source, which are not in the
 
237
        # last committed revision.
 
238
        merge_extra = graph.find_unique_ancestors(merge, other_revisions)
 
239
        other_revisions.append(merge)
 
240
        merge_extra.discard(_mod_revision.NULL_REVISION)
 
241
 
 
242
        # Get a handle to all of the revisions we will need
 
243
        try:
 
244
            revisions = dict((rev.revision_id, rev) for rev in
 
245
                             branch.repository.get_revisions(merge_extra))
 
246
        except errors.NoSuchRevision:
 
247
            # One of the sub nodes is a ghost, check each one
 
248
            revisions = {}
 
249
            for revision_id in merge_extra:
 
250
                try:
 
251
                    rev = branch.repository.get_revisions([revision_id])[0]
 
252
                except errors.NoSuchRevision:
 
253
                    revisions[revision_id] = None
188
254
                else:
189
 
                    prefix = '   '
190
 
                print >> to_file, prefix, line_log(mm_revision, width - 5)
191
 
                ignore.add(mmerge)
192
 
        except errors.NoSuchRevision:
193
 
            if short:
194
 
                prefix = 'P  '
195
 
            else:
196
 
                prefix = ' '
197
 
            print >> to_file, prefix, merge
 
255
                    revisions[revision_id] = rev
 
256
 
 
257
        # Display the revisions brought in by this merge.
 
258
        rev_id_iterator = _get_sorted_revisions(merge, merge_extra,
 
259
                            branch.repository.get_parent_map(merge_extra))
 
260
        # Skip the first node
 
261
        num, first, depth, eom = rev_id_iterator.next()
 
262
        if first != merge:
 
263
            raise AssertionError('Somehow we misunderstood how'
 
264
                ' iter_topo_order works %s != %s' % (first, merge))
 
265
        for num, sub_merge, depth, eom in rev_id_iterator:
 
266
            rev = revisions[sub_merge]
 
267
            if rev is None:
 
268
                to_file.write(sub_prefix + '(ghost) ' + sub_merge + '\n')
 
269
                continue
 
270
            log_message = log_formatter.log_string(None,
 
271
                            revisions[sub_merge],
 
272
                            term_width - len(sub_prefix))
 
273
            to_file.write(sub_prefix + log_message + '\n')
 
274
 
 
275
 
 
276
def _filter_nonexistent(orig_paths, old_tree, new_tree):
 
277
    """Convert orig_paths to two sorted lists and return them.
 
278
 
 
279
    The first is orig_paths paths minus the items in the second list,
 
280
    and the second list is paths that are not in either inventory or
 
281
    tree (they don't qualify if they exist in the tree's inventory, or
 
282
    if they exist in the tree but are not versioned.)
 
283
 
 
284
    If either of the two lists is empty, return it as an empty list.
 
285
 
 
286
    This can be used by operations such as bzr status that can accept
 
287
    unknown or ignored files.
 
288
    """
 
289
    mutter("check paths: %r", orig_paths)
 
290
    if not orig_paths:
 
291
        return orig_paths, []
 
292
    s = old_tree.filter_unversioned_files(orig_paths)
 
293
    s = new_tree.filter_unversioned_files(s)
 
294
    nonexistent = [path for path in s if not new_tree.has_filename(path)]
 
295
    remaining   = [path for path in orig_paths if not path in nonexistent]
 
296
    # Sorting the 'remaining' list doesn't have much effect in
 
297
    # practice, since the various status output sections will sort
 
298
    # their groups individually.  But for consistency of this
 
299
    # function's API, it's better to sort both than just 'nonexistent'.
 
300
    return sorted(remaining), sorted(nonexistent)