← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-03-03 06:02:49 UTC
  • mfrom: (5672.1.7 branch-revs-to-fetch)
  • Revision ID: pqm@pqm.ubuntu.com-20110303060249-l2zou9i59742nrqf
(spiv) Add Branch.heads_to_fetch API and HPSS request. (Andrew Bennetts)

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
    work_inv = working.inventory
 
225
    branch_revno, branch_last_revision = branch.last_revision_info()
252
226
    try:
253
227
        tree_last_id = working.get_parent_ids()[0]
254
228
    except IndexError:
265
239
def _show_working_stats(working, outfile):
266
240
    """Show statistics about a working tree."""
267
241
    basis = working.basis_tree()
 
242
    work_inv = working.inventory
268
243
    delta = working.changes_from(basis, want_unchanged=True)
269
244
 
270
245
    outfile.write('\n')
285
260
    outfile.write('  %8d ignored\n' % ignore_cnt)
286
261
 
287
262
    dir_cnt = 0
288
 
    root_id = working.get_root_id()
289
 
    for path, entry in working.iter_entries_by_dir():
290
 
        if entry.kind == 'directory' and entry.file_id != root_id:
 
263
    for file_id in work_inv:
 
264
        if (work_inv.get_file_kind(file_id) == 'directory' and
 
265
            not work_inv.is_root(file_id)):
291
266
            dir_cnt += 1
292
267
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
293
268
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
295
270
 
296
271
def _show_branch_stats(branch, verbose, outfile):
297
272
    """Show statistics about a branch."""
298
 
    try:
299
 
        revno, head = branch.last_revision_info()
300
 
    except errors.UnsupportedOperation:
301
 
        return {}
 
273
    revno, head = branch.last_revision_info()
302
274
    outfile.write('\n')
303
275
    outfile.write('Branch history:\n')
304
276
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
350
322
    try:
351
323
        tree = a_bzrdir.open_workingtree(
352
324
            recommend_upgrade=False)
353
 
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
325
    except (NoWorkingTree, NotLocalUrl):
354
326
        tree = None
355
327
        try:
356
 
            branch = a_bzrdir.open_branch(name="")
 
328
            branch = a_bzrdir.open_branch()
357
329
        except NotBranchError:
358
330
            branch = None
359
331
            try:
360
332
                repository = a_bzrdir.open_repository()
361
333
            except NoRepositoryPresent:
362
 
                lockable = None
363
 
                repository = None
 
334
                # Return silently; cmd_info already returned NotBranchError
 
335
                # if no bzrdir could be opened.
 
336
                return
364
337
            else:
365
338
                lockable = repository
366
339
        else:
371
344
        repository = branch.repository
372
345
        lockable = tree
373
346
 
374
 
    if lockable is not None:
375
 
        lockable.lock_read()
 
347
    lockable.lock_read()
376
348
    try:
377
349
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
378
350
                            outfile)
379
351
    finally:
380
 
        if lockable is not None:
381
 
            lockable.unlock()
 
352
        lockable.unlock()
382
353
 
383
354
 
384
355
def show_component_info(control, repository, branch=None, working=None,
390
361
        verbose = 1
391
362
    if verbose is True:
392
363
        verbose = 2
393
 
    layout = describe_layout(repository, branch, working, control)
 
364
    layout = describe_layout(repository, branch, working)
394
365
    format = describe_format(control, repository, branch, working)
395
366
    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)
 
367
    _show_location_info(gather_location_info(repository, branch, working),
 
368
                        outfile)
400
369
    if branch is not None:
401
370
        _show_related_info(branch, outfile)
402
371
    if verbose == 0:
403
372
        return
404
373
    _show_format_info(control, repository, branch, working, outfile)
405
374
    _show_locking_info(repository, branch, working, outfile)
406
 
    _show_control_dir_info(control, outfile)
407
375
    if branch is not None:
408
376
        _show_missing_revisions_branch(branch, outfile)
409
377
    if working is not None:
414
382
    if branch is not None:
415
383
        show_committers = verbose >= 2
416
384
        stats = _show_branch_stats(branch, show_committers, outfile)
417
 
    elif repository is not None:
 
385
    else:
418
386
        stats = repository.gather_stats()
419
 
    if branch is None and working is None and repository is not None:
 
387
    if branch is None and working is None:
420
388
        _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):
 
389
    _show_repository_stats(repository, stats, outfile)
 
390
 
 
391
 
 
392
def describe_layout(repository=None, branch=None, tree=None):
426
393
    """Convert a control directory layout into a user-understandable term
427
394
 
428
395
    Common outputs include "Standalone tree", "Repository branch" and
429
396
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
430
397
    and "Empty control directory"
431
398
    """
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
399
    if repository is None:
441
400
        return 'Empty control directory'
442
401
    if branch is None and tree is None:
444
403
            phrase = 'Shared repository'
445
404
        else:
446
405
            phrase = 'Unshared repository'
447
 
        extra = []
448
406
        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)
 
407
            phrase += ' with trees'
454
408
        return phrase
455
409
    else:
456
410
        if repository.is_shared():
493
447
        branch.user_url != tree.user_url):
494
448
        branch = None
495
449
        repository = None
496
 
    non_aliases = set(controldir.format_registry.keys())
497
 
    non_aliases.difference_update(controldir.format_registry.aliases())
 
450
    non_aliases = set(bzrdir.format_registry.keys())
 
451
    non_aliases.difference_update(bzrdir.format_registry.aliases())
498
452
    for key in non_aliases:
499
 
        format = controldir.format_registry.make_bzrdir(key)
 
453
        format = bzrdir.format_registry.make_bzrdir(key)
500
454
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
501
455
            if (tree and format.workingtree_format !=
502
456
                tree._format):
514
468
        return 'unnamed'
515
469
    candidates.sort()
516
470
    new_candidates = [c for c in candidates if not
517
 
        controldir.format_registry.get_info(c).hidden]
 
471
        bzrdir.format_registry.get_info(c).hidden]
518
472
    if len(new_candidates) > 0:
519
473
        # If there are any non-hidden formats that match, only return those to
520
474
        # avoid listing hidden formats except when only a hidden format will
527
481
    """Hooks for the info command."""
528
482
 
529
483
    def __init__(self):
530
 
        super(InfoHooks, self).__init__("bzrlib.info", "hooks")
531
 
        self.add_hook('repository',
 
484
        super(InfoHooks, self).__init__()
 
485
        self.create_hook(_mod_hooks.HookPoint('repository',
532
486
            "Invoked when displaying the statistics for a repository. "
533
487
            "repository is called with a statistics dictionary as returned "
534
 
            "by the repository and a file-like object to write to.", (1, 15))
 
488
            "by the repository and a file-like object to write to.", (1, 15), 
 
489
            None))
535
490
 
536
491
 
537
492
hooks = InfoHooks()