/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-11-11 12:51:45 UTC
  • mto: This revision was merged to the branch mainline in revision 6804.
  • Revision ID: jelmer@jelmer.uk-20171111125145-zw639zp14j8b2cin
Bunch of developer docs changes:

 * Move plans to plans/
 * Move performance analysis & planning docs to plans/performance/
 * Change Bazaar references to Breezy
 * Add branding guidelines

Show diffs side-by-side

added added

removed removed

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