/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/ui/text.py

  • Committer: Jelmer Vernooij
  • Date: 2018-03-01 23:44:14 UTC
  • mto: This revision was merged to the branch mainline in revision 6871.
  • Revision ID: jelmer@jelmer.uk-20180301234414-5btxmc1z8pz131ob
Fix context manager for RecordingUIFactory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/ui/text.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
"""Text UI, write output to the console."""
17
18
 
18
 
"""Text UI, write output to the console.
19
 
"""
 
19
from __future__ import absolute_import
20
20
 
21
21
import codecs
22
 
import getpass
23
22
import os
24
23
import sys
25
 
import time
26
24
import warnings
27
25
 
28
 
from bzrlib.lazy_import import lazy_import
 
26
from ..lazy_import import lazy_import
29
27
lazy_import(globals(), """
30
 
from bzrlib import (
 
28
import getpass
 
29
import time
 
30
 
 
31
from breezy import (
31
32
    debug,
32
33
    progress,
 
34
    )
 
35
""")
 
36
 
 
37
from .. import (
 
38
    config,
33
39
    osutils,
34
 
    symbol_versioning,
35
40
    trace,
36
41
    )
37
 
 
38
 
""")
39
 
 
40
 
from bzrlib.osutils import watch_sigwinch
41
 
 
42
 
from bzrlib.ui import (
 
42
from ..sixish import (
 
43
    text_type,
 
44
    )
 
45
from . import (
 
46
    NullProgressView,
43
47
    UIFactory,
44
 
    NullProgressView,
45
48
    )
46
49
 
47
50
 
 
51
class _ChooseUI(object):
 
52
 
 
53
    """ Helper class for choose implementation.
 
54
    """
 
55
 
 
56
    def __init__(self, ui, msg, choices, default):
 
57
        self.ui = ui
 
58
        self._setup_mode()
 
59
        self._build_alternatives(msg, choices, default)
 
60
 
 
61
    def _setup_mode(self):
 
62
        """Setup input mode (line-based, char-based) and echo-back.
 
63
 
 
64
        Line-based input is used if the BRZ_TEXTUI_INPUT environment
 
65
        variable is set to 'line-based', or if there is no controlling
 
66
        terminal.
 
67
        """
 
68
        if os.environ.get('BRZ_TEXTUI_INPUT') != 'line-based' and \
 
69
           self.ui.stdin == sys.stdin and self.ui.stdin.isatty():
 
70
            self.line_based = False
 
71
            self.echo_back = True
 
72
        else:
 
73
            self.line_based = True
 
74
            self.echo_back = not self.ui.stdin.isatty()
 
75
 
 
76
    def _build_alternatives(self, msg, choices, default):
 
77
        """Parse choices string.
 
78
 
 
79
        Setup final prompt and the lists of choices and associated
 
80
        shortcuts.
 
81
        """
 
82
        index = 0
 
83
        help_list = []
 
84
        self.alternatives = {}
 
85
        choices = choices.split('\n')
 
86
        if default is not None and default not in range(0, len(choices)):
 
87
            raise ValueError("invalid default index")
 
88
        for c in choices:
 
89
            name = c.replace('&', '').lower()
 
90
            choice = (name, index)
 
91
            if name in self.alternatives:
 
92
                raise ValueError("duplicated choice: %s" % name)
 
93
            self.alternatives[name] = choice
 
94
            shortcut = c.find('&')
 
95
            if -1 != shortcut and (shortcut + 1) < len(c):
 
96
                help = c[:shortcut]
 
97
                help += '[' + c[shortcut + 1] + ']'
 
98
                help += c[(shortcut + 2):]
 
99
                shortcut = c[shortcut + 1]
 
100
            else:
 
101
                c = c.replace('&', '')
 
102
                shortcut = c[0]
 
103
                help = '[%s]%s' % (shortcut, c[1:])
 
104
            shortcut = shortcut.lower()
 
105
            if shortcut in self.alternatives:
 
106
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
107
            self.alternatives[shortcut] = choice
 
108
            # Add redirections for default.
 
109
            if index == default:
 
110
                self.alternatives[''] = choice
 
111
                self.alternatives['\r'] = choice
 
112
            help_list.append(help)
 
113
            index += 1
 
114
 
 
115
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
116
 
 
117
    def _getline(self):
 
118
        line = self.ui.stdin.readline()
 
119
        if '' == line:
 
120
            raise EOFError
 
121
        return line.strip()
 
122
 
 
123
    def _getchar(self):
 
124
        char = osutils.getchar()
 
125
        if char == chr(3): # INTR
 
126
            raise KeyboardInterrupt
 
127
        if char == chr(4): # EOF (^d, C-d)
 
128
            raise EOFError
 
129
        return char.decode("ascii", "replace")
 
130
 
 
131
    def interact(self):
 
132
        """Keep asking the user until a valid choice is made.
 
133
        """
 
134
        if self.line_based:
 
135
            getchoice = self._getline
 
136
        else:
 
137
            getchoice = self._getchar
 
138
        iter = 0
 
139
        while True:
 
140
            iter += 1
 
141
            if 1 == iter or self.line_based:
 
142
                self.ui.prompt(self.prompt)
 
143
            try:
 
144
                choice = getchoice()
 
145
            except EOFError:
 
146
                self.ui.stderr.write(u'\n')
 
147
                return None
 
148
            except KeyboardInterrupt:
 
149
                self.ui.stderr.write(u'\n')
 
150
                raise
 
151
            choice = choice.lower()
 
152
            if choice not in self.alternatives:
 
153
                # Not a valid choice, keep on asking.
 
154
                continue
 
155
            name, index = self.alternatives[choice]
 
156
            if self.echo_back:
 
157
                self.ui.stderr.write(name + u'\n')
 
158
            return index
 
159
 
 
160
 
 
161
opt_progress_bar = config.Option(
 
162
    'progress_bar', help='Progress bar type.',
 
163
    default_from_env=['BRZ_PROGRESS_BAR'], default=None,
 
164
    invalid='error')
 
165
 
 
166
 
48
167
class TextUIFactory(UIFactory):
49
 
    """A UI factory for Text user interefaces."""
 
168
    """A UI factory for Text user interfaces."""
50
169
 
51
 
    def __init__(self,
52
 
                 stdin=None,
53
 
                 stdout=None,
54
 
                 stderr=None):
55
 
        """Create a TextUIFactory.
56
 
        """
 
170
    def __init__(self, stdin, stdout, stderr):
 
171
        """Create a TextUIFactory."""
57
172
        super(TextUIFactory, self).__init__()
58
 
        # TODO: there's no good reason not to pass all three streams, maybe we
59
 
        # should deprecate the default values...
60
173
        self.stdin = stdin
61
174
        self.stdout = stdout
62
175
        self.stderr = stderr
63
176
        # paints progress, network activity, etc
64
177
        self._progress_view = self.make_progress_view()
65
 
        # hook up the signals to watch for terminal size changes
66
 
        watch_sigwinch()
 
178
 
 
179
    def choose(self, msg, choices, default=None):
 
180
        """Prompt the user for a list of alternatives.
 
181
 
 
182
        Support both line-based and char-based editing.
 
183
 
 
184
        In line-based mode, both the shortcut and full choice name are valid
 
185
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
186
        'YES ' are all valid input lines for choosing 'yes'.
 
187
 
 
188
        An empty line, when in line-based mode, or pressing enter in char-based
 
189
        mode will select the default choice (if any).
 
190
 
 
191
        Choice is echoed back if:
 
192
        - input is char-based; which means a controlling terminal is available,
 
193
          and osutils.getchar is used
 
194
        - input is line-based, and no controlling terminal is available
 
195
        """
 
196
 
 
197
        choose_ui = _ChooseUI(self, msg, choices, default)
 
198
        return choose_ui.interact()
67
199
 
68
200
    def be_quiet(self, state):
69
201
        if state and not self._quiet:
82
214
        # to clear it.  We might need to separately check for the case of
83
215
        self._progress_view.clear()
84
216
 
85
 
    def get_boolean(self, prompt):
86
 
        while True:
87
 
            self.prompt(prompt + "? [y/n]: ")
88
 
            line = self.stdin.readline().lower()
89
 
            if line in ('y\n', 'yes\n'):
90
 
                return True
91
 
            elif line in ('n\n', 'no\n'):
92
 
                return False
93
 
            elif line in ('', None):
94
 
                # end-of-file; possibly should raise an error here instead
95
 
                return None
96
 
 
97
217
    def get_integer(self, prompt):
98
218
        while True:
99
219
            self.prompt(prompt)
114
234
            password = self.stdin.readline()
115
235
            if not password:
116
236
                password = None
117
 
            elif password[-1] == '\n':
118
 
                password = password[:-1]
 
237
            else:
 
238
                if password[-1] == '\n':
 
239
                    password = password[:-1]
119
240
        return password
120
241
 
121
 
    def get_password(self, prompt='', **kwargs):
 
242
    def get_password(self, prompt=u'', **kwargs):
122
243
        """Prompt the user for a password.
123
244
 
124
245
        :param prompt: The prompt to present the user
149
270
        username = self.stdin.readline()
150
271
        if not username:
151
272
            username = None
152
 
        elif username[-1] == '\n':
153
 
            username = username[:-1]
 
273
        else:
 
274
            if username[-1] == '\n':
 
275
                username = username[:-1]
154
276
        return username
155
277
 
156
278
    def make_progress_view(self):
157
279
        """Construct and return a new ProgressView subclass for this UI.
158
280
        """
159
281
        # with --quiet, never any progress view
160
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
282
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
161
283
        # user specifically requests either text or no progress bars, always
162
284
        # do that.  otherwise, guess based on $TERM and tty presence.
163
285
        if self.is_quiet():
164
286
            return NullProgressView()
165
 
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
166
 
            return TextProgressView(self.stderr)
167
 
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
168
 
            return NullProgressView()
169
 
        elif progress._supports_progress(self.stderr):
170
 
            return TextProgressView(self.stderr)
171
 
        else:
172
 
            return NullProgressView()
 
287
        pb_type = config.GlobalStack().get('progress_bar')
 
288
        if pb_type == 'none': # Explicit requirement
 
289
            return NullProgressView()
 
290
        if (pb_type == 'text' # Explicit requirement
 
291
            or progress._supports_progress(self.stderr)): # Guess
 
292
            return TextProgressView(self.stderr)
 
293
        # No explicit requirement and no successful guess
 
294
        return NullProgressView()
173
295
 
174
296
    def _make_output_stream_explicit(self, encoding, encoding_type):
175
 
        if encoding_type == 'exact':
176
 
            # force sys.stdout to be binary stream on win32; 
177
 
            # NB: this leaves the file set in that mode; may cause problems if
178
 
            # one process tries to do binary and then text output
179
 
            if sys.platform == 'win32':
180
 
                fileno = getattr(self.stdout, 'fileno', None)
181
 
                if fileno:
182
 
                    import msvcrt
183
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
184
 
            return TextUIOutputStream(self, self.stdout)
185
 
        else:
186
 
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
187
 
                errors=encoding_type)
188
 
            # For whatever reason codecs.getwriter() does not advertise its encoding
189
 
            # it just returns the encoding of the wrapped file, which is completely
190
 
            # bogus. So set the attribute, so we can find the correct encoding later.
191
 
            encoded_stdout.encoding = encoding
192
 
            return TextUIOutputStream(self, encoded_stdout)
 
297
        return TextUIOutputStream(self, self.stdout, encoding, encoding_type)
193
298
 
194
299
    def note(self, msg):
195
300
        """Write an already-formatted message, clearing the progress bar if necessary."""
198
303
 
199
304
    def prompt(self, prompt, **kwargs):
200
305
        """Emit prompt on the CLI.
201
 
        
 
306
 
202
307
        :param kwargs: Dictionary of arguments to insert into the prompt,
203
308
            to allow UIs to reformat the prompt.
204
309
        """
 
310
        if not isinstance(prompt, text_type):
 
311
            raise ValueError("prompt %r not a unicode string" % prompt)
205
312
        if kwargs:
206
313
            # See <https://launchpad.net/bugs/365891>
207
314
            prompt = prompt % kwargs
208
 
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
209
315
        self.clear_term()
 
316
        self.stdout.flush()
210
317
        self.stderr.write(prompt)
211
318
 
212
319
    def report_transport_activity(self, transport, byte_count, direction):
262
369
        # be easier to test; that has a lot of test fallout so for now just
263
370
        # new code can call this
264
371
        if warning_id not in self.suppressed_warnings:
265
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
266
 
                '\n')
 
372
            warning = self.format_user_warning(warning_id, message_args)
 
373
            self.stderr.write(warning + '\n')
 
374
 
 
375
 
 
376
def pad_to_width(line, width, encoding_hint='ascii'):
 
377
    """Truncate or pad unicode line to width.
 
378
 
 
379
    This is best-effort for now, and strings containing control codes or
 
380
    non-ascii text may be cut and padded incorrectly.
 
381
    """
 
382
    s = line.encode(encoding_hint, 'replace')
 
383
    return (b'%-*.*s' % (width, width, s)).decode(encoding_hint)
267
384
 
268
385
 
269
386
class TextProgressView(object):
270
387
    """Display of progress bar and other information on a tty.
271
388
 
272
 
    This shows one line of text, including possibly a network indicator, spinner,
273
 
    progress bar, message, etc.
 
389
    This shows one line of text, including possibly a network indicator,
 
390
    spinner, progress bar, message, etc.
274
391
 
275
392
    One instance of this is created and held by the UI, and fed updates when a
276
393
    task wants to be painted.
281
398
    this only prints the stack from the nominated current task up to the root.
282
399
    """
283
400
 
284
 
    def __init__(self, term_file):
 
401
    def __init__(self, term_file, encoding=None, errors=None):
285
402
        self._term_file = term_file
 
403
        if encoding is None:
 
404
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
 
405
        else:
 
406
            self._encoding = encoding
286
407
        # true when there's output on the screen we may need to clear
287
408
        self._have_output = False
288
409
        self._last_transport_msg = ''
297
418
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
298
419
        self._first_byte_time = None
299
420
        self._fraction = 0
300
 
        # force the progress bar to be off, as at the moment it doesn't 
 
421
        # force the progress bar to be off, as at the moment it doesn't
301
422
        # correspond reliably to overall command progress
302
423
        self.enable_bar = False
303
424
 
304
 
    def _show_line(self, s):
305
 
        # sys.stderr.write("progress %r\n" % s)
306
 
        width = osutils.terminal_width()
 
425
    def _avail_width(self):
 
426
        # we need one extra space for terminals that wrap on last char
 
427
        w = osutils.terminal_width()
 
428
        if w is None:
 
429
            return None
 
430
        else:
 
431
            return w - 1
 
432
 
 
433
    def _show_line(self, u):
 
434
        width = self._avail_width()
307
435
        if width is not None:
308
 
            # we need one extra space for terminals that wrap on last char
309
 
            width = width - 1
310
 
            s = '%-*.*s' % (width, width, s)
311
 
        self._term_file.write('\r' + s + '\r')
 
436
            u = pad_to_width(u, width, encoding_hint=self._encoding)
 
437
        self._term_file.write('\r' + u + '\r')
312
438
 
313
439
    def clear(self):
314
440
        if self._have_output:
335
461
                    self._last_task._overall_completion_fraction() or 0
336
462
            if (completion_fraction < self._fraction and 'progress' in
337
463
                debug.debug_flags):
338
 
                import pdb;pdb.set_trace()
 
464
                debug.set_trace()
339
465
            self._fraction = completion_fraction
340
466
            markers = int(round(float(cols) * completion_fraction)) - 1
341
467
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
349
475
            return ''
350
476
 
351
477
    def _format_task(self, task):
 
478
        """Format task-specific parts of progress bar.
 
479
 
 
480
        :returns: (text_part, counter_part) both unicode strings.
 
481
        """
352
482
        if not task.show_count:
353
483
            s = ''
354
484
        elif task.current_cnt is not None and task.total_cnt is not None:
364
494
            t = t._parent_task
365
495
            if t.msg:
366
496
                m = t.msg + ':' + m
367
 
        return m + s
 
497
        return m, s
368
498
 
369
499
    def _render_line(self):
370
500
        bar_string = self._render_bar()
371
501
        if self._last_task:
372
 
            task_msg = self._format_task(self._last_task)
 
502
            task_part, counter_part = self._format_task(self._last_task)
373
503
        else:
374
 
            task_msg = ''
 
504
            task_part = counter_part = ''
375
505
        if self._last_task and not self._last_task.show_transport_activity:
376
506
            trans = ''
377
507
        else:
378
508
            trans = self._last_transport_msg
379
 
            if trans:
380
 
                trans += ' | '
381
 
        return (bar_string + trans + task_msg)
 
509
        # the bar separates the transport activity from the message, so even
 
510
        # if there's no bar or spinner, we must show something if both those
 
511
        # fields are present
 
512
        if (task_part or trans) and not bar_string:
 
513
            bar_string = '| '
 
514
        # preferentially truncate the task message if we don't have enough
 
515
        # space
 
516
        avail_width = self._avail_width()
 
517
        if avail_width is not None:
 
518
            # if terminal avail_width is unknown, don't truncate
 
519
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
520
            # GZ 2017-04-22: Should measure and truncate task_part properly
 
521
            gap = current_len - avail_width
 
522
            if gap > 0:
 
523
                task_part = task_part[:-gap-2] + '..'
 
524
        s = trans + bar_string + task_part + counter_part
 
525
        if avail_width is not None:
 
526
            if len(s) < avail_width:
 
527
                s = s.ljust(avail_width)
 
528
            elif len(s) > avail_width:
 
529
                s = s[:avail_width]
 
530
        return s
382
531
 
383
532
    def _repaint(self):
384
533
        s = self._render_line()
387
536
 
388
537
    def show_progress(self, task):
389
538
        """Called by the task object when it has changed.
390
 
        
391
 
        :param task: The top task object; its parents are also included 
 
539
 
 
540
        :param task: The top task object; its parents are also included
392
541
            by following links.
393
542
        """
394
543
        must_update = task is not self._last_task
440
589
            rate = (self._bytes_since_update
441
590
                    / (now - self._transport_update_time))
442
591
            # using base-10 units (see HACKING.txt).
443
 
            msg = ("%6dkB %5dkB/s" %
 
592
            msg = ("%6dkB %5dkB/s " %
444
593
                    (self._total_byte_count / 1000, int(rate) / 1000,))
445
594
            self._transport_update_time = now
446
595
            self._last_repaint = now
481
630
            self._term_file.write(msg + '\n')
482
631
 
483
632
 
 
633
def _get_stream_encoding(stream):
 
634
    encoding = config.GlobalStack().get('output_encoding')
 
635
    if encoding is None:
 
636
        encoding = getattr(stream, "encoding", None)
 
637
    if encoding is None:
 
638
        encoding = osutils.get_terminal_encoding(trace=True)
 
639
    return encoding
 
640
 
 
641
 
 
642
def _unwrap_stream(stream):
 
643
    inner = getattr(stream, "buffer", None)
 
644
    if inner is None:
 
645
        inner = getattr(stream, "stream", None)
 
646
    return inner
 
647
 
 
648
 
 
649
def _wrap_in_stream(stream, encoding=None, errors='replace'):
 
650
    if encoding is None:
 
651
        encoding = _get_stream_encoding(stream)
 
652
    encoded_stream = codecs.getreader(encoding)(stream, errors=errors)
 
653
    encoded_stream.encoding = encoding
 
654
    return encoded_stream
 
655
 
 
656
 
 
657
def _wrap_out_stream(stream, encoding=None, errors='replace'):
 
658
    if encoding is None:
 
659
        encoding = _get_stream_encoding(stream)
 
660
    encoded_stream = codecs.getwriter(encoding)(stream, errors=errors)
 
661
    encoded_stream.encoding = encoding
 
662
    return encoded_stream
 
663
 
 
664
 
484
665
class TextUIOutputStream(object):
485
 
    """Decorates an output stream so that the terminal is cleared before writing.
486
 
 
487
 
    This is supposed to ensure that the progress bar does not conflict with bulk
488
 
    text output.
 
666
    """Decorates stream to interact better with progress and change encoding.
 
667
 
 
668
    Before writing to the wrapped stream, progress is cleared. Callers must
 
669
    ensure bulk output is terminated with a newline so progress won't overwrite
 
670
    partial lines.
 
671
 
 
672
    Additionally, the encoding and errors behaviour of the underlying stream
 
673
    can be changed at this point. If errors is set to 'exact' raw bytes may be
 
674
    written to the underlying stream.
489
675
    """
490
 
    # XXX: this does not handle the case of writing part of a line, then doing
491
 
    # progress bar output: the progress bar will probably write over it.
492
 
    # one option is just to buffer that text until we have a full line;
493
 
    # another is to save and restore it
494
 
 
495
 
    # XXX: might need to wrap more methods
496
 
 
497
 
    def __init__(self, ui_factory, wrapped_stream):
 
676
 
 
677
    def __init__(self, ui_factory, stream, encoding=None, errors='strict'):
498
678
        self.ui_factory = ui_factory
499
 
        self.wrapped_stream = wrapped_stream
500
 
        # this does no transcoding, but it must expose the underlying encoding
501
 
        # because some callers need to know what can be written - see for
502
 
        # example unescape_for_display.
503
 
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
679
        # GZ 2017-05-21: Clean up semantics when callers are made saner.
 
680
        inner = _unwrap_stream(stream)
 
681
        self.raw_stream = None
 
682
        if errors == "exact":
 
683
            errors = "strict"
 
684
            self.raw_stream = inner
 
685
        if inner is None:
 
686
            self.wrapped_stream = stream
 
687
            if encoding is None:
 
688
                encoding = _get_stream_encoding(stream)
 
689
        else:
 
690
            self.wrapped_stream = _wrap_out_stream(inner, encoding, errors)
 
691
            if encoding is None:
 
692
                encoding = self.wrapped_stream.encoding
 
693
        self.encoding = encoding
 
694
        self.errors = errors
 
695
 
 
696
    def _write(self, to_write):
 
697
        if isinstance(to_write, bytes):
 
698
            try:
 
699
                to_write = to_write.decode(self.encoding, self.errors)
 
700
            except UnicodeDecodeError:
 
701
                self.raw_stream.write(to_write)
 
702
                return
 
703
        self.wrapped_stream.write(to_write)
504
704
 
505
705
    def flush(self):
506
706
        self.ui_factory.clear_term()
508
708
 
509
709
    def write(self, to_write):
510
710
        self.ui_factory.clear_term()
511
 
        self.wrapped_stream.write(to_write)
 
711
        self._write(to_write)
512
712
 
513
713
    def writelines(self, lines):
514
714
        self.ui_factory.clear_term()
515
 
        self.wrapped_stream.writelines(lines)
 
715
        for line in lines:
 
716
            self._write(line)