/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-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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