← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Jonathan Riddell
  • Date: 2011-05-16 11:27:37 UTC
  • mto: This revision was merged to the branch mainline in revision 5869.
  • Revision ID: jriddell@canonical.com-20110516112737-gep642p24rtzp3jt
user guide licence

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/info.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
19
17
__all__ = ['show_bzrdir_info']
20
18
 
21
19
from cStringIO import StringIO
24
22
 
25
23
from bzrlib import (
26
24
    bzrdir,
27
 
    controldir,
28
25
    errors,
29
26
    hooks as _mod_hooks,
30
27
    osutils,
79
76
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
80
77
 
81
78
 
82
 
def gather_location_info(repository=None, branch=None, working=None,
83
 
        control=None):
 
79
def gather_location_info(repository, branch=None, working=None):
84
80
    locs = {}
 
81
    repository_path = repository.user_url
85
82
    if branch is not None:
86
83
        branch_path = branch.user_url
87
84
        master_path = branch.get_bound_location()
90
87
    else:
91
88
        branch_path = None
92
89
        master_path = None
93
 
        try:
94
 
            if control is not None and control.get_branch_reference():
95
 
                locs['checkout of branch'] = control.get_branch_reference()
96
 
        except NotBranchError:
97
 
            pass
98
90
    if working:
99
91
        working_path = working.user_url
100
92
        if working_path != branch_path:
113
105
            locs['branch root'] = branch_path
114
106
    else:
115
107
        working_path = None
116
 
        if repository is not None and repository.is_shared():
 
108
        if repository.is_shared():
117
109
            # lightweight checkout of branch in shared repository
118
110
            if branch_path is not None:
119
111
                locs['repository branch'] = branch_path
120
112
        elif branch_path is not None:
121
113
            # standalone
122
114
            locs['branch root'] = branch_path
123
 
        elif repository is not None:
124
 
            locs['repository'] = repository.user_url
125
 
        elif control is not None:
126
 
            locs['control directory'] = control.user_url
 
115
            if master_path != branch_path:
 
116
                locs['bound to branch'] = master_path
127
117
        else:
128
 
            # Really, at least a control directory should be
129
 
            # passed in for this method to be useful.
130
 
            pass
131
 
        if master_path != branch_path:
132
 
            locs['bound to branch'] = master_path
133
 
    if repository is not None and repository.is_shared():
 
118
            locs['repository'] = repository_path
 
119
    if repository.is_shared():
134
120
        # lightweight checkout of branch in shared repository
135
 
        locs['shared repository'] = repository.user_url
136
 
    order = ['control directory', 'light checkout root',
137
 
             'repository checkout root', 'checkout root',
138
 
             'checkout of branch', 'shared repository',
 
121
        locs['shared repository'] = repository_path
 
122
    order = ['light checkout root', 'repository checkout root',
 
123
             'checkout root', 'checkout of branch', 'shared repository',
139
124
             'repository', 'repository branch', 'branch root',
140
125
             'bound to branch']
141
126
    return [(n, locs[n]) for n in order if n in locs]
173
158
        outfile.writelines(locs.get_lines())
174
159
 
175
160
 
176
 
def _show_control_dir_info(control, outfile):
177
 
    """Show control dir information."""
178
 
    if control._format.colocated_branches:
179
 
        outfile.write('\n')
180
 
        outfile.write('Control directory:\n')
181
 
        outfile.write('         %d branches\n' % len(control.list_branches()))
182
 
 
183
 
 
184
161
def _show_format_info(control=None, repository=None, branch=None,
185
162
                      working=None, outfile=None):
186
163
    """Show known formats for control, working, branch and repository."""
200
177
            repository._format.get_format_description())
201
178
 
202
179
 
203
 
def _show_locking_info(repository=None, branch=None, working=None,
204
 
        outfile=None):
 
180
def _show_locking_info(repository, branch=None, working=None, outfile=None):
205
181
    """Show locking status of working, branch and repository."""
206
 
    if (repository and repository.get_physical_lock_status() or
 
182
    if (repository.get_physical_lock_status() or
207
183
        (branch and branch.get_physical_lock_status()) or
208
184
        (working and working.get_physical_lock_status())):
209
185
        outfile.write('\n')
245
221
    """Show missing revisions in working tree."""
246
222
    branch = working.branch
247
223
    basis = working.basis_tree()
248
 
    try:
249
 
        branch_revno, branch_last_revision = branch.last_revision_info()
250
 
    except errors.UnsupportedOperation:
251
 
        return
 
224
    branch_revno, branch_last_revision = branch.last_revision_info()
252
225
    try:
253
226
        tree_last_id = working.get_parent_ids()[0]
254
227
    except IndexError:
295
268
 
296
269
def _show_branch_stats(branch, verbose, outfile):
297
270
    """Show statistics about a branch."""
298
 
    try:
299
 
        revno, head = branch.last_revision_info()
300
 
    except errors.UnsupportedOperation:
301
 
        return {}
 
271
    revno, head = branch.last_revision_info()
302
272
    outfile.write('\n')
303
273
    outfile.write('Branch history:\n')
304
274
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
350
320
    try:
351
321
        tree = a_bzrdir.open_workingtree(
352
322
            recommend_upgrade=False)
353
 
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
323
    except (NoWorkingTree, NotLocalUrl):
354
324
        tree = None
355
325
        try:
356
 
            branch = a_bzrdir.open_branch(name="")
 
326
            branch = a_bzrdir.open_branch()
357
327
        except NotBranchError:
358
328
            branch = None
359
329
            try:
360
330
                repository = a_bzrdir.open_repository()
361
331
            except NoRepositoryPresent:
362
 
                lockable = None
363
 
                repository = None
 
332
                # Return silently; cmd_info already returned NotBranchError
 
333
                # if no bzrdir could be opened.
 
334
                return
364
335
            else:
365
336
                lockable = repository
366
337
        else:
371
342
        repository = branch.repository
372
343
        lockable = tree
373
344
 
374
 
    if lockable is not None:
375
 
        lockable.lock_read()
 
345
    lockable.lock_read()
376
346
    try:
377
347
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
378
348
                            outfile)
379
349
    finally:
380
 
        if lockable is not None:
381
 
            lockable.unlock()
 
350
        lockable.unlock()
382
351
 
383
352
 
384
353
def show_component_info(control, repository, branch=None, working=None,
390
359
        verbose = 1
391
360
    if verbose is True:
392
361
        verbose = 2
393
 
    layout = describe_layout(repository, branch, working, control)
 
362
    layout = describe_layout(repository, branch, working)
394
363
    format = describe_format(control, repository, branch, working)
395
364
    outfile.write("%s (format: %s)\n" % (layout, format))
396
 
    _show_location_info(
397
 
        gather_location_info(control=control, repository=repository,
398
 
            branch=branch, working=working),
399
 
        outfile)
 
365
    _show_location_info(gather_location_info(repository, branch, working),
 
366
                        outfile)
400
367
    if branch is not None:
401
368
        _show_related_info(branch, outfile)
402
369
    if verbose == 0:
403
370
        return
404
371
    _show_format_info(control, repository, branch, working, outfile)
405
372
    _show_locking_info(repository, branch, working, outfile)
406
 
    _show_control_dir_info(control, outfile)
407
373
    if branch is not None:
408
374
        _show_missing_revisions_branch(branch, outfile)
409
375
    if working is not None:
414
380
    if branch is not None:
415
381
        show_committers = verbose >= 2
416
382
        stats = _show_branch_stats(branch, show_committers, outfile)
417
 
    elif repository is not None:
 
383
    else:
418
384
        stats = repository.gather_stats()
419
 
    if branch is None and working is None and repository is not None:
 
385
    if branch is None and working is None:
420
386
        _show_repository_info(repository, outfile)
421
 
    if repository is not None:
422
 
        _show_repository_stats(repository, stats, outfile)
423
 
 
424
 
 
425
 
def describe_layout(repository=None, branch=None, tree=None, control=None):
 
387
    _show_repository_stats(repository, stats, outfile)
 
388
 
 
389
 
 
390
def describe_layout(repository=None, branch=None, tree=None):
426
391
    """Convert a control directory layout into a user-understandable term
427
392
 
428
393
    Common outputs include "Standalone tree", "Repository branch" and
429
394
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
430
395
    and "Empty control directory"
431
396
    """
432
 
    if branch is None and control is not None:
433
 
        try:
434
 
            branch_reference = control.get_branch_reference()
435
 
        except NotBranchError:
436
 
            pass
437
 
        else:
438
 
            if branch_reference is not None:
439
 
                return "Dangling branch reference"
440
397
    if repository is None:
441
398
        return 'Empty control directory'
442
399
    if branch is None and tree is None:
444
401
            phrase = 'Shared repository'
445
402
        else:
446
403
            phrase = 'Unshared repository'
447
 
        extra = []
448
404
        if repository.make_working_trees():
449
 
            extra.append('trees')
450
 
        if len(control.get_branches()) > 0:
451
 
            extra.append('colocated branches')
452
 
        if extra:
453
 
            phrase += ' with ' + " and ".join(extra)
 
405
            phrase += ' with trees'
454
406
        return phrase
455
407
    else:
456
408
        if repository.is_shared():
493
445
        branch.user_url != tree.user_url):
494
446
        branch = None
495
447
        repository = None
496
 
    non_aliases = set(controldir.format_registry.keys())
497
 
    non_aliases.difference_update(controldir.format_registry.aliases())
 
448
    non_aliases = set(bzrdir.format_registry.keys())
 
449
    non_aliases.difference_update(bzrdir.format_registry.aliases())
498
450
    for key in non_aliases:
499
 
        format = controldir.format_registry.make_bzrdir(key)
 
451
        format = bzrdir.format_registry.make_bzrdir(key)
500
452
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
501
453
            if (tree and format.workingtree_format !=
502
454
                tree._format):
514
466
        return 'unnamed'
515
467
    candidates.sort()
516
468
    new_candidates = [c for c in candidates if not
517
 
        controldir.format_registry.get_info(c).hidden]
 
469
        bzrdir.format_registry.get_info(c).hidden]
518
470
    if len(new_candidates) > 0:
519
471
        # If there are any non-hidden formats that match, only return those to
520
472
        # avoid listing hidden formats except when only a hidden format will