← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Martin Pool
  • Date: 2008-07-03 10:44:34 UTC
  • mfrom: (3512.3.2 setlocale.mini)
  • mto: This revision was merged to the branch mainline in revision 3518.
  • Revision ID: mbp@sourcefrog.net-20080703104434-v4qgzvxd2wxg8etl
Set locale from environment for third party libs and day of week.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/info.py
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
4
 
 
 
1
# Copyright (C) 2005, 2006, 2007 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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
17
__all__ = ['show_bzrdir_info']
20
18
 
 
19
import os
21
20
import time
22
 
 
23
 
 
24
 
import bzrlib.diff as diff
 
21
import sys
 
22
 
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    diff,
 
26
    errors,
 
27
    osutils,
 
28
    urlutils,
 
29
    )
25
30
from bzrlib.errors import (NoWorkingTree, NotBranchError,
26
31
                           NoRepositoryPresent, NotLocalUrl)
27
32
from bzrlib.missing import find_unmerged
28
 
from bzrlib.osutils import format_date
29
 
from bzrlib.symbol_versioning import *
30
 
 
31
 
 
32
 
def _countiter(it):
33
 
    # surely there's a builtin for this?
34
 
    i = 0
35
 
    for j in it:
36
 
        i += 1
37
 
    return i        
38
33
 
39
34
 
40
35
def plural(n, base='', pl=None):
41
36
    if n == 1:
42
37
        return base
43
 
    elif pl != None:
 
38
    elif pl is not None:
44
39
        return pl
45
40
    else:
46
41
        return 's'
47
42
 
48
43
 
49
 
def _show_location_info(repository=None, branch=None, working=None):
 
44
class LocationList(object):
 
45
 
 
46
    def __init__(self, base_path):
 
47
        self.locs = []
 
48
        self.base_path = base_path
 
49
 
 
50
    def add_url(self, label, url):
 
51
        """Add a URL to the list, converting it to a path if possible"""
 
52
        if url is None:
 
53
            return
 
54
        try:
 
55
            path = urlutils.local_path_from_url(url)
 
56
        except errors.InvalidURL:
 
57
            self.locs.append((label, url))
 
58
        else:
 
59
            self.add_path(label, path)
 
60
 
 
61
    def add_path(self, label, path):
 
62
        """Add a path, converting it to a relative path if possible"""
 
63
        try:
 
64
            path = osutils.relpath(self.base_path, path)
 
65
        except errors.PathNotChild:
 
66
            pass
 
67
        else:
 
68
            if path == '':
 
69
                path = '.'
 
70
        if path != '/':
 
71
            path = path.rstrip('/')
 
72
        self.locs.append((label, path))
 
73
 
 
74
    def get_lines(self):
 
75
        max_len = max(len(l) for l, u in self.locs)
 
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):
 
80
    locs = {}
 
81
    repository_path = repository.bzrdir.root_transport.base
 
82
    if branch is not None:
 
83
        branch_path = branch.bzrdir.root_transport.base
 
84
        master_path = branch.get_bound_location()
 
85
        if master_path is None:
 
86
            master_path = branch_path
 
87
    else:
 
88
        branch_path = None
 
89
        master_path = None
 
90
    if working:
 
91
        working_path = working.bzrdir.root_transport.base
 
92
        if working_path != branch_path:
 
93
            locs['light checkout root'] = working_path
 
94
        if master_path != branch_path:
 
95
            if repository.is_shared():
 
96
                locs['repository checkout root'] = branch_path
 
97
            else:
 
98
                locs['checkout root'] = branch_path
 
99
        if working_path != master_path:
 
100
            locs['checkout of branch'] = master_path
 
101
        elif repository.is_shared():
 
102
            locs['repository branch'] = branch_path
 
103
        elif branch_path is not None:
 
104
            # standalone
 
105
            locs['branch root'] = branch_path
 
106
    else:
 
107
        working_path = None
 
108
        if repository.is_shared():
 
109
            # lightweight checkout of branch in shared repository
 
110
            if branch_path is not None:
 
111
                locs['repository branch'] = branch_path
 
112
        elif branch_path is not None:
 
113
            # standalone
 
114
            locs['branch root'] = branch_path
 
115
            if master_path != branch_path:
 
116
                locs['bound to branch'] = master_path
 
117
        else:
 
118
            locs['repository'] = repository_path
 
119
    if repository.is_shared():
 
120
        # 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',
 
124
             'repository', 'repository branch', 'branch root',
 
125
             'bound to branch']
 
126
    return [(n, locs[n]) for n in order if n in locs]
 
127
 
 
128
 
 
129
def _show_location_info(locs, outfile):
50
130
    """Show known locations for working, branch and repository."""
51
 
    print 'Location:'
52
 
    if working and branch and working.bzrdir != branch.bzrdir:
53
 
        # Lightweight checkout
54
 
        print '       checkout root: %s' % (
55
 
            working.bzrdir.root_transport.base)
56
 
        print '  checkout of branch: %s' % (
57
 
            branch.bzrdir.root_transport.base)
58
 
    elif branch:
59
 
        # Standalone or bound branch (normal checkout)
60
 
        print '         branch root: %s' % (
61
 
            branch.bzrdir.root_transport.base)
62
 
        if branch.get_bound_location():
63
 
            print '     bound to branch: %s' % branch.get_bound_location()
64
 
 
65
 
    if repository and (not branch or repository.bzrdir != branch.bzrdir):
66
 
        if repository.is_shared():
67
 
            print '   shared repository: %s' % (
68
 
                repository.bzrdir.root_transport.base)
69
 
        else:
70
 
            print '          repository: %s' % (
71
 
                repository.bzrdir.root_transport.base)
72
 
 
73
 
    if branch:
74
 
        if branch.get_parent():
75
 
            print '       parent branch: %s' % branch.get_parent()
76
 
        if branch.get_push_location():
77
 
            print '      push to branch: %s' % branch.get_push_location()
78
 
 
79
 
 
80
 
def _show_format_info(control=None, repository=None, branch=None, working=None):
 
131
    outfile.write('Location:\n')
 
132
    path_list = LocationList(osutils.getcwd())
 
133
    for name, loc in locs:
 
134
        path_list.add_url(name, loc)
 
135
    outfile.writelines(path_list.get_lines())
 
136
 
 
137
 
 
138
def _gather_related_branches(branch):
 
139
    locs = LocationList(osutils.getcwd())
 
140
    locs.add_url('public branch', branch.get_public_branch())
 
141
    locs.add_url('push branch', branch.get_push_location())
 
142
    locs.add_url('parent branch', branch.get_parent())
 
143
    locs.add_url('submit branch', branch.get_submit_branch())
 
144
    return locs
 
145
 
 
146
 
 
147
def _show_related_info(branch, outfile):
 
148
    """Show parent and push location of branch."""
 
149
    locs = _gather_related_branches(branch)
 
150
    if len(locs.locs) > 0:
 
151
        outfile.write('\n')
 
152
        outfile.write('Related branches:\n')
 
153
        outfile.writelines(locs.get_lines())
 
154
 
 
155
 
 
156
def _show_format_info(control=None, repository=None, branch=None,
 
157
                      working=None, outfile=None):
81
158
    """Show known formats for control, working, branch and repository."""
82
 
    print
83
 
    print 'Format:'
 
159
    outfile.write('\n')
 
160
    outfile.write('Format:\n')
84
161
    if control:
85
 
        print '       control: %s' % control._format.get_format_description()
 
162
        outfile.write('       control: %s\n' %
 
163
            control._format.get_format_description())
86
164
    if working:
87
 
        print '  working tree: %s' % working._format.get_format_description()
 
165
        outfile.write('  working tree: %s\n' %
 
166
            working._format.get_format_description())
88
167
    if branch:
89
 
        print '        branch: %s' % branch._format.get_format_description()
 
168
        outfile.write('        branch: %s\n' %
 
169
            branch._format.get_format_description())
90
170
    if repository:
91
 
        print '    repository: %s' % repository._format.get_format_description()
92
 
 
93
 
 
94
 
def _show_missing_revisions_branch(branch):
 
171
        outfile.write('    repository: %s\n' %
 
172
            repository._format.get_format_description())
 
173
 
 
174
 
 
175
def _show_locking_info(repository, branch=None, working=None, outfile=None):
 
176
    """Show locking status of working, branch and repository."""
 
177
    if (repository.get_physical_lock_status() or
 
178
        (branch and branch.get_physical_lock_status()) or
 
179
        (working and working.get_physical_lock_status())):
 
180
        outfile.write('\n')
 
181
        outfile.write('Lock status:\n')
 
182
        if working:
 
183
            if working.get_physical_lock_status():
 
184
                status = 'locked'
 
185
            else:
 
186
                status = 'unlocked'
 
187
            outfile.write('  working tree: %s\n' % status)
 
188
        if branch:
 
189
            if branch.get_physical_lock_status():
 
190
                status = 'locked'
 
191
            else:
 
192
                status = 'unlocked'
 
193
            outfile.write('        branch: %s\n' % status)
 
194
        if repository:
 
195
            if repository.get_physical_lock_status():
 
196
                status = 'locked'
 
197
            else:
 
198
                status = 'unlocked'
 
199
            outfile.write('    repository: %s\n' % status)
 
200
 
 
201
 
 
202
def _show_missing_revisions_branch(branch, outfile):
95
203
    """Show missing master revisions in branch."""
96
204
    # Try with inaccessible branch ?
97
205
    master = branch.get_master_branch()
98
206
    if master:
99
207
        local_extra, remote_extra = find_unmerged(branch, master)
100
208
        if remote_extra:
101
 
            print
102
 
            print 'Branch is out of date: missing %d revision%s.' % (
103
 
                len(remote_extra), plural(len(remote_extra)))
104
 
 
105
 
 
106
 
def _show_missing_revisions_working(working):
 
209
            outfile.write('\n')
 
210
            outfile.write(('Branch is out of date: missing %d '
 
211
                'revision%s.\n') % (len(remote_extra),
 
212
                plural(len(remote_extra))))
 
213
 
 
214
 
 
215
def _show_missing_revisions_working(working, outfile):
107
216
    """Show missing revisions in working tree."""
108
217
    branch = working.branch
109
218
    basis = working.basis_tree()
110
219
    work_inv = working.inventory
111
 
    delta = diff.compare_trees(basis, working, want_unchanged=True)
112
 
    history = branch.revision_history()
113
 
    tree_last_id = working.last_revision()
 
220
    branch_revno, branch_last_revision = branch.last_revision_info()
 
221
    try:
 
222
        tree_last_id = working.get_parent_ids()[0]
 
223
    except IndexError:
 
224
        tree_last_id = None
114
225
 
115
 
    if len(history) and tree_last_id != history[-1]:
 
226
    if branch_revno and tree_last_id != branch_last_revision:
116
227
        tree_last_revno = branch.revision_id_to_revno(tree_last_id)
117
 
        missing_count = len(history) - tree_last_revno
118
 
        print
119
 
        print 'Working tree is out of date: missing %d revision%s.' % (
120
 
            missing_count, plural(missing_count))
121
 
 
122
 
 
123
 
def _show_working_stats(working):
 
228
        missing_count = branch_revno - tree_last_revno
 
229
        outfile.write('\n')
 
230
        outfile.write(('Working tree is out of date: missing %d '
 
231
            'revision%s.\n') % (missing_count, plural(missing_count)))
 
232
 
 
233
 
 
234
def _show_working_stats(working, outfile):
124
235
    """Show statistics about a working tree."""
125
236
    basis = working.basis_tree()
126
237
    work_inv = working.inventory
127
 
    delta = diff.compare_trees(basis, working, want_unchanged=True)
 
238
    delta = working.changes_from(basis, want_unchanged=True)
128
239
 
129
 
    print
130
 
    print 'In the working tree:'
131
 
    print '  %8s unchanged' % len(delta.unchanged)
132
 
    print '  %8d modified' % len(delta.modified)
133
 
    print '  %8d added' % len(delta.added)
134
 
    print '  %8d removed' % len(delta.removed)
135
 
    print '  %8d renamed' % len(delta.renamed)
 
240
    outfile.write('\n')
 
241
    outfile.write('In the working tree:\n')
 
242
    outfile.write('  %8s unchanged\n' % len(delta.unchanged))
 
243
    outfile.write('  %8d modified\n' % len(delta.modified))
 
244
    outfile.write('  %8d added\n' % len(delta.added))
 
245
    outfile.write('  %8d removed\n' % len(delta.removed))
 
246
    outfile.write('  %8d renamed\n' % len(delta.renamed))
136
247
 
137
248
    ignore_cnt = unknown_cnt = 0
138
249
    for path in working.extras():
140
251
            ignore_cnt += 1
141
252
        else:
142
253
            unknown_cnt += 1
143
 
    print '  %8d unknown' % unknown_cnt
144
 
    print '  %8d ignored' % ignore_cnt
 
254
    outfile.write('  %8d unknown\n' % unknown_cnt)
 
255
    outfile.write('  %8d ignored\n' % ignore_cnt)
145
256
 
146
257
    dir_cnt = 0
147
258
    for file_id in work_inv:
148
 
        if work_inv.get_file_kind(file_id) == 'directory':
 
259
        if (work_inv.get_file_kind(file_id) == 'directory' and 
 
260
            not work_inv.is_root(file_id)):
149
261
            dir_cnt += 1
150
 
    print '  %8d versioned %s' \
151
 
          % (dir_cnt,
152
 
             plural(dir_cnt, 'subdirectory', 'subdirectories'))
153
 
 
154
 
 
155
 
def _show_branch_stats(branch, verbose):
 
262
    outfile.write('  %8d versioned %s\n' % (dir_cnt,
 
263
        plural(dir_cnt, 'subdirectory', 'subdirectories')))
 
264
 
 
265
 
 
266
def _show_branch_stats(branch, verbose, outfile):
156
267
    """Show statistics about a branch."""
157
 
    repository = branch.repository
158
 
    history = branch.revision_history()
159
 
 
160
 
    print
161
 
    print 'Branch history:'
162
 
    revno = len(history)
163
 
    print '  %8d revision%s' % (revno, plural(revno))
 
268
    revno, head = branch.last_revision_info()
 
269
    outfile.write('\n')
 
270
    outfile.write('Branch history:\n')
 
271
    outfile.write('  %8d revision%s\n' % (revno, plural(revno)))
 
272
    stats = branch.repository.gather_stats(head, committers=verbose)
164
273
    if verbose:
165
 
        committers = {}
166
 
        for rev in history:
167
 
            committers[repository.get_revision(rev).committer] = True
168
 
        print '  %8d committer%s' % (len(committers), plural(len(committers)))
169
 
    if revno > 0:
170
 
        firstrev = repository.get_revision(history[0])
171
 
        age = int((time.time() - firstrev.timestamp) / 3600 / 24)
172
 
        print '  %8d day%s old' % (age, plural(age))
173
 
        print '   first revision: %s' % format_date(firstrev.timestamp,
174
 
                                                    firstrev.timezone)
175
 
 
176
 
        lastrev = repository.get_revision(history[-1])
177
 
        print '  latest revision: %s' % format_date(lastrev.timestamp,
178
 
                                                    lastrev.timezone)
179
 
 
180
 
#     print
181
 
#     print 'Text store:'
182
 
#     c, t = branch.text_store.total_size()
183
 
#     print '  %8d file texts' % c
184
 
#     print '  %8d KiB' % (t/1024)
185
 
 
186
 
#     print
187
 
#     print 'Inventory store:'
188
 
#     c, t = branch.inventory_store.total_size()
189
 
#     print '  %8d inventories' % c
190
 
#     print '  %8d KiB' % (t/1024)
191
 
 
192
 
 
193
 
def _show_repository_info(repository):
 
274
        committers = stats['committers']
 
275
        outfile.write('  %8d committer%s\n' % (committers,
 
276
            plural(committers)))
 
277
    if revno:
 
278
        timestamp, timezone = stats['firstrev']
 
279
        age = int((time.time() - timestamp) / 3600 / 24)
 
280
        outfile.write('  %8d day%s old\n' % (age, plural(age)))
 
281
        outfile.write('   first revision: %s\n' %
 
282
            osutils.format_date(timestamp, timezone))
 
283
        timestamp, timezone = stats['latestrev']
 
284
        outfile.write('  latest revision: %s\n' %
 
285
            osutils.format_date(timestamp, timezone))
 
286
    return stats
 
287
 
 
288
 
 
289
def _show_repository_info(repository, outfile):
194
290
    """Show settings of a repository."""
195
291
    if repository.make_working_trees():
196
 
        print
197
 
        print 'Create working tree for new branches inside the repository.'
198
 
 
199
 
 
200
 
def _show_repository_stats(repository):
 
292
        outfile.write('\n')
 
293
        outfile.write('Create working tree for new branches inside '
 
294
            'the repository.\n')
 
295
 
 
296
 
 
297
def _show_repository_stats(stats, outfile):
201
298
    """Show statistics about a repository."""
202
 
    if repository.bzrdir.root_transport.listable():
203
 
        print
204
 
        print 'Revision store:'
205
 
        c, t = repository._revision_store.total_size(repository.get_transaction())
206
 
        print '  %8d revision%s' % (c, plural(c))
207
 
        print '  %8d KiB' % (t/1024)
208
 
 
209
 
 
210
 
@deprecated_function(zero_eight)
211
 
def show_info(b):
212
 
    """Please see show_bzrdir_info."""
213
 
    return show_bzrdir_info(b.bzrdir)
214
 
 
215
 
 
216
 
def show_bzrdir_info(a_bzrdir, verbose=False):
 
299
    if 'revisions' in stats or 'size' in stats:
 
300
        outfile.write('\n')
 
301
        outfile.write('Repository:\n')
 
302
    if 'revisions' in stats:
 
303
        revisions = stats['revisions']
 
304
        outfile.write('  %8d revision%s\n' % (revisions, plural(revisions)))
 
305
    if 'size' in stats:
 
306
        outfile.write('  %8d KiB\n' % (stats['size']/1024))
 
307
 
 
308
 
 
309
def show_bzrdir_info(a_bzrdir, verbose=False, outfile=None):
217
310
    """Output to stdout the 'info' for a_bzrdir."""
 
311
    if outfile is None:
 
312
        outfile = sys.stdout
218
313
    try:
219
 
        working = a_bzrdir.open_workingtree()
220
 
        working.lock_read()
221
 
        try:
222
 
            show_tree_info(working, verbose)
223
 
        finally:
224
 
            working.unlock()
225
 
        return
 
314
        tree = a_bzrdir.open_workingtree(
 
315
            recommend_upgrade=False)
226
316
    except (NoWorkingTree, NotLocalUrl):
227
 
        pass
228
 
 
229
 
    try:
230
 
        branch = a_bzrdir.open_branch()
231
 
        branch.lock_read()
232
 
        try:
233
 
            show_branch_info(branch, verbose)
234
 
        finally:
235
 
            branch.unlock()
236
 
        return
237
 
    except NotBranchError:
238
 
        pass
239
 
 
240
 
    try:
241
 
        repository = a_bzrdir.open_repository()
242
 
        repository.lock_read()
243
 
        try:
244
 
            show_repository_info(repository, verbose)
245
 
        finally:
246
 
            repository.unlock()
247
 
        return
248
 
    except NoRepositoryPresent:
249
 
        pass
250
 
 
251
 
    # Return silently, cmd_info returns NotBranchError if no bzrdir
252
 
    # could be opened.
253
 
 
254
 
 
255
 
def show_tree_info(working, verbose):
256
 
    """Output to stdout the 'info' for working."""
257
 
    branch = working.branch
258
 
    repository = branch.repository
259
 
    control = working.bzrdir
260
 
 
261
 
    _show_location_info(repository, branch, working)
262
 
    _show_format_info(control, repository, branch, working)
263
 
    _show_missing_revisions_branch(branch)
264
 
    _show_missing_revisions_working(working)
265
 
    _show_working_stats(working)
266
 
    _show_branch_stats(branch, verbose)
267
 
    _show_repository_stats(repository)
268
 
 
269
 
 
270
 
def show_branch_info(branch, verbose):
271
 
    """Output to stdout the 'info' for branch."""
272
 
    repository = branch.repository
273
 
    control = branch.bzrdir
274
 
 
275
 
    _show_location_info(repository, branch)
276
 
    _show_format_info(control, repository, branch)
277
 
    _show_missing_revisions_branch(branch)
278
 
    _show_branch_stats(branch, verbose)
279
 
    _show_repository_stats(repository)
280
 
 
281
 
 
282
 
def show_repository_info(repository, verbose):
283
 
    """Output to stdout the 'info' for branch."""
284
 
    control = repository.bzrdir
285
 
 
286
 
    _show_location_info(repository)
287
 
    _show_format_info(control, repository)
288
 
    _show_repository_info(repository)
289
 
    _show_repository_stats(repository)
 
317
        tree = None
 
318
        try:
 
319
            branch = a_bzrdir.open_branch()
 
320
        except NotBranchError:
 
321
            branch = None
 
322
            try:
 
323
                repository = a_bzrdir.open_repository()
 
324
            except NoRepositoryPresent:
 
325
                # Return silently; cmd_info already returned NotBranchError
 
326
                # if no bzrdir could be opened.
 
327
                return
 
328
            else:
 
329
                lockable = repository
 
330
        else:
 
331
            repository = branch.repository
 
332
            lockable = branch
 
333
    else:
 
334
        branch = tree.branch
 
335
        repository = branch.repository
 
336
        lockable = tree
 
337
 
 
338
    lockable.lock_read()
 
339
    try:
 
340
        show_component_info(a_bzrdir, repository, branch, tree, verbose,
 
341
                            outfile)
 
342
    finally:
 
343
        lockable.unlock()
 
344
 
 
345
 
 
346
def show_component_info(control, repository, branch=None, working=None,
 
347
    verbose=1, outfile=None):
 
348
    """Write info about all bzrdir components to stdout"""
 
349
    if outfile is None:
 
350
        outfile = sys.stdout
 
351
    if verbose is False:
 
352
        verbose = 1
 
353
    if verbose is True:
 
354
        verbose = 2
 
355
    layout = describe_layout(repository, branch, working)
 
356
    format = describe_format(control, repository, branch, working)
 
357
    outfile.write("%s (format: %s)\n" % (layout, format))
 
358
    _show_location_info(gather_location_info(repository, branch, working),
 
359
                        outfile)
 
360
    if branch is not None:
 
361
        _show_related_info(branch, outfile)
 
362
    if verbose == 0:
 
363
        return
 
364
    _show_format_info(control, repository, branch, working, outfile)
 
365
    _show_locking_info(repository, branch, working, outfile)
 
366
    if branch is not None:
 
367
        _show_missing_revisions_branch(branch, outfile)
 
368
    if working is not None:
 
369
        _show_missing_revisions_working(working, outfile)
 
370
        _show_working_stats(working, outfile)
 
371
    elif branch is not None:
 
372
        _show_missing_revisions_branch(branch, outfile)
 
373
    if branch is not None:
 
374
        stats = _show_branch_stats(branch, verbose==2, outfile)
 
375
    else:
 
376
        stats = repository.gather_stats()
 
377
    if branch is None and working is None:
 
378
        _show_repository_info(repository, outfile)
 
379
    _show_repository_stats(stats, outfile)
 
380
 
 
381
 
 
382
def describe_layout(repository=None, branch=None, tree=None):
 
383
    """Convert a control directory layout into a user-understandable term
 
384
 
 
385
    Common outputs include "Standalone tree", "Repository branch" and
 
386
    "Checkout".  Uncommon outputs include "Unshared repository with trees"
 
387
    and "Empty control directory"
 
388
    """
 
389
    if repository is None:
 
390
        return 'Empty control directory'
 
391
    if branch is None and tree is None:
 
392
        if repository.is_shared():
 
393
            phrase = 'Shared repository'
 
394
        else:
 
395
            phrase = 'Unshared repository'
 
396
        if repository.make_working_trees():
 
397
            phrase += ' with trees'
 
398
        return phrase
 
399
    else:
 
400
        if repository.is_shared():
 
401
            independence = "Repository "
 
402
        else:
 
403
            independence = "Standalone "
 
404
        if tree is not None:
 
405
            phrase = "tree"
 
406
        else:
 
407
            phrase = "branch"
 
408
        if branch is None and tree is not None:
 
409
            phrase = "branchless tree"
 
410
        else:
 
411
            if (tree is not None and tree.bzrdir.root_transport.base !=
 
412
                branch.bzrdir.root_transport.base):
 
413
                independence = ''
 
414
                phrase = "Lightweight checkout"
 
415
            elif branch.get_bound_location() is not None:
 
416
                if independence == 'Standalone ':
 
417
                    independence = ''
 
418
                if tree is None:
 
419
                    phrase = "Bound branch"
 
420
                else:
 
421
                    phrase = "Checkout"
 
422
        if independence != "":
 
423
            phrase = phrase.lower()
 
424
        return "%s%s" % (independence, phrase)
 
425
 
 
426
 
 
427
def describe_format(control, repository, branch, tree):
 
428
    """Determine the format of an existing control directory
 
429
 
 
430
    Several candidates may be found.  If so, the names are returned as a
 
431
    single string, separated by ' or '.
 
432
 
 
433
    If no matching candidate is found, "unnamed" is returned.
 
434
    """
 
435
    candidates  = []
 
436
    if (branch is not None and tree is not None and
 
437
        branch.bzrdir.root_transport.base !=
 
438
        tree.bzrdir.root_transport.base):
 
439
        branch = None
 
440
        repository = None
 
441
    non_aliases = set(bzrdir.format_registry.keys())
 
442
    non_aliases.difference_update(bzrdir.format_registry.aliases())
 
443
    for key in non_aliases:
 
444
        format = bzrdir.format_registry.make_bzrdir(key)
 
445
        if isinstance(format, bzrdir.BzrDirMetaFormat1):
 
446
            if (tree and format.workingtree_format !=
 
447
                tree._format):
 
448
                continue
 
449
            if (branch and format.get_branch_format() !=
 
450
                branch._format):
 
451
                continue
 
452
            if (repository and format.repository_format !=
 
453
                repository._format):
 
454
                continue
 
455
        if format.__class__ is not control._format.__class__:
 
456
            continue
 
457
        candidates.append(key)
 
458
    if len(candidates) == 0:
 
459
        return 'unnamed'
 
460
    candidates.sort()
 
461
    new_candidates = [c for c in candidates if not
 
462
        bzrdir.format_registry.get_info(c).hidden]
 
463
    if len(new_candidates) > 0:
 
464
        # If there are any non-hidden formats that match, only return those to
 
465
        # avoid listing hidden formats except when only a hidden format will
 
466
        # do.
 
467
        candidates = new_candidates
 
468
    return ' or '.join(candidates)