← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-10 17:52:08 UTC
  • mfrom: (5021 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5023.
  • Revision ID: john@arbash-meinel.com-20100210175208-bubuwav4uqigu291
Merge bzr.dev 5021 to resolve NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/info.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
__all__ = ['show_bzrdir_info']
18
18
 
19
19
from cStringIO import StringIO
 
20
import os
20
21
import time
21
22
import sys
22
23
 
23
24
from bzrlib import (
24
25
    bzrdir,
25
 
    controldir,
 
26
    diff,
26
27
    errors,
27
28
    hooks as _mod_hooks,
28
29
    osutils,
77
78
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
78
79
 
79
80
 
80
 
def gather_location_info(repository=None, branch=None, working=None,
81
 
        control=None):
 
81
def gather_location_info(repository, branch=None, working=None):
82
82
    locs = {}
 
83
    repository_path = repository.bzrdir.root_transport.base
83
84
    if branch is not None:
84
 
        branch_path = branch.user_url
 
85
        branch_path = branch.bzrdir.root_transport.base
85
86
        master_path = branch.get_bound_location()
86
87
        if master_path is None:
87
88
            master_path = branch_path
88
89
    else:
89
90
        branch_path = None
90
91
        master_path = None
91
 
        try:
92
 
            if control is not None and control.get_branch_reference():
93
 
                locs['checkout of branch'] = control.get_branch_reference()
94
 
        except NotBranchError:
95
 
            pass
96
92
    if working:
97
 
        working_path = working.user_url
 
93
        working_path = working.bzrdir.root_transport.base
98
94
        if working_path != branch_path:
99
95
            locs['light checkout root'] = working_path
100
96
        if master_path != branch_path:
111
107
            locs['branch root'] = branch_path
112
108
    else:
113
109
        working_path = None
114
 
        if repository is not None and repository.is_shared():
 
110
        if repository.is_shared():
115
111
            # lightweight checkout of branch in shared repository
116
112
            if branch_path is not None:
117
113
                locs['repository branch'] = branch_path
118
114
        elif branch_path is not None:
119
115
            # standalone
120
116
            locs['branch root'] = branch_path
121
 
        elif repository is not None:
122
 
            locs['repository'] = repository.user_url
123
 
        elif control is not None:
124
 
            locs['control directory'] = control.user_url
 
117
            if master_path != branch_path:
 
118
                locs['bound to branch'] = master_path
125
119
        else:
126
 
            # Really, at least a control directory should be
127
 
            # passed in for this method to be useful.
128
 
            pass
129
 
        if master_path != branch_path:
130
 
            locs['bound to branch'] = master_path
131
 
    if repository is not None and repository.is_shared():
 
120
            locs['repository'] = repository_path
 
121
    if repository.is_shared():
132
122
        # lightweight checkout of branch in shared repository
133
 
        locs['shared repository'] = repository.user_url
134
 
    order = ['control directory', 'light checkout root',
135
 
             'repository checkout root', 'checkout root',
136
 
             'checkout of branch', 'shared repository',
 
123
        locs['shared repository'] = repository_path
 
124
    order = ['light checkout root', 'repository checkout root',
 
125
             'checkout root', 'checkout of branch', 'shared repository',
137
126
             'repository', 'repository branch', 'branch root',
138
127
             'bound to branch']
139
128
    return [(n, locs[n]) for n in order if n in locs]
171
160
        outfile.writelines(locs.get_lines())
172
161
 
173
162
 
174
 
def _show_control_dir_info(control, outfile):
175
 
    """Show control dir information."""
176
 
    if control._format.colocated_branches:
177
 
        outfile.write('\n')
178
 
        outfile.write('Control directory:\n')
179
 
        outfile.write('         %d branches\n' % len(control.list_branches()))
180
 
 
181
 
 
182
163
def _show_format_info(control=None, repository=None, branch=None,
183
164
                      working=None, outfile=None):
184
165
    """Show known formats for control, working, branch and repository."""
242
223
    """Show missing revisions in working tree."""
243
224
    branch = working.branch
244
225
    basis = working.basis_tree()
245
 
    try:
246
 
        branch_revno, branch_last_revision = branch.last_revision_info()
247
 
    except errors.UnsupportedOperation:
248
 
        return
 
226
    work_inv = working.inventory
 
227
    branch_revno, branch_last_revision = branch.last_revision_info()
249
228
    try:
250
229
        tree_last_id = working.get_parent_ids()[0]
251
230
    except IndexError:
262
241
def _show_working_stats(working, outfile):
263
242
    """Show statistics about a working tree."""
264
243
    basis = working.basis_tree()
 
244
    work_inv = working.inventory
265
245
    delta = working.changes_from(basis, want_unchanged=True)
266
246
 
267
247
    outfile.write('\n')
282
262
    outfile.write('  %8d ignored\n' % ignore_cnt)
283
263
 
284
264
    dir_cnt = 0
285
 
    root_id = working.get_root_id()
286
 
    for path, entry in working.iter_entries_by_dir():
287
 
        if entry.kind == 'directory' and entry.file_id != root_id:
 
265
    for file_id in work_inv:
 
266
        if (work_inv.get_file_kind(file_id) == 'directory' and
 
267
            not work_inv.is_root(file_id)):
288
268
            dir_cnt += 1
289
269
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
290
270
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
292
272
 
293
273
def _show_branch_stats(branch, verbose, outfile):
294
274
    """Show statistics about a branch."""
295
 
    try:
296
 
        revno, head = branch.last_revision_info()
297
 
    except errors.UnsupportedOperation:
298
 
        return {}
 
275
    revno, head = branch.last_revision_info()
299
276
    outfile.write('\n')
300
277
    outfile.write('Branch history:\n')
301
278
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
347
324
    try:
348
325
        tree = a_bzrdir.open_workingtree(
349
326
            recommend_upgrade=False)
350
 
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
327
    except (NoWorkingTree, NotLocalUrl):
351
328
        tree = None
352
329
        try:
353
330
            branch = a_bzrdir.open_branch()
356
333
            try:
357
334
                repository = a_bzrdir.open_repository()
358
335
            except NoRepositoryPresent:
359
 
                lockable = None
360
 
                repository = None
 
336
                # Return silently; cmd_info already returned NotBranchError
 
337
                # if no bzrdir could be opened.
 
338
                return
361
339
            else:
362
340
                lockable = repository
363
341
        else:
368
346
        repository = branch.repository
369
347
        lockable = tree
370
348
 
371
 
    if lockable is not None:
372
 
        lockable.lock_read()
 
349
    lockable.lock_read()
373
350
    try:
374
351
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
375
352
                            outfile)
376
353
    finally:
377
 
        if lockable is not None:
378
 
            lockable.unlock()
 
354
        lockable.unlock()
379
355
 
380
356
 
381
357
def show_component_info(control, repository, branch=None, working=None,
387
363
        verbose = 1
388
364
    if verbose is True:
389
365
        verbose = 2
390
 
    layout = describe_layout(repository, branch, working, control)
 
366
    layout = describe_layout(repository, branch, working)
391
367
    format = describe_format(control, repository, branch, working)
392
368
    outfile.write("%s (format: %s)\n" % (layout, format))
393
 
    _show_location_info(
394
 
        gather_location_info(control=control, repository=repository,
395
 
            branch=branch, working=working),
396
 
        outfile)
 
369
    _show_location_info(gather_location_info(repository, branch, working),
 
370
                        outfile)
397
371
    if branch is not None:
398
372
        _show_related_info(branch, outfile)
399
373
    if verbose == 0:
400
374
        return
401
375
    _show_format_info(control, repository, branch, working, outfile)
402
376
    _show_locking_info(repository, branch, working, outfile)
403
 
    _show_control_dir_info(control, outfile)
404
377
    if branch is not None:
405
378
        _show_missing_revisions_branch(branch, outfile)
406
379
    if working is not None:
418
391
    _show_repository_stats(repository, stats, outfile)
419
392
 
420
393
 
421
 
def describe_layout(repository=None, branch=None, tree=None, control=None):
 
394
def describe_layout(repository=None, branch=None, tree=None):
422
395
    """Convert a control directory layout into a user-understandable term
423
396
 
424
397
    Common outputs include "Standalone tree", "Repository branch" and
425
398
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
426
399
    and "Empty control directory"
427
400
    """
428
 
    if branch is None and control is not None:
429
 
        try:
430
 
            branch_reference = control.get_branch_reference()
431
 
        except NotBranchError:
432
 
            pass
433
 
        else:
434
 
            if branch_reference is not None:
435
 
                return "Dangling branch reference"
436
401
    if repository is None:
437
402
        return 'Empty control directory'
438
403
    if branch is None and tree is None:
455
420
        if branch is None and tree is not None:
456
421
            phrase = "branchless tree"
457
422
        else:
458
 
            if (tree is not None and tree.user_url !=
459
 
                branch.user_url):
 
423
            if (tree is not None and tree.bzrdir.root_transport.base !=
 
424
                branch.bzrdir.root_transport.base):
460
425
                independence = ''
461
426
                phrase = "Lightweight checkout"
462
427
            elif branch.get_bound_location() is not None:
481
446
    """
482
447
    candidates  = []
483
448
    if (branch is not None and tree is not None and
484
 
        branch.user_url != tree.user_url):
 
449
        branch.bzrdir.root_transport.base !=
 
450
        tree.bzrdir.root_transport.base):
485
451
        branch = None
486
452
        repository = None
487
 
    non_aliases = set(controldir.format_registry.keys())
488
 
    non_aliases.difference_update(controldir.format_registry.aliases())
 
453
    non_aliases = set(bzrdir.format_registry.keys())
 
454
    non_aliases.difference_update(bzrdir.format_registry.aliases())
489
455
    for key in non_aliases:
490
 
        format = controldir.format_registry.make_bzrdir(key)
 
456
        format = bzrdir.format_registry.make_bzrdir(key)
491
457
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
492
458
            if (tree and format.workingtree_format !=
493
459
                tree._format):
505
471
        return 'unnamed'
506
472
    candidates.sort()
507
473
    new_candidates = [c for c in candidates if not
508
 
        controldir.format_registry.get_info(c).hidden]
 
474
        bzrdir.format_registry.get_info(c).hidden]
509
475
    if len(new_candidates) > 0:
510
476
        # If there are any non-hidden formats that match, only return those to
511
477
        # avoid listing hidden formats except when only a hidden format will
518
484
    """Hooks for the info command."""
519
485
 
520
486
    def __init__(self):
521
 
        super(InfoHooks, self).__init__("bzrlib.info", "hooks")
522
 
        self.add_hook('repository',
 
487
        super(InfoHooks, self).__init__()
 
488
        self.create_hook(_mod_hooks.HookPoint('repository',
523
489
            "Invoked when displaying the statistics for a repository. "
524
490
            "repository is called with a statistics dictionary as returned "
525
 
            "by the repository and a file-like object to write to.", (1, 15))
 
491
            "by the repository and a file-like object to write to.", (1, 15), 
 
492
            None))
526
493
 
527
494
 
528
495
hooks = InfoHooks()