/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:26:22 UTC
  • mfrom: (7167.1.4 run-flake8)
  • Revision ID: breezy.the.bot@gmail.com-20181116182622-qw3gan3hz78a2imw
Add a flake8 test.

Merged from https://code.launchpad.net/~jelmer/brz/run-flake8/+merge/358902

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