← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/info.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-06-20 01:09:18 UTC
  • mfrom: (3505.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080620010918-64z4xylh1ap5hgyf
Accept user names with @s in URLs (Neil Martinsen-Burrell)

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
 
from sets import Set
 
17
__all__ = ['show_bzrdir_info']
 
18
 
 
19
import os
20
20
import time
21
 
 
22
 
import bzrlib
23
 
from osutils import format_date
24
 
 
25
 
def show_info(b):
26
 
    print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
27
 
 
28
 
    def plural(n, base='', pl=None):
29
 
        if n == 1:
30
 
            return base
31
 
        elif pl != None:
32
 
            return pl
33
 
        else:
34
 
            return 's'
35
 
 
36
 
    count_version_dirs = 0
37
 
 
38
 
    count_status = {'A': 0, 'D': 0, 'M': 0, 'R': 0, '?': 0, 'I': 0, '.': 0}
39
 
    for st_tup in bzrlib.diff_trees(b.basis_tree(), b.working_tree()):
40
 
        fs = st_tup[0]
41
 
        count_status[fs] += 1
42
 
        if fs not in ['I', '?'] and st_tup[4] == 'directory':
43
 
            count_version_dirs += 1
44
 
 
45
 
    print
46
 
    print 'in the working tree:'
47
 
    for name, fs in (('unchanged', '.'),
48
 
                     ('modified', 'M'), ('added', 'A'), ('removed', 'D'),
49
 
                     ('renamed', 'R'), ('unknown', '?'), ('ignored', 'I'),
50
 
                     ):
51
 
        print '  %8d %s' % (count_status[fs], name)
52
 
    print '  %8d versioned subdirector%s' % (count_version_dirs,
53
 
                                             plural(count_version_dirs, 'y', 'ies'))
54
 
 
55
 
    print
56
 
    print 'branch history:'
57
 
    history = b.revision_history()
58
 
    revno = len(history)
59
 
    print '  %8d revision%s' % (revno, plural(revno))
60
 
    committers = Set()
61
 
    for rev in history:
62
 
        committers.add(b.get_revision(rev).committer)
63
 
    print '  %8d committer%s' % (len(committers), plural(len(committers)))
64
 
    if revno > 0:
65
 
        firstrev = b.get_revision(history[0])
66
 
        age = int((time.time() - firstrev.timestamp) / 3600 / 24)
67
 
        print '  %8d day%s old' % (age, plural(age))
68
 
        print '   first revision: %s' % format_date(firstrev.timestamp,
69
 
                                                    firstrev.timezone)
70
 
 
71
 
        lastrev = b.get_revision(history[-1])
72
 
        print '  latest revision: %s' % format_date(lastrev.timestamp,
73
 
                                                    lastrev.timezone)
74
 
 
75
 
    print
76
 
    print 'text store:'
77
 
    c, t = b.text_store.total_size()
78
 
    print '  %8d file texts' % c
79
 
    print '  %8d kB' % (t/1024)
80
 
 
81
 
    print
82
 
    print 'revision store:'
83
 
    c, t = b.revision_store.total_size()
84
 
    print '  %8d revisions' % c
85
 
    print '  %8d kB' % (t/1024)
86
 
 
87
 
 
88
 
    print
89
 
    print 'inventory store:'
90
 
    c, t = b.inventory_store.total_size()
91
 
    print '  %8d inventories' % c
92
 
    print '  %8d kB' % (t/1024)
93
 
 
 
21
import sys
 
22
 
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    diff,
 
26
    errors,
 
27
    osutils,
 
28
    urlutils,
 
29
    )
 
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):
 
36
    if n == 1:
 
37
        return base
 
38
    elif pl is not None:
 
39
        return pl
 
40
    else:
 
41
        return 's'
 
42
 
 
43
 
 
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):
 
130
    """Show known locations for working, branch and repository."""
 
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):
 
158
    """Show known formats for control, working, branch and repository."""
 
159
    outfile.write('\n')
 
160
    outfile.write('Format:\n')
 
161
    if control:
 
162
        outfile.write('       control: %s\n' %
 
163
            control._format.get_format_description())
 
164
    if working:
 
165
        outfile.write('  working tree: %s\n' %
 
166
            working._format.get_format_description())
 
167
    if branch:
 
168
        outfile.write('        branch: %s\n' %
 
169
            branch._format.get_format_description())
 
170
    if repository:
 
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):
 
203
    """Show missing master revisions in branch."""
 
204
    # Try with inaccessible branch ?
 
205
    master = branch.get_master_branch()
 
206
    if master:
 
207
        local_extra, remote_extra = find_unmerged(branch, master)
 
208
        if remote_extra:
 
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):
 
216
    """Show missing revisions in working tree."""
 
217
    branch = working.branch
 
218
    basis = working.basis_tree()
 
219
    work_inv = working.inventory
 
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
 
225
 
 
226
    if branch_revno and tree_last_id != branch_last_revision:
 
227
        tree_last_revno = branch.revision_id_to_revno(tree_last_id)
 
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):
 
235
    """Show statistics about a working tree."""
 
236
    basis = working.basis_tree()
 
237
    work_inv = working.inventory
 
238
    delta = working.changes_from(basis, want_unchanged=True)
 
239
 
 
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))
 
247
 
 
248
    ignore_cnt = unknown_cnt = 0
 
249
    for path in working.extras():
 
250
        if working.is_ignored(path):
 
251
            ignore_cnt += 1
 
252
        else:
 
253
            unknown_cnt += 1
 
254
    outfile.write('  %8d unknown\n' % unknown_cnt)
 
255
    outfile.write('  %8d ignored\n' % ignore_cnt)
 
256
 
 
257
    dir_cnt = 0
 
258
    for file_id in work_inv:
 
259
        if (work_inv.get_file_kind(file_id) == 'directory' and 
 
260
            not work_inv.is_root(file_id)):
 
261
            dir_cnt += 1
 
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):
 
267
    """Show statistics about a branch."""
 
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)
 
273
    if verbose:
 
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):
 
290
    """Show settings of a repository."""
 
291
    if repository.make_working_trees():
 
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):
 
298
    """Show statistics about a repository."""
 
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):
 
310
    """Output to stdout the 'info' for a_bzrdir."""
 
311
    if outfile is None:
 
312
        outfile = sys.stdout
 
313
    try:
 
314
        tree = a_bzrdir.open_workingtree(
 
315
            recommend_upgrade=False)
 
316
    except (NoWorkingTree, NotLocalUrl):
 
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)