← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Aaron Bentley
  • Date: 2008-03-29 21:16:20 UTC
  • mto: (3298.2.13 revision_id_to_revno)
  • mto: This revision was merged to the branch mainline in revision 3328.
  • Revision ID: aaron@aaronbentley.com-20080329211620-1a91xrjinusqxudy
Update tests for null:, clea up slightly

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/info.py
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
4
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
# 
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
7
5
# the Free Software Foundation; either version 2 of the License, or
8
6
# (at your option) any later version.
9
 
 
 
7
#
10
8
# This program is distributed in the hope that it will be useful,
11
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
11
# GNU General Public License for more details.
14
 
 
 
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
 
from sets import Set
 
17
__all__ = ['show_bzrdir_info']
 
18
 
 
19
import os
20
20
import time
21
 
 
22
 
import bzrlib
23
 
from osutils import format_date
24
 
 
25
 
def show_info(b):
26
 
    print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
27
 
 
28
 
    def plural(n, base='', pl=None):
29
 
        if n == 1:
30
 
            return base
31
 
        elif pl != None:
32
 
            return pl
33
 
        else:
34
 
            return 's'
35
 
 
36
 
    count_version_dirs = 0
37
 
 
38
 
    count_status = {'A': 0, 'D': 0, 'M': 0, 'R': 0, '?': 0, 'I': 0, '.': 0}
39
 
    for st_tup in bzrlib.diff_trees(b.basis_tree(), b.working_tree()):
40
 
        fs = st_tup[0]
41
 
        count_status[fs] += 1
42
 
        if fs not in ['I', '?'] and st_tup[4] == 'directory':
43
 
            count_version_dirs += 1
44
 
 
45
 
    print
46
 
    print 'in the working tree:'
47
 
    for name, fs in (('unchanged', '.'),
48
 
                     ('modified', 'M'), ('added', 'A'), ('removed', 'D'),
49
 
                     ('renamed', 'R'), ('unknown', '?'), ('ignored', 'I'),
50
 
                     ):
51
 
        print '  %8d %s' % (count_status[fs], name)
52
 
    print '  %8d versioned subdirector%s' % (count_version_dirs,
53
 
                                             plural(count_version_dirs, 'y', 'ies'))
54
 
 
55
 
    print
56
 
    print 'branch history:'
57
 
    history = b.revision_history()
58
 
    revno = len(history)
59
 
    print '  %8d revision%s' % (revno, plural(revno))
60
 
    committers = Set()
61
 
    for rev in history:
62
 
        committers.add(b.get_revision(rev).committer)
63
 
    print '  %8d committer%s' % (len(committers), plural(len(committers)))
64
 
    if revno > 0:
65
 
        firstrev = b.get_revision(history[0])
66
 
        age = int((time.time() - firstrev.timestamp) / 3600 / 24)
67
 
        print '  %8d day%s old' % (age, plural(age))
68
 
        print '   first revision: %s' % format_date(firstrev.timestamp,
69
 
                                                    firstrev.timezone)
70
 
 
71
 
        lastrev = b.get_revision(history[-1])
72
 
        print '  latest revision: %s' % format_date(lastrev.timestamp,
73
 
                                                    lastrev.timezone)
74
 
 
75
 
    print
76
 
    print 'text store:'
77
 
    c, t = b.text_store.total_size()
78
 
    print '  %8d file texts' % c
79
 
    print '  %8d kB' % (t/1024)
80
 
 
81
 
    print
82
 
    print 'revision store:'
83
 
    c, t = b.revision_store.total_size()
84
 
    print '  %8d revisions' % c
85
 
    print '  %8d kB' % (t/1024)
86
 
 
87
 
 
88
 
    print
89
 
    print 'inventory store:'
90
 
    c, t = b.inventory_store.total_size()
91
 
    print '  %8d inventories' % c
92
 
    print '  %8d kB' % (t/1024)
93
 
 
 
21
import sys
 
22
 
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    diff,
 
26
    errors,
 
27
    osutils,
 
28
    urlutils,
 
29
    )
 
30
from bzrlib.errors import (NoWorkingTree, NotBranchError,
 
31
                           NoRepositoryPresent, NotLocalUrl)
 
32
from bzrlib.missing import find_unmerged
 
33
from bzrlib.symbol_versioning import (deprecated_function,
 
34
        zero_eighteen)
 
35
 
 
36
 
 
37
def plural(n, base='', pl=None):
 
38
    if n == 1:
 
39
        return base
 
40
    elif pl is not None:
 
41
        return pl
 
42
    else:
 
43
        return 's'
 
44
 
 
45
 
 
46
class LocationList(object):
 
47
 
 
48
    def __init__(self, base_path):
 
49
        self.locs = []
 
50
        self.base_path = base_path
 
51
 
 
52
    def add_url(self, label, url):
 
53
        """Add a URL to the list, converting it to a path if possible"""
 
54
        if url is None:
 
55
            return
 
56
        try:
 
57
            path = urlutils.local_path_from_url(url)
 
58
        except errors.InvalidURL:
 
59
            self.locs.append((label, url))
 
60
        else:
 
61
            self.add_path(label, path)
 
62
 
 
63
    def add_path(self, label, path):
 
64
        """Add a path, converting it to a relative path if possible"""
 
65
        try:
 
66
            path = osutils.relpath(self.base_path, path)
 
67
        except errors.PathNotChild:
 
68
            pass
 
69
        else:
 
70
            if path == '':
 
71
                path = '.'
 
72
        if path != '/':
 
73
            path = path.rstrip('/')
 
74
        self.locs.append((label, path))
 
75
 
 
76
    def get_lines(self):
 
77
        max_len = max(len(l) for l, u in self.locs)
 
78
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
 
79
 
 
80
 
 
81
def gather_location_info(repository, branch=None, working=None):
 
82
    locs = {}
 
83
    repository_path = repository.bzrdir.root_transport.base
 
84
    if branch is not None:
 
85
        branch_path = branch.bzrdir.root_transport.base
 
86
        master_path = branch.get_bound_location()
 
87
        if master_path is None:
 
88
            master_path = branch_path
 
89
    else:
 
90
        branch_path = None
 
91
        master_path = None
 
92
    if working:
 
93
        working_path = working.bzrdir.root_transport.base
 
94
        if working_path != branch_path:
 
95
            locs['light checkout root'] = working_path
 
96
        if master_path != branch_path:
 
97
            if repository.is_shared():
 
98
                locs['repository checkout root'] = branch_path
 
99
            else:
 
100
                locs['checkout root'] = branch_path
 
101
        if working_path != master_path:
 
102
            locs['checkout of branch'] = master_path
 
103
        elif repository.is_shared():
 
104
            locs['repository branch'] = branch_path
 
105
        elif branch_path is not None:
 
106
            # standalone
 
107
            locs['branch root'] = branch_path
 
108
    else:
 
109
        working_path = None
 
110
        if repository.is_shared():
 
111
            # lightweight checkout of branch in shared repository
 
112
            if branch_path is not None:
 
113
                locs['repository branch'] = branch_path
 
114
        elif branch_path is not None:
 
115
            # standalone
 
116
            locs['branch root'] = branch_path
 
117
            if master_path != branch_path:
 
118
                locs['bound to branch'] = master_path
 
119
        else:
 
120
            locs['repository'] = repository_path
 
121
    if repository.is_shared():
 
122
        # lightweight checkout of branch in shared repository
 
123
        locs['shared repository'] = repository_path
 
124
    order = ['light checkout root', 'repository checkout root',
 
125
             'checkout root', 'checkout of branch', 'shared repository',
 
126
             'repository', 'repository branch', 'branch root',
 
127
             'bound to branch']
 
128
    return [(n, locs[n]) for n in order if n in locs]
 
129
 
 
130
 
 
131
def _show_location_info(locs, outfile):
 
132
    """Show known locations for working, branch and repository."""
 
133
    outfile.write('Location:\n')
 
134
    path_list = LocationList(osutils.getcwd())
 
135
    for name, loc in locs:
 
136
        path_list.add_url(name, loc)
 
137
    outfile.writelines(path_list.get_lines())
 
138
 
 
139
 
 
140
def _gather_related_branches(branch):
 
141
    locs = LocationList(osutils.getcwd())
 
142
    locs.add_url('public branch', branch.get_public_branch())
 
143
    locs.add_url('push branch', branch.get_push_location())
 
144
    locs.add_url('parent branch', branch.get_parent())
 
145
    locs.add_url('submit branch', branch.get_submit_branch())
 
146
    return locs
 
147
 
 
148
 
 
149
def _show_related_info(branch, outfile):
 
150
    """Show parent and push location of branch."""
 
151
    locs = _gather_related_branches(branch)
 
152
    if len(locs.locs) > 0:
 
153
        outfile.write('\n')
 
154
        outfile.write('Related branches:\n')
 
155
        outfile.writelines(locs.get_lines())
 
156
 
 
157
 
 
158
def _show_format_info(control=None, repository=None, branch=None,
 
159
                      working=None, outfile=None):
 
160
    """Show known formats for control, working, branch and repository."""
 
161
    outfile.write('\n')
 
162
    outfile.write('Format:\n')
 
163
    if control:
 
164
        outfile.write('       control: %s\n' %
 
165
            control._format.get_format_description())
 
166
    if working:
 
167
        outfile.write('  working tree: %s\n' %
 
168
            working._format.get_format_description())
 
169
    if branch:
 
170
        outfile.write('        branch: %s\n' %
 
171
            branch._format.get_format_description())
 
172
    if repository:
 
173
        outfile.write('    repository: %s\n' %
 
174
            repository._format.get_format_description())
 
175
 
 
176
 
 
177
def _show_locking_info(repository, branch=None, working=None, outfile=None):
 
178
    """Show locking status of working, branch and repository."""
 
179
    if (repository.get_physical_lock_status() or
 
180
        (branch and branch.get_physical_lock_status()) or
 
181
        (working and working.get_physical_lock_status())):
 
182
        outfile.write('\n')
 
183
        outfile.write('Lock status:\n')
 
184
        if working:
 
185
            if working.get_physical_lock_status():
 
186
                status = 'locked'
 
187
            else:
 
188
                status = 'unlocked'
 
189
            outfile.write('  working tree: %s\n' % status)
 
190
        if branch:
 
191
            if branch.get_physical_lock_status():
 
192
                status = 'locked'
 
193
            else:
 
194
                status = 'unlocked'
 
195
            outfile.write('        branch: %s\n' % status)
 
196
        if repository:
 
197
            if repository.get_physical_lock_status():
 
198
                status = 'locked'
 
199
            else:
 
200
                status = 'unlocked'
 
201
            outfile.write('    repository: %s\n' % status)
 
202
 
 
203
 
 
204
def _show_missing_revisions_branch(branch, outfile):
 
205
    """Show missing master revisions in branch."""
 
206
    # Try with inaccessible branch ?
 
207
    master = branch.get_master_branch()
 
208
    if master:
 
209
        local_extra, remote_extra = find_unmerged(branch, master)
 
210
        if remote_extra:
 
211
            outfile.write('\n')
 
212
            outfile.write(('Branch is out of date: missing %d '
 
213
                'revision%s.\n') % (len(remote_extra),
 
214
                plural(len(remote_extra))))
 
215
 
 
216
 
 
217
def _show_missing_revisions_working(working, outfile):
 
218
    """Show missing revisions in working tree."""
 
219
    branch = working.branch
 
220
    basis = working.basis_tree()
 
221
    work_inv = working.inventory
 
222
    branch_revno, branch_last_revision = branch.last_revision_info()
 
223
    try:
 
224
        tree_last_id = working.get_parent_ids()[0]
 
225
    except IndexError:
 
226
        tree_last_id = None
 
227
 
 
228
    if branch_revno and tree_last_id != branch_last_revision:
 
229
        tree_last_revno = branch.revision_id_to_revno(tree_last_id)
 
230
        missing_count = branch_revno - tree_last_revno
 
231
        outfile.write('\n')
 
232
        outfile.write(('Working tree is out of date: missing %d '
 
233
            'revision%s.\n') % (missing_count, plural(missing_count)))
 
234
 
 
235
 
 
236
def _show_working_stats(working, outfile):
 
237
    """Show statistics about a working tree."""
 
238
    basis = working.basis_tree()
 
239
    work_inv = working.inventory
 
240
    delta = working.changes_from(basis, want_unchanged=True)
 
241
 
 
242
    outfile.write('\n')
 
243
    outfile.write('In the working tree:\n')
 
244
    outfile.write('  %8s unchanged\n' % len(delta.unchanged))
 
245
    outfile.write('  %8d modified\n' % len(delta.modified))
 
246
    outfile.write('  %8d added\n' % len(delta.added))
 
247
    outfile.write('  %8d removed\n' % len(delta.removed))
 
248
    outfile.write('  %8d renamed\n' % len(delta.renamed))
 
249
 
 
250
    ignore_cnt = unknown_cnt = 0
 
251
    for path in working.extras():
 
252
        if working.is_ignored(path):
 
253
            ignore_cnt += 1
 
254
        else:
 
255
            unknown_cnt += 1
 
256
    outfile.write('  %8d unknown\n' % unknown_cnt)
 
257
    outfile.write('  %8d ignored\n' % ignore_cnt)
 
258
 
 
259
    dir_cnt = 0
 
260
    for file_id in work_inv:
 
261
        if (work_inv.get_file_kind(file_id) == 'directory' and 
 
262
            not work_inv.is_root(file_id)):
 
263
            dir_cnt += 1
 
264
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
 
265
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
 
266
 
 
267
 
 
268
def _show_branch_stats(branch, verbose, outfile):
 
269
    """Show statistics about a branch."""
 
270
    revno, head = branch.last_revision_info()
 
271
    outfile.write('\n')
 
272
    outfile.write('Branch history:\n')
 
273
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
 
274
    stats = branch.repository.gather_stats(head, committers=verbose)
 
275
    if verbose:
 
276
        committers = stats['committers']
 
277
        outfile.write('  %8d committer%s\n' % (committers,
 
278
            plural(committers)))
 
279
    if revno:
 
280
        timestamp, timezone = stats['firstrev']
 
281
        age = int((time.time() - timestamp) / 3600 / 24)
 
282
        outfile.write('  %8d day%s old\n' % (age, plural(age)))
 
283
        outfile.write('   first revision: %s\n' %
 
284
            osutils.format_date(timestamp, timezone))
 
285
        timestamp, timezone = stats['latestrev']
 
286
        outfile.write('  latest revision: %s\n' %
 
287
            osutils.format_date(timestamp, timezone))
 
288
    return stats
 
289
 
 
290
 
 
291
def _show_repository_info(repository, outfile):
 
292
    """Show settings of a repository."""
 
293
    if repository.make_working_trees():
 
294
        outfile.write('\n')
 
295
        outfile.write('Create working tree for new branches inside '
 
296
            'the repository.\n')
 
297
 
 
298
 
 
299
def _show_repository_stats(stats, outfile):
 
300
    """Show statistics about a repository."""
 
301
    if 'revisions' in stats or 'size' in stats:
 
302
        outfile.write('\n')
 
303
        outfile.write('Repository:\n')
 
304
    if 'revisions' in stats:
 
305
        revisions = stats['revisions']
 
306
        outfile.write('  %8d revision%s\n' % (revisions, plural(revisions)))
 
307
    if 'size' in stats:
 
308
        outfile.write('  %8d KiB\n' % (stats['size']/1024))
 
309
 
 
310
 
 
311
def show_bzrdir_info(a_bzrdir, verbose=False, outfile=None):
 
312
    """Output to stdout the 'info' for a_bzrdir."""
 
313
    if outfile is None:
 
314
        outfile = sys.stdout
 
315
    try:
 
316
        tree = a_bzrdir.open_workingtree(
 
317
            recommend_upgrade=False)
 
318
    except (NoWorkingTree, NotLocalUrl):
 
319
        tree = None
 
320
        try:
 
321
            branch = a_bzrdir.open_branch()
 
322
        except NotBranchError:
 
323
            branch = None
 
324
            try:
 
325
                repository = a_bzrdir.open_repository()
 
326
            except NoRepositoryPresent:
 
327
                # Return silently; cmd_info already returned NotBranchError
 
328
                # if no bzrdir could be opened.
 
329
                return
 
330
            else:
 
331
                lockable = repository
 
332
        else:
 
333
            repository = branch.repository
 
334
            lockable = branch
 
335
    else:
 
336
        branch = tree.branch
 
337
        repository = branch.repository
 
338
        lockable = tree
 
339
 
 
340
    lockable.lock_read()
 
341
    try:
 
342
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
 
343
                            outfile)
 
344
    finally:
 
345
        lockable.unlock()
 
346
 
 
347
 
 
348
def show_component_info(control, repository, branch=None, working=None,
 
349
    verbose=1, outfile=None):
 
350
    """Write info about all bzrdir components to stdout"""
 
351
    if outfile is None:
 
352
        outfile = sys.stdout
 
353
    if verbose is False:
 
354
        verbose = 1
 
355
    if verbose is True:
 
356
        verbose = 2
 
357
    layout = describe_layout(repository, branch, working)
 
358
    format = describe_format(control, repository, branch, working)
 
359
    outfile.write("%s (format: %s)\n" % (layout, format))
 
360
    _show_location_info(gather_location_info(repository, branch, working),
 
361
                        outfile)
 
362
    if branch is not None:
 
363
        _show_related_info(branch, outfile)
 
364
    if verbose == 0:
 
365
        return
 
366
    _show_format_info(control, repository, branch, working, outfile)
 
367
    _show_locking_info(repository, branch, working, outfile)
 
368
    if branch is not None:
 
369
        _show_missing_revisions_branch(branch, outfile)
 
370
    if working is not None:
 
371
        _show_missing_revisions_working(working, outfile)
 
372
        _show_working_stats(working, outfile)
 
373
    elif branch is not None:
 
374
        _show_missing_revisions_branch(branch, outfile)
 
375
    if branch is not None:
 
376
        stats = _show_branch_stats(branch, verbose==2, outfile)
 
377
    else:
 
378
        stats = repository.gather_stats()
 
379
    if branch is None and working is None:
 
380
        _show_repository_info(repository, outfile)
 
381
    _show_repository_stats(stats, outfile)
 
382
 
 
383
 
 
384
def describe_layout(repository=None, branch=None, tree=None):
 
385
    """Convert a control directory layout into a user-understandable term
 
386
 
 
387
    Common outputs include "Standalone tree", "Repository branch" and
 
388
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
 
389
    and "Empty control directory"
 
390
    """
 
391
    if repository is None:
 
392
        return 'Empty control directory'
 
393
    if branch is None and tree is None:
 
394
        if repository.is_shared():
 
395
            phrase = 'Shared repository'
 
396
        else:
 
397
            phrase = 'Unshared repository'
 
398
        if repository.make_working_trees():
 
399
            phrase += ' with trees'
 
400
        return phrase
 
401
    else:
 
402
        if repository.is_shared():
 
403
            independence = "Repository "
 
404
        else:
 
405
            independence = "Standalone "
 
406
        if tree is not None:
 
407
            phrase = "tree"
 
408
        else:
 
409
            phrase = "branch"
 
410
        if branch is None and tree is not None:
 
411
            phrase = "branchless tree"
 
412
        else:
 
413
            if (tree is not None and tree.bzrdir.root_transport.base !=
 
414
                branch.bzrdir.root_transport.base):
 
415
                independence = ''
 
416
                phrase = "Lightweight checkout"
 
417
            elif branch.get_bound_location() is not None:
 
418
                if independence == 'Standalone ':
 
419
                    independence = ''
 
420
                if tree is None:
 
421
                    phrase = "Bound branch"
 
422
                else:
 
423
                    phrase = "Checkout"
 
424
        if independence != "":
 
425
            phrase = phrase.lower()
 
426
        return "%s%s" % (independence, phrase)
 
427
 
 
428
 
 
429
def describe_format(control, repository, branch, tree):
 
430
    """Determine the format of an existing control directory
 
431
 
 
432
    Several candidates may be found.  If so, the names are returned as a
 
433
    single string, separated by ' or '.
 
434
 
 
435
    If no matching candidate is found, "unnamed" is returned.
 
436
    """
 
437
    candidates  = []
 
438
    if (branch is not None and tree is not None and
 
439
        branch.bzrdir.root_transport.base !=
 
440
        tree.bzrdir.root_transport.base):
 
441
        branch = None
 
442
        repository = None
 
443
    non_aliases = set(bzrdir.format_registry.keys())
 
444
    non_aliases.difference_update(bzrdir.format_registry.aliases())
 
445
    for key in non_aliases:
 
446
        format = bzrdir.format_registry.make_bzrdir(key)
 
447
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
 
448
            if (tree and format.workingtree_format !=
 
449
                tree._format):
 
450
                continue
 
451
            if (branch and format.get_branch_format() !=
 
452
                branch._format):
 
453
                continue
 
454
            if (repository and format.repository_format !=
 
455
                repository._format):
 
456
                continue
 
457
        if format.__class__ is not control._format.__class__:
 
458
            continue
 
459
        candidates.append(key)
 
460
    if len(candidates) == 0:
 
461
        return 'unnamed'
 
462
    candidates.sort()
 
463
    new_candidates = [c for c in candidates if not
 
464
        bzrdir.format_registry.get_info(c).hidden]
 
465
    if len(new_candidates) > 0:
 
466
        # If there are any non-hidden formats that match, only return those to
 
467
        # avoid listing hidden formats except when only a hidden format will
 
468
        # do.
 
469
        candidates = new_candidates
 
470
    return ' or '.join(candidates)