/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

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
 
from io import StringIO
 
19
from cStringIO import StringIO
22
20
import time
23
21
import sys
24
22
 
25
 
from . import (
26
 
    branch as _mod_branch,
27
 
    controldir,
 
23
from bzrlib import (
 
24
    bzrdir,
28
25
    errors,
29
26
    hooks as _mod_hooks,
30
27
    osutils,
31
28
    urlutils,
32
29
    )
33
 
from .bzr import (
34
 
    bzrdir,
35
 
    )
36
 
from .errors import (NoWorkingTree, NotBranchError,
37
 
                     NoRepositoryPresent, NotLocalUrl)
38
 
from .missing import find_unmerged
39
 
 
40
 
 
41
 
def plural(n, base=u'', pl=None):
 
30
from bzrlib.errors import (NoWorkingTree, NotBranchError,
 
31
                           NoRepositoryPresent, NotLocalUrl)
 
32
from bzrlib.missing import find_unmerged
 
33
 
 
34
 
 
35
def plural(n, base='', pl=None):
42
36
    if n == 1:
43
37
        return base
44
38
    elif pl is not None:
45
39
        return pl
46
40
    else:
47
 
        return u's'
 
41
        return 's'
48
42
 
49
43
 
50
44
class LocationList(object):
59
53
            return
60
54
        try:
61
55
            path = urlutils.local_path_from_url(url)
62
 
        except urlutils.InvalidURL:
 
56
        except errors.InvalidURL:
63
57
            self.locs.append((label, url))
64
58
        else:
65
59
            self.add_path(label, path)
79
73
 
80
74
    def get_lines(self):
81
75
        max_len = max(len(l) for l, u in self.locs)
82
 
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs]
83
 
 
84
 
 
85
 
def gather_location_info(repository=None, branch=None, working=None,
86
 
                         control=None):
 
76
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
 
77
 
 
78
 
 
79
def gather_location_info(repository, branch=None, working=None):
87
80
    locs = {}
 
81
    repository_path = repository.user_url
88
82
    if branch is not None:
89
83
        branch_path = branch.user_url
90
84
        master_path = branch.get_bound_location()
93
87
    else:
94
88
        branch_path = None
95
89
        master_path = None
96
 
        try:
97
 
            if control is not None and control.get_branch_reference():
98
 
                locs['checkout of branch'] = control.get_branch_reference()
99
 
        except NotBranchError:
100
 
            pass
101
90
    if working:
102
91
        working_path = working.user_url
103
92
        if working_path != branch_path:
108
97
            else:
109
98
                locs['checkout root'] = branch_path
110
99
        if working_path != master_path:
111
 
            (master_path_base, params) = urlutils.split_segment_parameters(
112
 
                master_path)
113
 
            if working_path == master_path_base:
114
 
                locs['checkout of co-located branch'] = params['branch']
115
 
            elif 'branch' in params:
116
 
                locs['checkout of branch'] = "%s, branch %s" % (
117
 
                    master_path_base, params['branch'])
118
 
            else:
119
 
                locs['checkout of branch'] = master_path
 
100
            locs['checkout of branch'] = master_path
120
101
        elif repository.is_shared():
121
102
            locs['repository branch'] = branch_path
122
103
        elif branch_path is not None:
124
105
            locs['branch root'] = branch_path
125
106
    else:
126
107
        working_path = None
127
 
        if repository is not None and repository.is_shared():
 
108
        if repository.is_shared():
128
109
            # lightweight checkout of branch in shared repository
129
110
            if branch_path is not None:
130
111
                locs['repository branch'] = branch_path
131
112
        elif branch_path is not None:
132
113
            # standalone
133
114
            locs['branch root'] = branch_path
134
 
        elif repository is not None:
135
 
            locs['repository'] = repository.user_url
136
 
        elif control is not None:
137
 
            locs['control directory'] = control.user_url
 
115
            if master_path != branch_path:
 
116
                locs['bound to branch'] = master_path
138
117
        else:
139
 
            # Really, at least a control directory should be
140
 
            # passed in for this method to be useful.
141
 
            pass
142
 
        if master_path != branch_path:
143
 
            locs['bound to branch'] = master_path
144
 
    if repository is not None and repository.is_shared():
 
118
            locs['repository'] = repository_path
 
119
    if repository.is_shared():
145
120
        # lightweight checkout of branch in shared repository
146
 
        locs['shared repository'] = repository.user_url
147
 
    order = ['control directory', 'light checkout root',
148
 
             'repository checkout root', 'checkout root',
149
 
             'checkout of branch', 'checkout of co-located branch',
150
 
             'shared repository', 'repository', 'repository branch',
151
 
             'branch root', 'bound to branch']
 
121
        locs['shared repository'] = repository_path
 
122
    order = ['light checkout root', 'repository checkout root',
 
123
             'checkout root', 'checkout of branch', 'shared repository',
 
124
             'repository', 'repository branch', 'branch root',
 
125
             'bound to branch']
152
126
    return [(n, locs[n]) for n in order if n in locs]
153
127
 
154
128
 
169
143
    locs.add_url('submit branch', branch.get_submit_branch())
170
144
    try:
171
145
        locs.add_url('stacked on', branch.get_stacked_on_url())
172
 
    except (_mod_branch.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
173
 
            errors.NotStacked):
 
146
    except (errors.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
 
147
        errors.NotStacked):
174
148
        pass
175
149
    return locs
176
150
 
184
158
        outfile.writelines(locs.get_lines())
185
159
 
186
160
 
187
 
def _show_control_dir_info(control, outfile):
188
 
    """Show control dir information."""
189
 
    if control._format.colocated_branches:
190
 
        outfile.write('\n')
191
 
        outfile.write('Control directory:\n')
192
 
        outfile.write('         %d branches\n' % len(control.list_branches()))
193
 
 
194
 
 
195
161
def _show_format_info(control=None, repository=None, branch=None,
196
162
                      working=None, outfile=None):
197
163
    """Show known formats for control, working, branch and repository."""
199
165
    outfile.write('Format:\n')
200
166
    if control:
201
167
        outfile.write('       control: %s\n' %
202
 
                      control._format.get_format_description())
 
168
            control._format.get_format_description())
203
169
    if working:
204
170
        outfile.write('  working tree: %s\n' %
205
 
                      working._format.get_format_description())
 
171
            working._format.get_format_description())
206
172
    if branch:
207
173
        outfile.write('        branch: %s\n' %
208
 
                      branch._format.get_format_description())
 
174
            branch._format.get_format_description())
209
175
    if repository:
210
176
        outfile.write('    repository: %s\n' %
211
 
                      repository._format.get_format_description())
212
 
 
213
 
 
214
 
def _show_locking_info(repository=None, branch=None, working=None,
215
 
                       outfile=None):
 
177
            repository._format.get_format_description())
 
178
 
 
179
 
 
180
def _show_locking_info(repository, branch=None, working=None, outfile=None):
216
181
    """Show locking status of working, branch and repository."""
217
 
    if (repository and repository.get_physical_lock_status() or
 
182
    if (repository.get_physical_lock_status() or
218
183
        (branch and branch.get_physical_lock_status()) or
219
 
            (working and working.get_physical_lock_status())):
 
184
        (working and working.get_physical_lock_status())):
220
185
        outfile.write('\n')
221
186
        outfile.write('Lock status:\n')
222
187
        if working:
248
213
        if remote_extra:
249
214
            outfile.write('\n')
250
215
            outfile.write(('Branch is out of date: missing %d '
251
 
                           'revision%s.\n') % (len(remote_extra),
252
 
                                               plural(len(remote_extra))))
 
216
                'revision%s.\n') % (len(remote_extra),
 
217
                plural(len(remote_extra))))
253
218
 
254
219
 
255
220
def _show_missing_revisions_working(working, outfile):
256
221
    """Show missing revisions in working tree."""
257
222
    branch = working.branch
258
 
    try:
259
 
        branch_revno, branch_last_revision = branch.last_revision_info()
260
 
    except errors.UnsupportedOperation:
261
 
        return
 
223
    basis = working.basis_tree()
 
224
    work_inv = working.inventory
 
225
    branch_revno, branch_last_revision = branch.last_revision_info()
262
226
    try:
263
227
        tree_last_id = working.get_parent_ids()[0]
264
228
    except IndexError:
269
233
        missing_count = branch_revno - tree_last_revno
270
234
        outfile.write('\n')
271
235
        outfile.write(('Working tree is out of date: missing %d '
272
 
                       'revision%s.\n') % (missing_count, plural(missing_count)))
 
236
            'revision%s.\n') % (missing_count, plural(missing_count)))
273
237
 
274
238
 
275
239
def _show_working_stats(working, outfile):
276
240
    """Show statistics about a working tree."""
277
241
    basis = working.basis_tree()
 
242
    work_inv = working.inventory
278
243
    delta = working.changes_from(basis, want_unchanged=True)
279
244
 
280
245
    outfile.write('\n')
284
249
    outfile.write('  %8d added\n' % len(delta.added))
285
250
    outfile.write('  %8d removed\n' % len(delta.removed))
286
251
    outfile.write('  %8d renamed\n' % len(delta.renamed))
287
 
    outfile.write('  %8d copied\n' % len(delta.copied))
288
252
 
289
253
    ignore_cnt = unknown_cnt = 0
290
254
    for path in working.extras():
296
260
    outfile.write('  %8d ignored\n' % ignore_cnt)
297
261
 
298
262
    dir_cnt = 0
299
 
    for path, entry in working.iter_entries_by_dir():
300
 
        if entry.kind == 'directory' and path != '':
 
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)):
301
266
            dir_cnt += 1
302
267
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
303
 
                                            plural(dir_cnt, 'subdirectory', 'subdirectories')))
 
268
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
304
269
 
305
270
 
306
271
def _show_branch_stats(branch, verbose, outfile):
307
272
    """Show statistics about a branch."""
308
 
    try:
309
 
        revno, head = branch.last_revision_info()
310
 
    except errors.UnsupportedOperation:
311
 
        return {}
 
273
    revno, head = branch.last_revision_info()
312
274
    outfile.write('\n')
313
275
    outfile.write('Branch history:\n')
314
276
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
316
278
    if verbose:
317
279
        committers = stats['committers']
318
280
        outfile.write('  %8d committer%s\n' % (committers,
319
 
                                               plural(committers)))
 
281
            plural(committers)))
320
282
    if revno:
321
283
        timestamp, timezone = stats['firstrev']
322
284
        age = int((time.time() - timestamp) / 3600 / 24)
323
285
        outfile.write('  %8d day%s old\n' % (age, plural(age)))
324
286
        outfile.write('   first revision: %s\n' %
325
 
                      osutils.format_date(timestamp, timezone))
 
287
            osutils.format_date(timestamp, timezone))
326
288
        timestamp, timezone = stats['latestrev']
327
289
        outfile.write('  latest revision: %s\n' %
328
 
                      osutils.format_date(timestamp, timezone))
 
290
            osutils.format_date(timestamp, timezone))
329
291
    return stats
330
292
 
331
293
 
334
296
    if repository.make_working_trees():
335
297
        outfile.write('\n')
336
298
        outfile.write('Create working tree for new branches inside '
337
 
                      'the repository.\n')
 
299
            'the repository.\n')
338
300
 
339
301
 
340
302
def _show_repository_stats(repository, stats, outfile):
344
306
        revisions = stats['revisions']
345
307
        f.write('  %8d revision%s\n' % (revisions, plural(revisions)))
346
308
    if 'size' in stats:
347
 
        f.write('  %8d KiB\n' % (stats['size'] / 1024))
 
309
        f.write('  %8d KiB\n' % (stats['size']/1024))
348
310
    for hook in hooks['repository']:
349
311
        hook(repository, stats, f)
350
312
    if f.getvalue() != "":
353
315
        outfile.write(f.getvalue())
354
316
 
355
317
 
356
 
def show_bzrdir_info(a_controldir, verbose=False, outfile=None):
357
 
    """Output to stdout the 'info' for a_controldir."""
 
318
def show_bzrdir_info(a_bzrdir, verbose=False, outfile=None):
 
319
    """Output to stdout the 'info' for a_bzrdir."""
358
320
    if outfile is None:
359
321
        outfile = sys.stdout
360
322
    try:
361
 
        tree = a_controldir.open_workingtree(
 
323
        tree = a_bzrdir.open_workingtree(
362
324
            recommend_upgrade=False)
363
 
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
325
    except (NoWorkingTree, NotLocalUrl):
364
326
        tree = None
365
327
        try:
366
 
            branch = a_controldir.open_branch(name="")
 
328
            branch = a_bzrdir.open_branch()
367
329
        except NotBranchError:
368
330
            branch = None
369
331
            try:
370
 
                repository = a_controldir.open_repository()
 
332
                repository = a_bzrdir.open_repository()
371
333
            except NoRepositoryPresent:
372
 
                lockable = None
373
 
                repository = None
 
334
                # Return silently; cmd_info already returned NotBranchError
 
335
                # if no bzrdir could be opened.
 
336
                return
374
337
            else:
375
338
                lockable = repository
376
339
        else:
381
344
        repository = branch.repository
382
345
        lockable = tree
383
346
 
384
 
    if lockable is not None:
385
 
        lockable.lock_read()
 
347
    lockable.lock_read()
386
348
    try:
387
 
        show_component_info(a_controldir, repository, branch, tree, verbose,
 
349
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
388
350
                            outfile)
389
351
    finally:
390
 
        if lockable is not None:
391
 
            lockable.unlock()
 
352
        lockable.unlock()
392
353
 
393
354
 
394
355
def show_component_info(control, repository, branch=None, working=None,
395
 
                        verbose=1, outfile=None):
 
356
    verbose=1, outfile=None):
396
357
    """Write info about all bzrdir components to stdout"""
397
358
    if outfile is None:
398
359
        outfile = sys.stdout
400
361
        verbose = 1
401
362
    if verbose is True:
402
363
        verbose = 2
403
 
    layout = describe_layout(repository, branch, working, control)
 
364
    layout = describe_layout(repository, branch, working)
404
365
    format = describe_format(control, repository, branch, working)
405
366
    outfile.write("%s (format: %s)\n" % (layout, format))
406
 
    _show_location_info(
407
 
        gather_location_info(control=control, repository=repository,
408
 
                             branch=branch, working=working),
409
 
        outfile)
 
367
    _show_location_info(gather_location_info(repository, branch, working),
 
368
                        outfile)
410
369
    if branch is not None:
411
370
        _show_related_info(branch, outfile)
412
371
    if verbose == 0:
413
372
        return
414
373
    _show_format_info(control, repository, branch, working, outfile)
415
374
    _show_locking_info(repository, branch, working, outfile)
416
 
    _show_control_dir_info(control, outfile)
417
375
    if branch is not None:
418
376
        _show_missing_revisions_branch(branch, outfile)
419
377
    if working is not None:
424
382
    if branch is not None:
425
383
        show_committers = verbose >= 2
426
384
        stats = _show_branch_stats(branch, show_committers, outfile)
427
 
    elif repository is not None:
 
385
    else:
428
386
        stats = repository.gather_stats()
429
 
    if branch is None and working is None and repository is not None:
 
387
    if branch is None and working is None:
430
388
        _show_repository_info(repository, outfile)
431
 
    if repository is not None:
432
 
        _show_repository_stats(repository, stats, outfile)
433
 
 
434
 
 
435
 
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):
436
393
    """Convert a control directory layout into a user-understandable term
437
394
 
438
395
    Common outputs include "Standalone tree", "Repository branch" and
439
396
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
440
397
    and "Empty control directory"
441
398
    """
442
 
    if branch is None and control is not None:
443
 
        try:
444
 
            branch_reference = control.get_branch_reference()
445
 
        except NotBranchError:
446
 
            pass
447
 
        else:
448
 
            if branch_reference is not None:
449
 
                return "Dangling branch reference"
450
399
    if repository is None:
451
400
        return 'Empty control directory'
452
401
    if branch is None and tree is None:
454
403
            phrase = 'Shared repository'
455
404
        else:
456
405
            phrase = 'Unshared repository'
457
 
        extra = []
458
406
        if repository.make_working_trees():
459
 
            extra.append('trees')
460
 
        if len(control.branch_names()) > 0:
461
 
            extra.append('colocated branches')
462
 
        if extra:
463
 
            phrase += ' with ' + " and ".join(extra)
 
407
            phrase += ' with trees'
464
408
        return phrase
465
409
    else:
466
410
        if repository.is_shared():
474
418
        if branch is None and tree is not None:
475
419
            phrase = "branchless tree"
476
420
        else:
477
 
            if (tree is not None and tree.controldir.control_url !=
478
 
                    branch.controldir.control_url):
 
421
            if (tree is not None and tree.user_url !=
 
422
                branch.user_url):
479
423
                independence = ''
480
424
                phrase = "Lightweight checkout"
481
425
            elif branch.get_bound_location() is not None:
498
442
 
499
443
    If no matching candidate is found, "unnamed" is returned.
500
444
    """
501
 
    candidates = []
 
445
    candidates  = []
502
446
    if (branch is not None and tree is not None and
503
 
            branch.user_url != tree.user_url):
 
447
        branch.user_url != tree.user_url):
504
448
        branch = None
505
449
        repository = None
506
 
    non_aliases = set(controldir.format_registry.keys())
507
 
    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())
508
452
    for key in non_aliases:
509
 
        format = controldir.format_registry.make_controldir(key)
 
453
        format = bzrdir.format_registry.make_bzrdir(key)
510
454
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
511
455
            if (tree and format.workingtree_format !=
512
 
                    tree._format):
 
456
                tree._format):
513
457
                continue
514
458
            if (branch and format.get_branch_format() !=
515
 
                    branch._format):
 
459
                branch._format):
516
460
                continue
517
461
            if (repository and format.repository_format !=
518
 
                    repository._format):
 
462
                repository._format):
519
463
                continue
520
464
        if format.__class__ is not control._format.__class__:
521
465
            continue
524
468
        return 'unnamed'
525
469
    candidates.sort()
526
470
    new_candidates = [c for c in candidates if not
527
 
                      controldir.format_registry.get_info(c).hidden]
 
471
        bzrdir.format_registry.get_info(c).hidden]
528
472
    if len(new_candidates) > 0:
529
473
        # If there are any non-hidden formats that match, only return those to
530
474
        # avoid listing hidden formats except when only a hidden format will
537
481
    """Hooks for the info command."""
538
482
 
539
483
    def __init__(self):
540
 
        super(InfoHooks, self).__init__("breezy.info", "hooks")
541
 
        self.add_hook(
542
 
            'repository',
 
484
        super(InfoHooks, self).__init__()
 
485
        self.create_hook(_mod_hooks.HookPoint('repository',
543
486
            "Invoked when displaying the statistics for a repository. "
544
487
            "repository is called with a statistics dictionary as returned "
545
 
            "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))
546
490
 
547
491
 
548
492
hooks = InfoHooks()