/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 breezy/info.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 02:09:46 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610020946-nxnwagf535b3lctb
Move breezy.repofmt contents to  breezy.bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
 
17
19
__all__ = ['show_bzrdir_info']
18
20
 
19
 
from cStringIO import StringIO
20
21
import time
21
22
import sys
22
23
 
23
 
from bzrlib import (
24
 
    bzrdir,
 
24
from . import (
 
25
    controldir,
25
26
    errors,
26
27
    hooks as _mod_hooks,
27
28
    osutils,
28
29
    urlutils,
29
30
    )
30
 
from bzrlib.errors import (NoWorkingTree, NotBranchError,
 
31
from .bzr import (
 
32
    bzrdir,
 
33
    )
 
34
from .errors import (NoWorkingTree, NotBranchError,
31
35
                           NoRepositoryPresent, NotLocalUrl)
32
 
from bzrlib.missing import find_unmerged
 
36
from .missing import find_unmerged
 
37
from .sixish import (
 
38
    BytesIO,
 
39
    )
33
40
 
34
41
 
35
42
def plural(n, base='', pl=None):
76
83
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs ]
77
84
 
78
85
 
79
 
def gather_location_info(repository, branch=None, working=None):
 
86
def gather_location_info(repository=None, branch=None, working=None,
 
87
        control=None):
80
88
    locs = {}
81
 
    repository_path = repository.user_url
82
89
    if branch is not None:
83
90
        branch_path = branch.user_url
84
91
        master_path = branch.get_bound_location()
87
94
    else:
88
95
        branch_path = None
89
96
        master_path = None
 
97
        try:
 
98
            if control is not None and control.get_branch_reference():
 
99
                locs['checkout of branch'] = control.get_branch_reference()
 
100
        except NotBranchError:
 
101
            pass
90
102
    if working:
91
103
        working_path = working.user_url
92
104
        if working_path != branch_path:
105
117
            locs['branch root'] = branch_path
106
118
    else:
107
119
        working_path = None
108
 
        if repository.is_shared():
 
120
        if repository is not None and repository.is_shared():
109
121
            # lightweight checkout of branch in shared repository
110
122
            if branch_path is not None:
111
123
                locs['repository branch'] = branch_path
112
124
        elif branch_path is not None:
113
125
            # standalone
114
126
            locs['branch root'] = branch_path
115
 
            if master_path != branch_path:
116
 
                locs['bound to branch'] = master_path
 
127
        elif repository is not None:
 
128
            locs['repository'] = repository.user_url
 
129
        elif control is not None:
 
130
            locs['control directory'] = control.user_url
117
131
        else:
118
 
            locs['repository'] = repository_path
119
 
    if repository.is_shared():
 
132
            # Really, at least a control directory should be
 
133
            # passed in for this method to be useful.
 
134
            pass
 
135
        if master_path != branch_path:
 
136
            locs['bound to branch'] = master_path
 
137
    if repository is not None and repository.is_shared():
120
138
        # lightweight checkout of branch in 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
        locs['shared repository'] = repository.user_url
 
140
    order = ['control directory', 'light checkout root',
 
141
             'repository checkout root', 'checkout root',
 
142
             'checkout of branch', 'shared repository',
124
143
             'repository', 'repository branch', 'branch root',
125
144
             'bound to branch']
126
145
    return [(n, locs[n]) for n in order if n in locs]
158
177
        outfile.writelines(locs.get_lines())
159
178
 
160
179
 
 
180
def _show_control_dir_info(control, outfile):
 
181
    """Show control dir information."""
 
182
    if control._format.colocated_branches:
 
183
        outfile.write('\n')
 
184
        outfile.write('Control directory:\n')
 
185
        outfile.write('         %d branches\n' % len(control.list_branches()))
 
186
 
 
187
 
161
188
def _show_format_info(control=None, repository=None, branch=None,
162
189
                      working=None, outfile=None):
163
190
    """Show known formats for control, working, branch and repository."""
177
204
            repository._format.get_format_description())
178
205
 
179
206
 
180
 
def _show_locking_info(repository, branch=None, working=None, outfile=None):
 
207
def _show_locking_info(repository=None, branch=None, working=None,
 
208
        outfile=None):
181
209
    """Show locking status of working, branch and repository."""
182
 
    if (repository.get_physical_lock_status() or
 
210
    if (repository and repository.get_physical_lock_status() or
183
211
        (branch and branch.get_physical_lock_status()) or
184
212
        (working and working.get_physical_lock_status())):
185
213
        outfile.write('\n')
221
249
    """Show missing revisions in working tree."""
222
250
    branch = working.branch
223
251
    basis = working.basis_tree()
224
 
    work_inv = working.inventory
225
 
    branch_revno, branch_last_revision = branch.last_revision_info()
 
252
    try:
 
253
        branch_revno, branch_last_revision = branch.last_revision_info()
 
254
    except errors.UnsupportedOperation:
 
255
        return
226
256
    try:
227
257
        tree_last_id = working.get_parent_ids()[0]
228
258
    except IndexError:
239
269
def _show_working_stats(working, outfile):
240
270
    """Show statistics about a working tree."""
241
271
    basis = working.basis_tree()
242
 
    work_inv = working.inventory
243
272
    delta = working.changes_from(basis, want_unchanged=True)
244
273
 
245
274
    outfile.write('\n')
260
289
    outfile.write('  %8d ignored\n' % ignore_cnt)
261
290
 
262
291
    dir_cnt = 0
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
    root_id = working.get_root_id()
 
293
    for path, entry in working.iter_entries_by_dir():
 
294
        if entry.kind == 'directory' and entry.file_id != root_id:
266
295
            dir_cnt += 1
267
296
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
268
297
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
270
299
 
271
300
def _show_branch_stats(branch, verbose, outfile):
272
301
    """Show statistics about a branch."""
273
 
    revno, head = branch.last_revision_info()
 
302
    try:
 
303
        revno, head = branch.last_revision_info()
 
304
    except errors.UnsupportedOperation:
 
305
        return {}
274
306
    outfile.write('\n')
275
307
    outfile.write('Branch history:\n')
276
308
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
301
333
 
302
334
def _show_repository_stats(repository, stats, outfile):
303
335
    """Show statistics about a repository."""
304
 
    f = StringIO()
 
336
    f = BytesIO()
305
337
    if 'revisions' in stats:
306
338
        revisions = stats['revisions']
307
339
        f.write('  %8d revision%s\n' % (revisions, plural(revisions)))
322
354
    try:
323
355
        tree = a_bzrdir.open_workingtree(
324
356
            recommend_upgrade=False)
325
 
    except (NoWorkingTree, NotLocalUrl):
 
357
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
326
358
        tree = None
327
359
        try:
328
 
            branch = a_bzrdir.open_branch()
 
360
            branch = a_bzrdir.open_branch(name="")
329
361
        except NotBranchError:
330
362
            branch = None
331
363
            try:
332
364
                repository = a_bzrdir.open_repository()
333
365
            except NoRepositoryPresent:
334
 
                # Return silently; cmd_info already returned NotBranchError
335
 
                # if no bzrdir could be opened.
336
 
                return
 
366
                lockable = None
 
367
                repository = None
337
368
            else:
338
369
                lockable = repository
339
370
        else:
344
375
        repository = branch.repository
345
376
        lockable = tree
346
377
 
347
 
    lockable.lock_read()
 
378
    if lockable is not None:
 
379
        lockable.lock_read()
348
380
    try:
349
381
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
350
382
                            outfile)
351
383
    finally:
352
 
        lockable.unlock()
 
384
        if lockable is not None:
 
385
            lockable.unlock()
353
386
 
354
387
 
355
388
def show_component_info(control, repository, branch=None, working=None,
361
394
        verbose = 1
362
395
    if verbose is True:
363
396
        verbose = 2
364
 
    layout = describe_layout(repository, branch, working)
 
397
    layout = describe_layout(repository, branch, working, control)
365
398
    format = describe_format(control, repository, branch, working)
366
399
    outfile.write("%s (format: %s)\n" % (layout, format))
367
 
    _show_location_info(gather_location_info(repository, branch, working),
368
 
                        outfile)
 
400
    _show_location_info(
 
401
        gather_location_info(control=control, repository=repository,
 
402
            branch=branch, working=working),
 
403
        outfile)
369
404
    if branch is not None:
370
405
        _show_related_info(branch, outfile)
371
406
    if verbose == 0:
372
407
        return
373
408
    _show_format_info(control, repository, branch, working, outfile)
374
409
    _show_locking_info(repository, branch, working, outfile)
 
410
    _show_control_dir_info(control, outfile)
375
411
    if branch is not None:
376
412
        _show_missing_revisions_branch(branch, outfile)
377
413
    if working is not None:
382
418
    if branch is not None:
383
419
        show_committers = verbose >= 2
384
420
        stats = _show_branch_stats(branch, show_committers, outfile)
385
 
    else:
 
421
    elif repository is not None:
386
422
        stats = repository.gather_stats()
387
 
    if branch is None and working is None:
 
423
    if branch is None and working is None and repository is not None:
388
424
        _show_repository_info(repository, outfile)
389
 
    _show_repository_stats(repository, stats, outfile)
390
 
 
391
 
 
392
 
def describe_layout(repository=None, branch=None, tree=None):
 
425
    if repository is not None:
 
426
        _show_repository_stats(repository, stats, outfile)
 
427
 
 
428
 
 
429
def describe_layout(repository=None, branch=None, tree=None, control=None):
393
430
    """Convert a control directory layout into a user-understandable term
394
431
 
395
432
    Common outputs include "Standalone tree", "Repository branch" and
396
433
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
397
434
    and "Empty control directory"
398
435
    """
 
436
    if branch is None and control is not None:
 
437
        try:
 
438
            branch_reference = control.get_branch_reference()
 
439
        except NotBranchError:
 
440
            pass
 
441
        else:
 
442
            if branch_reference is not None:
 
443
                return "Dangling branch reference"
399
444
    if repository is None:
400
445
        return 'Empty control directory'
401
446
    if branch is None and tree is None:
403
448
            phrase = 'Shared repository'
404
449
        else:
405
450
            phrase = 'Unshared repository'
 
451
        extra = []
406
452
        if repository.make_working_trees():
407
 
            phrase += ' with trees'
 
453
            extra.append('trees')
 
454
        if len(control.get_branches()) > 0:
 
455
            extra.append('colocated branches')
 
456
        if extra:
 
457
            phrase += ' with ' + " and ".join(extra)
408
458
        return phrase
409
459
    else:
410
460
        if repository.is_shared():
447
497
        branch.user_url != tree.user_url):
448
498
        branch = None
449
499
        repository = None
450
 
    non_aliases = set(bzrdir.format_registry.keys())
451
 
    non_aliases.difference_update(bzrdir.format_registry.aliases())
 
500
    non_aliases = set(controldir.format_registry.keys())
 
501
    non_aliases.difference_update(controldir.format_registry.aliases())
452
502
    for key in non_aliases:
453
 
        format = bzrdir.format_registry.make_bzrdir(key)
 
503
        format = controldir.format_registry.make_bzrdir(key)
454
504
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
455
505
            if (tree and format.workingtree_format !=
456
506
                tree._format):
468
518
        return 'unnamed'
469
519
    candidates.sort()
470
520
    new_candidates = [c for c in candidates if not
471
 
        bzrdir.format_registry.get_info(c).hidden]
 
521
        controldir.format_registry.get_info(c).hidden]
472
522
    if len(new_candidates) > 0:
473
523
        # If there are any non-hidden formats that match, only return those to
474
524
        # avoid listing hidden formats except when only a hidden format will
481
531
    """Hooks for the info command."""
482
532
 
483
533
    def __init__(self):
484
 
        super(InfoHooks, self).__init__()
485
 
        self.create_hook(_mod_hooks.HookPoint('repository',
 
534
        super(InfoHooks, self).__init__("breezy.info", "hooks")
 
535
        self.add_hook('repository',
486
536
            "Invoked when displaying the statistics for a repository. "
487
537
            "repository is called with a statistics dictionary as returned "
488
 
            "by the repository and a file-like object to write to.", (1, 15), 
489
 
            None))
 
538
            "by the repository and a file-like object to write to.", (1, 15))
490
539
 
491
540
 
492
541
hooks = InfoHooks()