/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/info.py
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
4
 
 
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
7
5
# the Free Software Foundation; either version 2 of the License, or
8
6
# (at your option) any later version.
9
 
 
 
7
#
10
8
# This program is distributed in the hope that it will be useful,
11
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
11
# GNU General Public License for more details.
14
 
 
 
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
__all__ = ['show_bzrdir_info']
 
18
 
 
19
from io import StringIO
19
20
import time
20
 
 
21
 
from osutils import format_date
22
 
 
23
 
 
24
 
def _countiter(it):
25
 
    # surely there's a builtin for this?
26
 
    i = 0
27
 
    for j in it:
28
 
        i += 1
29
 
    return i        
30
 
 
31
 
 
32
 
 
33
 
def show_info(b):
34
 
    import diff
35
 
    
36
 
    print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
37
 
 
38
 
    def plural(n, base='', pl=None):
39
 
        if n == 1:
40
 
            return base
41
 
        elif pl != None:
42
 
            return pl
43
 
        else:
44
 
            return 's'
45
 
 
46
 
    count_version_dirs = 0
47
 
 
48
 
    basis = b.basis_tree()
49
 
    working = b.working_tree()
50
 
    work_inv = working.inventory
51
 
    delta = diff.compare_trees(basis, working, want_unchanged=True)
52
 
    
53
 
    print
54
 
    print 'in the working tree:'
55
 
    print '  %8s unchanged' % len(delta.unchanged)
56
 
    print '  %8d modified' % len(delta.modified)
57
 
    print '  %8d added' % len(delta.added)
58
 
    print '  %8d removed' % len(delta.removed)
59
 
    print '  %8d renamed' % len(delta.renamed)
 
21
import sys
 
22
 
 
23
from . import (
 
24
    branch as _mod_branch,
 
25
    controldir,
 
26
    errors,
 
27
    hooks as _mod_hooks,
 
28
    osutils,
 
29
    urlutils,
 
30
    )
 
31
from .bzr import (
 
32
    bzrdir,
 
33
    )
 
34
from .errors import (NoWorkingTree, NotBranchError,
 
35
                     NoRepositoryPresent, NotLocalUrl)
 
36
from .missing import find_unmerged
 
37
 
 
38
 
 
39
def plural(n, base=u'', pl=None):
 
40
    if n == 1:
 
41
        return base
 
42
    elif pl is not None:
 
43
        return pl
 
44
    else:
 
45
        return u's'
 
46
 
 
47
 
 
48
class LocationList(object):
 
49
 
 
50
    def __init__(self, base_path):
 
51
        self.locs = []
 
52
        self.base_path = base_path
 
53
 
 
54
    def add_url(self, label, url):
 
55
        """Add a URL to the list, converting it to a path if possible"""
 
56
        if url is None:
 
57
            return
 
58
        try:
 
59
            path = urlutils.local_path_from_url(url)
 
60
        except urlutils.InvalidURL:
 
61
            self.locs.append((label, url))
 
62
        else:
 
63
            self.add_path(label, path)
 
64
 
 
65
    def add_path(self, label, path):
 
66
        """Add a path, converting it to a relative path if possible"""
 
67
        try:
 
68
            path = osutils.relpath(self.base_path, path)
 
69
        except errors.PathNotChild:
 
70
            pass
 
71
        else:
 
72
            if path == '':
 
73
                path = '.'
 
74
        if path != '/':
 
75
            path = path.rstrip('/')
 
76
        self.locs.append((label, path))
 
77
 
 
78
    def get_lines(self):
 
79
        max_len = max(len(l) for l, u in self.locs)
 
80
        return ["  %*s: %s\n" % (max_len, l, u) for l, u in self.locs]
 
81
 
 
82
 
 
83
def gather_location_info(repository=None, branch=None, working=None,
 
84
                         control=None):
 
85
    locs = {}
 
86
    if branch is not None:
 
87
        branch_path = branch.user_url
 
88
        master_path = branch.get_bound_location()
 
89
        if master_path is None:
 
90
            master_path = branch_path
 
91
    else:
 
92
        branch_path = None
 
93
        master_path = None
 
94
        try:
 
95
            if control is not None and control.get_branch_reference():
 
96
                locs['checkout of branch'] = control.get_branch_reference()
 
97
        except NotBranchError:
 
98
            pass
 
99
    if working:
 
100
        working_path = working.user_url
 
101
        if working_path != branch_path:
 
102
            locs['light checkout root'] = working_path
 
103
        if master_path != branch_path:
 
104
            if repository.is_shared():
 
105
                locs['repository checkout root'] = branch_path
 
106
            else:
 
107
                locs['checkout root'] = branch_path
 
108
        if working_path != master_path:
 
109
            (master_path_base, params) = urlutils.split_segment_parameters(
 
110
                master_path)
 
111
            if working_path == master_path_base:
 
112
                locs['checkout of co-located branch'] = params['branch']
 
113
            elif 'branch' in params:
 
114
                locs['checkout of branch'] = "%s, branch %s" % (
 
115
                    master_path_base, params['branch'])
 
116
            else:
 
117
                locs['checkout of branch'] = master_path
 
118
        elif repository.is_shared():
 
119
            locs['repository branch'] = branch_path
 
120
        elif branch_path is not None:
 
121
            # standalone
 
122
            locs['branch root'] = branch_path
 
123
    else:
 
124
        working_path = None
 
125
        if repository is not None and repository.is_shared():
 
126
            # lightweight checkout of branch in shared repository
 
127
            if branch_path is not None:
 
128
                locs['repository branch'] = branch_path
 
129
        elif branch_path is not None:
 
130
            # standalone
 
131
            locs['branch root'] = branch_path
 
132
        elif repository is not None:
 
133
            locs['repository'] = repository.user_url
 
134
        elif control is not None:
 
135
            locs['control directory'] = control.user_url
 
136
        else:
 
137
            # Really, at least a control directory should be
 
138
            # passed in for this method to be useful.
 
139
            pass
 
140
        if master_path != branch_path:
 
141
            locs['bound to branch'] = master_path
 
142
    if repository is not None and repository.is_shared():
 
143
        # lightweight checkout of branch in shared repository
 
144
        locs['shared repository'] = repository.user_url
 
145
    order = ['control directory', 'light checkout root',
 
146
             'repository checkout root', 'checkout root',
 
147
             'checkout of branch', 'checkout of co-located branch',
 
148
             'shared repository', 'repository', 'repository branch',
 
149
             'branch root', 'bound to branch']
 
150
    return [(n, locs[n]) for n in order if n in locs]
 
151
 
 
152
 
 
153
def _show_location_info(locs, outfile):
 
154
    """Show known locations for working, branch and repository."""
 
155
    outfile.write('Location:\n')
 
156
    path_list = LocationList(osutils.getcwd())
 
157
    for name, loc in locs:
 
158
        path_list.add_url(name, loc)
 
159
    outfile.writelines(path_list.get_lines())
 
160
 
 
161
 
 
162
def _gather_related_branches(branch):
 
163
    locs = LocationList(osutils.getcwd())
 
164
    locs.add_url('public branch', branch.get_public_branch())
 
165
    locs.add_url('push branch', branch.get_push_location())
 
166
    locs.add_url('parent branch', branch.get_parent())
 
167
    locs.add_url('submit branch', branch.get_submit_branch())
 
168
    try:
 
169
        locs.add_url('stacked on', branch.get_stacked_on_url())
 
170
    except (_mod_branch.UnstackableBranchFormat, errors.UnstackableRepositoryFormat,
 
171
            errors.NotStacked):
 
172
        pass
 
173
    return locs
 
174
 
 
175
 
 
176
def _show_related_info(branch, outfile):
 
177
    """Show parent and push location of branch."""
 
178
    locs = _gather_related_branches(branch)
 
179
    if len(locs.locs) > 0:
 
180
        outfile.write('\n')
 
181
        outfile.write('Related branches:\n')
 
182
        outfile.writelines(locs.get_lines())
 
183
 
 
184
 
 
185
def _show_control_dir_info(control, outfile):
 
186
    """Show control dir information."""
 
187
    if control._format.colocated_branches:
 
188
        outfile.write('\n')
 
189
        outfile.write('Control directory:\n')
 
190
        outfile.write('         %d branches\n' % len(control.list_branches()))
 
191
 
 
192
 
 
193
def _show_format_info(control=None, repository=None, branch=None,
 
194
                      working=None, outfile=None):
 
195
    """Show known formats for control, working, branch and repository."""
 
196
    outfile.write('\n')
 
197
    outfile.write('Format:\n')
 
198
    if control:
 
199
        outfile.write('       control: %s\n' %
 
200
                      control._format.get_format_description())
 
201
    if working:
 
202
        outfile.write('  working tree: %s\n' %
 
203
                      working._format.get_format_description())
 
204
    if branch:
 
205
        outfile.write('        branch: %s\n' %
 
206
                      branch._format.get_format_description())
 
207
    if repository:
 
208
        outfile.write('    repository: %s\n' %
 
209
                      repository._format.get_format_description())
 
210
 
 
211
 
 
212
def _show_locking_info(repository=None, branch=None, working=None,
 
213
                       outfile=None):
 
214
    """Show locking status of working, branch and repository."""
 
215
    if (repository and repository.get_physical_lock_status() or
 
216
        (branch and branch.get_physical_lock_status()) or
 
217
            (working and working.get_physical_lock_status())):
 
218
        outfile.write('\n')
 
219
        outfile.write('Lock status:\n')
 
220
        if working:
 
221
            if working.get_physical_lock_status():
 
222
                status = 'locked'
 
223
            else:
 
224
                status = 'unlocked'
 
225
            outfile.write('  working tree: %s\n' % status)
 
226
        if branch:
 
227
            if branch.get_physical_lock_status():
 
228
                status = 'locked'
 
229
            else:
 
230
                status = 'unlocked'
 
231
            outfile.write('        branch: %s\n' % status)
 
232
        if repository:
 
233
            if repository.get_physical_lock_status():
 
234
                status = 'locked'
 
235
            else:
 
236
                status = 'unlocked'
 
237
            outfile.write('    repository: %s\n' % status)
 
238
 
 
239
 
 
240
def _show_missing_revisions_branch(branch, outfile):
 
241
    """Show missing master revisions in branch."""
 
242
    # Try with inaccessible branch ?
 
243
    master = branch.get_master_branch()
 
244
    if master:
 
245
        local_extra, remote_extra = find_unmerged(branch, master)
 
246
        if remote_extra:
 
247
            outfile.write('\n')
 
248
            outfile.write(('Branch is out of date: missing %d '
 
249
                           'revision%s.\n') % (len(remote_extra),
 
250
                                               plural(len(remote_extra))))
 
251
 
 
252
 
 
253
def _show_missing_revisions_working(working, outfile):
 
254
    """Show missing revisions in working tree."""
 
255
    branch = working.branch
 
256
    try:
 
257
        branch_revno, branch_last_revision = branch.last_revision_info()
 
258
    except errors.UnsupportedOperation:
 
259
        return
 
260
    try:
 
261
        tree_last_id = working.get_parent_ids()[0]
 
262
    except IndexError:
 
263
        tree_last_id = None
 
264
 
 
265
    if branch_revno and tree_last_id != branch_last_revision:
 
266
        tree_last_revno = branch.revision_id_to_revno(tree_last_id)
 
267
        missing_count = branch_revno - tree_last_revno
 
268
        outfile.write('\n')
 
269
        outfile.write(('Working tree is out of date: missing %d '
 
270
                       'revision%s.\n') % (missing_count, plural(missing_count)))
 
271
 
 
272
 
 
273
def _show_working_stats(working, outfile):
 
274
    """Show statistics about a working tree."""
 
275
    basis = working.basis_tree()
 
276
    delta = working.changes_from(basis, want_unchanged=True)
 
277
 
 
278
    outfile.write('\n')
 
279
    outfile.write('In the working tree:\n')
 
280
    outfile.write('  %8s unchanged\n' % len(delta.unchanged))
 
281
    outfile.write('  %8d modified\n' % len(delta.modified))
 
282
    outfile.write('  %8d added\n' % len(delta.added))
 
283
    outfile.write('  %8d removed\n' % len(delta.removed))
 
284
    outfile.write('  %8d renamed\n' % len(delta.renamed))
 
285
    outfile.write('  %8d copied\n' % len(delta.copied))
60
286
 
61
287
    ignore_cnt = unknown_cnt = 0
62
288
    for path in working.extras():
64
290
            ignore_cnt += 1
65
291
        else:
66
292
            unknown_cnt += 1
67
 
 
68
 
    print '  %8d unknown' % unknown_cnt
69
 
    print '  %8d ignored' % ignore_cnt
 
293
    outfile.write('  %8d unknown\n' % unknown_cnt)
 
294
    outfile.write('  %8d ignored\n' % ignore_cnt)
70
295
 
71
296
    dir_cnt = 0
72
 
    for file_id in work_inv:
73
 
        if work_inv.get_file_kind(file_id) == 'directory':
 
297
    for path, entry in working.iter_entries_by_dir():
 
298
        if entry.kind == 'directory' and path != '':
74
299
            dir_cnt += 1
75
 
    print '  %8d versioned %s' \
76
 
          % (dir_cnt,
77
 
             plural(dir_cnt, 'subdirectory', 'subdirectories'))
78
 
 
79
 
    print
80
 
    print 'branch history:'
81
 
    history = b.revision_history()
82
 
    revno = len(history)
83
 
    print '  %8d revision%s' % (revno, plural(revno))
84
 
    committers = {}
85
 
    for rev in history:
86
 
        committers[b.get_revision(rev).committer] = True
87
 
    print '  %8d committer%s' % (len(committers), plural(len(committers)))
88
 
    if revno > 0:
89
 
        firstrev = b.get_revision(history[0])
90
 
        age = int((time.time() - firstrev.timestamp) / 3600 / 24)
91
 
        print '  %8d day%s old' % (age, plural(age))
92
 
        print '   first revision: %s' % format_date(firstrev.timestamp,
93
 
                                                    firstrev.timezone)
94
 
 
95
 
        lastrev = b.get_revision(history[-1])
96
 
        print '  latest revision: %s' % format_date(lastrev.timestamp,
97
 
                                                    lastrev.timezone)
98
 
 
99
 
    print
100
 
    print 'text store:'
101
 
    c, t = b.text_store.total_size()
102
 
    print '  %8d file texts' % c
103
 
    print '  %8d kB' % (t/1024)
104
 
 
105
 
    print
106
 
    print 'revision store:'
107
 
    c, t = b.revision_store.total_size()
108
 
    print '  %8d revisions' % c
109
 
    print '  %8d kB' % (t/1024)
110
 
 
111
 
 
112
 
    print
113
 
    print 'inventory store:'
114
 
    c, t = b.inventory_store.total_size()
115
 
    print '  %8d inventories' % c
116
 
    print '  %8d kB' % (t/1024)
117
 
 
 
300
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
 
301
                                            plural(dir_cnt, 'subdirectory', 'subdirectories')))
 
302
 
 
303
 
 
304
def _show_branch_stats(branch, verbose, outfile):
 
305
    """Show statistics about a branch."""
 
306
    try:
 
307
        revno, head = branch.last_revision_info()
 
308
    except errors.UnsupportedOperation:
 
309
        return {}
 
310
    outfile.write('\n')
 
311
    outfile.write('Branch history:\n')
 
312
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
 
313
    stats = branch.repository.gather_stats(head, committers=verbose)
 
314
    if verbose:
 
315
        committers = stats['committers']
 
316
        outfile.write('  %8d committer%s\n' % (committers,
 
317
                                               plural(committers)))
 
318
    if revno:
 
319
        timestamp, timezone = stats['firstrev']
 
320
        age = int((time.time() - timestamp) / 3600 / 24)
 
321
        outfile.write('  %8d day%s old\n' % (age, plural(age)))
 
322
        outfile.write('   first revision: %s\n' %
 
323
                      osutils.format_date(timestamp, timezone))
 
324
        timestamp, timezone = stats['latestrev']
 
325
        outfile.write('  latest revision: %s\n' %
 
326
                      osutils.format_date(timestamp, timezone))
 
327
    return stats
 
328
 
 
329
 
 
330
def _show_repository_info(repository, outfile):
 
331
    """Show settings of a repository."""
 
332
    if repository.make_working_trees():
 
333
        outfile.write('\n')
 
334
        outfile.write('Create working tree for new branches inside '
 
335
                      'the repository.\n')
 
336
 
 
337
 
 
338
def _show_repository_stats(repository, stats, outfile):
 
339
    """Show statistics about a repository."""
 
340
    f = StringIO()
 
341
    if 'revisions' in stats:
 
342
        revisions = stats['revisions']
 
343
        f.write('  %8d revision%s\n' % (revisions, plural(revisions)))
 
344
    if 'size' in stats:
 
345
        f.write('  %8d KiB\n' % (stats['size'] / 1024))
 
346
    for hook in hooks['repository']:
 
347
        hook(repository, stats, f)
 
348
    if f.getvalue() != "":
 
349
        outfile.write('\n')
 
350
        outfile.write('Repository:\n')
 
351
        outfile.write(f.getvalue())
 
352
 
 
353
 
 
354
def show_bzrdir_info(a_controldir, verbose=False, outfile=None):
 
355
    """Output to stdout the 'info' for a_controldir."""
 
356
    if outfile is None:
 
357
        outfile = sys.stdout
 
358
    try:
 
359
        tree = a_controldir.open_workingtree(
 
360
            recommend_upgrade=False)
 
361
    except (NoWorkingTree, NotLocalUrl, NotBranchError):
 
362
        tree = None
 
363
        try:
 
364
            branch = a_controldir.open_branch(name="")
 
365
        except NotBranchError:
 
366
            branch = None
 
367
            try:
 
368
                repository = a_controldir.open_repository()
 
369
            except NoRepositoryPresent:
 
370
                lockable = None
 
371
                repository = None
 
372
            else:
 
373
                lockable = repository
 
374
        else:
 
375
            repository = branch.repository
 
376
            lockable = branch
 
377
    else:
 
378
        branch = tree.branch
 
379
        repository = branch.repository
 
380
        lockable = tree
 
381
 
 
382
    if lockable is not None:
 
383
        lockable.lock_read()
 
384
    try:
 
385
        show_component_info(a_controldir, repository, branch, tree, verbose,
 
386
                            outfile)
 
387
    finally:
 
388
        if lockable is not None:
 
389
            lockable.unlock()
 
390
 
 
391
 
 
392
def show_component_info(control, repository, branch=None, working=None,
 
393
                        verbose=1, outfile=None):
 
394
    """Write info about all bzrdir components to stdout"""
 
395
    if outfile is None:
 
396
        outfile = sys.stdout
 
397
    if verbose is False:
 
398
        verbose = 1
 
399
    if verbose is True:
 
400
        verbose = 2
 
401
    layout = describe_layout(repository, branch, working, control)
 
402
    format = describe_format(control, repository, branch, working)
 
403
    outfile.write("%s (format: %s)\n" % (layout, format))
 
404
    _show_location_info(
 
405
        gather_location_info(control=control, repository=repository,
 
406
                             branch=branch, working=working),
 
407
        outfile)
 
408
    if branch is not None:
 
409
        _show_related_info(branch, outfile)
 
410
    if verbose == 0:
 
411
        return
 
412
    _show_format_info(control, repository, branch, working, outfile)
 
413
    _show_locking_info(repository, branch, working, outfile)
 
414
    _show_control_dir_info(control, outfile)
 
415
    if branch is not None:
 
416
        _show_missing_revisions_branch(branch, outfile)
 
417
    if working is not None:
 
418
        _show_missing_revisions_working(working, outfile)
 
419
        _show_working_stats(working, outfile)
 
420
    elif branch is not None:
 
421
        _show_missing_revisions_branch(branch, outfile)
 
422
    if branch is not None:
 
423
        show_committers = verbose >= 2
 
424
        stats = _show_branch_stats(branch, show_committers, outfile)
 
425
    elif repository is not None:
 
426
        stats = repository.gather_stats()
 
427
    if branch is None and working is None and repository is not None:
 
428
        _show_repository_info(repository, outfile)
 
429
    if repository is not None:
 
430
        _show_repository_stats(repository, stats, outfile)
 
431
 
 
432
 
 
433
def describe_layout(repository=None, branch=None, tree=None, control=None):
 
434
    """Convert a control directory layout into a user-understandable term
 
435
 
 
436
    Common outputs include "Standalone tree", "Repository branch" and
 
437
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
 
438
    and "Empty control directory"
 
439
    """
 
440
    if branch is None and control is not None:
 
441
        try:
 
442
            branch_reference = control.get_branch_reference()
 
443
        except NotBranchError:
 
444
            pass
 
445
        else:
 
446
            if branch_reference is not None:
 
447
                return "Dangling branch reference"
 
448
    if repository is None:
 
449
        return 'Empty control directory'
 
450
    if branch is None and tree is None:
 
451
        if repository.is_shared():
 
452
            phrase = 'Shared repository'
 
453
        else:
 
454
            phrase = 'Unshared repository'
 
455
        extra = []
 
456
        if repository.make_working_trees():
 
457
            extra.append('trees')
 
458
        if len(control.branch_names()) > 0:
 
459
            extra.append('colocated branches')
 
460
        if extra:
 
461
            phrase += ' with ' + " and ".join(extra)
 
462
        return phrase
 
463
    else:
 
464
        if repository.is_shared():
 
465
            independence = "Repository "
 
466
        else:
 
467
            independence = "Standalone "
 
468
        if tree is not None:
 
469
            phrase = "tree"
 
470
        else:
 
471
            phrase = "branch"
 
472
        if branch is None and tree is not None:
 
473
            phrase = "branchless tree"
 
474
        else:
 
475
            if (tree is not None and tree.controldir.control_url !=
 
476
                    branch.controldir.control_url):
 
477
                independence = ''
 
478
                phrase = "Lightweight checkout"
 
479
            elif branch.get_bound_location() is not None:
 
480
                if independence == 'Standalone ':
 
481
                    independence = ''
 
482
                if tree is None:
 
483
                    phrase = "Bound branch"
 
484
                else:
 
485
                    phrase = "Checkout"
 
486
        if independence != "":
 
487
            phrase = phrase.lower()
 
488
        return "%s%s" % (independence, phrase)
 
489
 
 
490
 
 
491
def describe_format(control, repository, branch, tree):
 
492
    """Determine the format of an existing control directory
 
493
 
 
494
    Several candidates may be found.  If so, the names are returned as a
 
495
    single string, separated by ' or '.
 
496
 
 
497
    If no matching candidate is found, "unnamed" is returned.
 
498
    """
 
499
    candidates = []
 
500
    if (branch is not None and tree is not None and
 
501
            branch.user_url != tree.user_url):
 
502
        branch = None
 
503
        repository = None
 
504
    non_aliases = set(controldir.format_registry.keys())
 
505
    non_aliases.difference_update(controldir.format_registry.aliases())
 
506
    for key in non_aliases:
 
507
        format = controldir.format_registry.make_controldir(key)
 
508
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
 
509
            if (tree and format.workingtree_format !=
 
510
                    tree._format):
 
511
                continue
 
512
            if (branch and format.get_branch_format() !=
 
513
                    branch._format):
 
514
                continue
 
515
            if (repository and format.repository_format !=
 
516
                    repository._format):
 
517
                continue
 
518
        if format.__class__ is not control._format.__class__:
 
519
            continue
 
520
        candidates.append(key)
 
521
    if len(candidates) == 0:
 
522
        return 'unnamed'
 
523
    candidates.sort()
 
524
    new_candidates = [c for c in candidates if not
 
525
                      controldir.format_registry.get_info(c).hidden]
 
526
    if len(new_candidates) > 0:
 
527
        # If there are any non-hidden formats that match, only return those to
 
528
        # avoid listing hidden formats except when only a hidden format will
 
529
        # do.
 
530
        candidates = new_candidates
 
531
    return ' or '.join(candidates)
 
532
 
 
533
 
 
534
class InfoHooks(_mod_hooks.Hooks):
 
535
    """Hooks for the info command."""
 
536
 
 
537
    def __init__(self):
 
538
        super(InfoHooks, self).__init__("breezy.info", "hooks")
 
539
        self.add_hook(
 
540
            'repository',
 
541
            "Invoked when displaying the statistics for a repository. "
 
542
            "repository is called with a statistics dictionary as returned "
 
543
            "by the repository and a file-like object to write to.", (1, 15))
 
544
 
 
545
 
 
546
hooks = InfoHooks()