/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: 2019-02-04 01:01:24 UTC
  • mto: This revision was merged to the branch mainline in revision 7268.
  • Revision ID: jelmer@jelmer.uk-20190204010124-ni0i4qc6f5tnbvux
Fix source tests.

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
        is_tty = self.ui.raw_stdin.isatty()
 
69
        if (os.environ.get('BRZ_TEXTUI_INPUT') != 'line-based' and
 
70
                self.ui.raw_stdin == _unwrap_stream(sys.stdin) and is_tty):
 
71
            self.line_based = False
 
72
            self.echo_back = True
 
73
        else:
 
74
            self.line_based = True
 
75
            self.echo_back = not is_tty
 
76
 
 
77
    def _build_alternatives(self, msg, choices, default):
 
78
        """Parse choices string.
 
79
 
 
80
        Setup final prompt and the lists of choices and associated
 
81
        shortcuts.
 
82
        """
 
83
        index = 0
 
84
        help_list = []
 
85
        self.alternatives = {}
 
86
        choices = choices.split('\n')
 
87
        if default is not None and default not in range(0, len(choices)):
 
88
            raise ValueError("invalid default index")
 
89
        for c in choices:
 
90
            name = c.replace('&', '').lower()
 
91
            choice = (name, index)
 
92
            if name in self.alternatives:
 
93
                raise ValueError("duplicated choice: %s" % name)
 
94
            self.alternatives[name] = choice
 
95
            shortcut = c.find('&')
 
96
            if -1 != shortcut and (shortcut + 1) < len(c):
 
97
                help = c[:shortcut]
 
98
                help += '[' + c[shortcut + 1] + ']'
 
99
                help += c[(shortcut + 2):]
 
100
                shortcut = c[shortcut + 1]
 
101
            else:
 
102
                c = c.replace('&', '')
 
103
                shortcut = c[0]
 
104
                help = '[%s]%s' % (shortcut, c[1:])
 
105
            shortcut = shortcut.lower()
 
106
            if shortcut in self.alternatives:
 
107
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
108
            self.alternatives[shortcut] = choice
 
109
            # Add redirections for default.
 
110
            if index == default:
 
111
                self.alternatives[''] = choice
 
112
                self.alternatives['\r'] = choice
 
113
            help_list.append(help)
 
114
            index += 1
 
115
 
 
116
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
117
 
 
118
    def _getline(self):
 
119
        line = self.ui.stdin.readline()
 
120
        if '' == line:
 
121
            raise EOFError
 
122
        return line.strip()
 
123
 
 
124
    def _getchar(self):
 
125
        char = osutils.getchar()
 
126
        if char == chr(3):  # INTR
 
127
            raise KeyboardInterrupt
 
128
        if char == chr(4):  # EOF (^d, C-d)
 
129
            raise EOFError
 
130
        if isinstance(char, bytes):
 
131
            return char.decode('ascii', 'replace')
 
132
        return char
 
133
 
 
134
    def interact(self):
 
135
        """Keep asking the user until a valid choice is made.
 
136
        """
 
137
        if self.line_based:
 
138
            getchoice = self._getline
 
139
        else:
 
140
            getchoice = self._getchar
 
141
        iter = 0
 
142
        while True:
 
143
            iter += 1
 
144
            if 1 == iter or self.line_based:
 
145
                self.ui.prompt(self.prompt)
 
146
            try:
 
147
                choice = getchoice()
 
148
            except EOFError:
 
149
                self.ui.stderr.write(u'\n')
 
150
                return None
 
151
            except KeyboardInterrupt:
 
152
                self.ui.stderr.write(u'\n')
 
153
                raise
 
154
            choice = choice.lower()
 
155
            if choice not in self.alternatives:
 
156
                # Not a valid choice, keep on asking.
 
157
                continue
 
158
            name, index = self.alternatives[choice]
 
159
            if self.echo_back:
 
160
                self.ui.stderr.write(name + u'\n')
 
161
            return index
 
162
 
 
163
 
 
164
opt_progress_bar = config.Option(
 
165
    'progress_bar', help='Progress bar type.',
 
166
    default_from_env=['BRZ_PROGRESS_BAR'], default=None,
 
167
    invalid='error')
 
168
 
 
169
 
48
170
class TextUIFactory(UIFactory):
49
 
    """A UI factory for Text user interefaces."""
 
171
    """A UI factory for Text user interfaces."""
50
172
 
51
 
    def __init__(self,
52
 
                 stdin=None,
53
 
                 stdout=None,
54
 
                 stderr=None):
55
 
        """Create a TextUIFactory.
56
 
        """
 
173
    def __init__(self, stdin, stdout, stderr):
 
174
        """Create a TextUIFactory."""
57
175
        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
176
        self.stdin = stdin
61
177
        self.stdout = stdout
62
178
        self.stderr = stderr
 
179
        self._progress_view = NullProgressView()
 
180
 
 
181
    def __enter__(self):
 
182
        # Choose default encoding and handle py2/3 differences
 
183
        self._setup_streams()
63
184
        # paints progress, network activity, etc
64
185
        self._progress_view = self.make_progress_view()
65
 
        # hook up the signals to watch for terminal size changes
66
 
        watch_sigwinch()
 
186
        return self
 
187
 
 
188
    def _setup_streams(self):
 
189
        self.raw_stdin = _unwrap_stream(self.stdin)
 
190
        self.stdin = _wrap_in_stream(self.raw_stdin)
 
191
        self.raw_stdout = _unwrap_stream(self.stdout)
 
192
        self.stdout = _wrap_out_stream(self.raw_stdout)
 
193
        self.raw_stderr = _unwrap_stream(self.stderr)
 
194
        self.stderr = _wrap_out_stream(self.raw_stderr)
 
195
 
 
196
    def choose(self, msg, choices, default=None):
 
197
        """Prompt the user for a list of alternatives.
 
198
 
 
199
        Support both line-based and char-based editing.
 
200
 
 
201
        In line-based mode, both the shortcut and full choice name are valid
 
202
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
203
        'YES ' are all valid input lines for choosing 'yes'.
 
204
 
 
205
        An empty line, when in line-based mode, or pressing enter in char-based
 
206
        mode will select the default choice (if any).
 
207
 
 
208
        Choice is echoed back if:
 
209
        - input is char-based; which means a controlling terminal is available,
 
210
          and osutils.getchar is used
 
211
        - input is line-based, and no controlling terminal is available
 
212
        """
 
213
 
 
214
        choose_ui = _ChooseUI(self, msg, choices, default)
 
215
        return choose_ui.interact()
67
216
 
68
217
    def be_quiet(self, state):
69
218
        if state and not self._quiet:
82
231
        # to clear it.  We might need to separately check for the case of
83
232
        self._progress_view.clear()
84
233
 
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
234
    def get_integer(self, prompt):
98
235
        while True:
99
236
            self.prompt(prompt)
114
251
            password = self.stdin.readline()
115
252
            if not password:
116
253
                password = None
117
 
            elif password[-1] == '\n':
118
 
                password = password[:-1]
 
254
            else:
 
255
                if password[-1] == '\n':
 
256
                    password = password[:-1]
119
257
        return password
120
258
 
121
 
    def get_password(self, prompt='', **kwargs):
 
259
    def get_password(self, prompt=u'', **kwargs):
122
260
        """Prompt the user for a password.
123
261
 
124
262
        :param prompt: The prompt to present the user
149
287
        username = self.stdin.readline()
150
288
        if not username:
151
289
            username = None
152
 
        elif username[-1] == '\n':
153
 
            username = username[:-1]
 
290
        else:
 
291
            if username[-1] == '\n':
 
292
                username = username[:-1]
154
293
        return username
155
294
 
156
295
    def make_progress_view(self):
157
296
        """Construct and return a new ProgressView subclass for this UI.
158
297
        """
159
298
        # with --quiet, never any progress view
160
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
299
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
161
300
        # user specifically requests either text or no progress bars, always
162
301
        # do that.  otherwise, guess based on $TERM and tty presence.
163
302
        if self.is_quiet():
164
303
            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()
 
304
        pb_type = config.GlobalStack().get('progress_bar')
 
305
        if pb_type == 'none':  # Explicit requirement
 
306
            return NullProgressView()
 
307
        if (pb_type == 'text' or # Explicit requirement
 
308
                progress._supports_progress(self.stderr)):  # Guess
 
309
            return TextProgressView(self.stderr)
 
310
        # No explicit requirement and no successful guess
 
311
        return NullProgressView()
173
312
 
174
313
    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)
 
314
        return TextUIOutputStream(self, self.stdout, encoding, encoding_type)
193
315
 
194
316
    def note(self, msg):
195
317
        """Write an already-formatted message, clearing the progress bar if necessary."""
198
320
 
199
321
    def prompt(self, prompt, **kwargs):
200
322
        """Emit prompt on the CLI.
201
 
        
 
323
 
202
324
        :param kwargs: Dictionary of arguments to insert into the prompt,
203
325
            to allow UIs to reformat the prompt.
204
326
        """
 
327
        if not isinstance(prompt, text_type):
 
328
            raise ValueError("prompt %r not a unicode string" % prompt)
205
329
        if kwargs:
206
330
            # See <https://launchpad.net/bugs/365891>
207
331
            prompt = prompt % kwargs
208
 
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
209
332
        self.clear_term()
 
333
        self.stdout.flush()
210
334
        self.stderr.write(prompt)
 
335
        self.stderr.flush()
211
336
 
212
337
    def report_transport_activity(self, transport, byte_count, direction):
213
338
        """Called by transports as they do IO.
216
341
        By default it does nothing.
217
342
        """
218
343
        self._progress_view.show_transport_activity(transport,
219
 
            direction, byte_count)
 
344
                                                    direction, byte_count)
220
345
 
221
346
    def log_transport_activity(self, display=False):
222
347
        """See UIFactory.log_transport_activity()"""
240
365
        """
241
366
        if not self._task_stack:
242
367
            warnings.warn("%r updated but no tasks are active" %
243
 
                (task,))
 
368
                          (task,))
244
369
        elif task != self._task_stack[-1]:
245
370
            # We used to check it was the top task, but it's hard to always
246
371
            # get this right and it's not necessarily useful: any actual
247
372
            # problems will be evident in use
248
 
            #warnings.warn("%r is not the top progress task %r" %
 
373
            # warnings.warn("%r is not the top progress task %r" %
249
374
            #     (task, self._task_stack[-1]))
250
375
            pass
251
376
        self._progress_view.show_progress(task)
262
387
        # be easier to test; that has a lot of test fallout so for now just
263
388
        # new code can call this
264
389
        if warning_id not in self.suppressed_warnings:
265
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
266
 
                '\n')
 
390
            warning = self.format_user_warning(warning_id, message_args)
 
391
            self.stderr.write(warning + '\n')
 
392
 
 
393
 
 
394
def pad_to_width(line, width, encoding_hint='ascii'):
 
395
    """Truncate or pad unicode line to width.
 
396
 
 
397
    This is best-effort for now, and strings containing control codes or
 
398
    non-ascii text may be cut and padded incorrectly.
 
399
    """
 
400
    s = line.encode(encoding_hint, 'replace')
 
401
    return (b'%-*.*s' % (width, width, s)).decode(encoding_hint)
267
402
 
268
403
 
269
404
class TextProgressView(object):
270
405
    """Display of progress bar and other information on a tty.
271
406
 
272
 
    This shows one line of text, including possibly a network indicator, spinner,
273
 
    progress bar, message, etc.
 
407
    This shows one line of text, including possibly a network indicator,
 
408
    spinner, progress bar, message, etc.
274
409
 
275
410
    One instance of this is created and held by the UI, and fed updates when a
276
411
    task wants to be painted.
281
416
    this only prints the stack from the nominated current task up to the root.
282
417
    """
283
418
 
284
 
    def __init__(self, term_file):
 
419
    def __init__(self, term_file, encoding=None, errors=None):
285
420
        self._term_file = term_file
 
421
        if encoding is None:
 
422
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
 
423
        else:
 
424
            self._encoding = encoding
286
425
        # true when there's output on the screen we may need to clear
287
426
        self._have_output = False
288
427
        self._last_transport_msg = ''
297
436
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
298
437
        self._first_byte_time = None
299
438
        self._fraction = 0
300
 
        # force the progress bar to be off, as at the moment it doesn't 
 
439
        # force the progress bar to be off, as at the moment it doesn't
301
440
        # correspond reliably to overall command progress
302
441
        self.enable_bar = False
303
442
 
304
 
    def _show_line(self, s):
305
 
        # sys.stderr.write("progress %r\n" % s)
306
 
        width = osutils.terminal_width()
 
443
    def _avail_width(self):
 
444
        # we need one extra space for terminals that wrap on last char
 
445
        w = osutils.terminal_width()
 
446
        if w is None:
 
447
            return None
 
448
        else:
 
449
            return w - 1
 
450
 
 
451
    def _show_line(self, u):
 
452
        width = self._avail_width()
307
453
        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')
 
454
            u = pad_to_width(u, width, encoding_hint=self._encoding)
 
455
        self._term_file.write('\r' + u + '\r')
312
456
 
313
457
    def clear(self):
314
458
        if self._have_output:
318
462
    def _render_bar(self):
319
463
        # return a string for the progress bar itself
320
464
        if self.enable_bar and (
321
 
            (self._last_task is None) or self._last_task.show_bar):
 
465
                (self._last_task is None) or self._last_task.show_bar):
322
466
            # If there's no task object, we show space for the bar anyhow.
323
467
            # That's because most invocations of bzr will end showing progress
324
468
            # at some point, though perhaps only after doing some initial IO.
325
469
            # It looks better to draw the progress bar initially rather than
326
470
            # to have what looks like an incomplete progress bar.
327
 
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
471
            spin_str = r'/-\|'[self._spin_pos % 4]
328
472
            self._spin_pos += 1
329
473
            cols = 20
330
474
            if self._last_task is None:
334
478
                completion_fraction = \
335
479
                    self._last_task._overall_completion_fraction() or 0
336
480
            if (completion_fraction < self._fraction and 'progress' in
337
 
                debug.debug_flags):
338
 
                import pdb;pdb.set_trace()
 
481
                    debug.debug_flags):
 
482
                debug.set_trace()
339
483
            self._fraction = completion_fraction
340
484
            markers = int(round(float(cols) * completion_fraction)) - 1
341
485
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
342
486
            return bar_str
343
487
        elif (self._last_task is None) or self._last_task.show_spinner:
344
488
            # The last task wanted just a spinner, no bar
345
 
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
489
            spin_str = r'/-\|'[self._spin_pos % 4]
346
490
            self._spin_pos += 1
347
491
            return spin_str + ' '
348
492
        else:
349
493
            return ''
350
494
 
351
495
    def _format_task(self, task):
 
496
        """Format task-specific parts of progress bar.
 
497
 
 
498
        :returns: (text_part, counter_part) both unicode strings.
 
499
        """
352
500
        if not task.show_count:
353
501
            s = ''
354
502
        elif task.current_cnt is not None and task.total_cnt is not None:
364
512
            t = t._parent_task
365
513
            if t.msg:
366
514
                m = t.msg + ':' + m
367
 
        return m + s
 
515
        return m, s
368
516
 
369
517
    def _render_line(self):
370
518
        bar_string = self._render_bar()
371
519
        if self._last_task:
372
 
            task_msg = self._format_task(self._last_task)
 
520
            task_part, counter_part = self._format_task(self._last_task)
373
521
        else:
374
 
            task_msg = ''
 
522
            task_part = counter_part = ''
375
523
        if self._last_task and not self._last_task.show_transport_activity:
376
524
            trans = ''
377
525
        else:
378
526
            trans = self._last_transport_msg
379
 
            if trans:
380
 
                trans += ' | '
381
 
        return (bar_string + trans + task_msg)
 
527
        # the bar separates the transport activity from the message, so even
 
528
        # if there's no bar or spinner, we must show something if both those
 
529
        # fields are present
 
530
        if (task_part or trans) and not bar_string:
 
531
            bar_string = '| '
 
532
        # preferentially truncate the task message if we don't have enough
 
533
        # space
 
534
        avail_width = self._avail_width()
 
535
        if avail_width is not None:
 
536
            # if terminal avail_width is unknown, don't truncate
 
537
            current_len = len(bar_string) + len(trans) + \
 
538
                len(task_part) + len(counter_part)
 
539
            # GZ 2017-04-22: Should measure and truncate task_part properly
 
540
            gap = current_len - avail_width
 
541
            if gap > 0:
 
542
                task_part = task_part[:-gap - 2] + '..'
 
543
        s = trans + bar_string + task_part + counter_part
 
544
        if avail_width is not None:
 
545
            if len(s) < avail_width:
 
546
                s = s.ljust(avail_width)
 
547
            elif len(s) > avail_width:
 
548
                s = s[:avail_width]
 
549
        return s
382
550
 
383
551
    def _repaint(self):
384
552
        s = self._render_line()
387
555
 
388
556
    def show_progress(self, task):
389
557
        """Called by the task object when it has changed.
390
 
        
391
 
        :param task: The top task object; its parents are also included 
 
558
 
 
559
        :param task: The top task object; its parents are also included
392
560
            by following links.
393
561
        """
394
562
        must_update = task is not self._last_task
437
605
        elif now >= (self._transport_update_time + 0.5):
438
606
            # guard against clock stepping backwards, and don't update too
439
607
            # often
440
 
            rate = (self._bytes_since_update
441
 
                    / (now - self._transport_update_time))
 
608
            rate = (self._bytes_since_update /
 
609
                    (now - self._transport_update_time))
442
610
            # using base-10 units (see HACKING.txt).
443
 
            msg = ("%6dkB %5dkB/s" %
444
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
611
            msg = ("%6dkB %5dkB/s " %
 
612
                   (self._total_byte_count / 1000, int(rate) / 1000,))
445
613
            self._transport_update_time = now
446
614
            self._last_repaint = now
447
615
            self._bytes_since_update = 0
464
632
                  bps / 1000.,
465
633
                  self._bytes_by_direction['read'] / 1000.,
466
634
                  self._bytes_by_direction['write'] / 1000.,
467
 
                 ))
 
635
                  ))
468
636
        if self._bytes_by_direction['unknown'] > 0:
469
637
            msg += ' u:%.0fkB)' % (
470
638
                self._bytes_by_direction['unknown'] / 1000.
481
649
            self._term_file.write(msg + '\n')
482
650
 
483
651
 
 
652
def _get_stream_encoding(stream):
 
653
    encoding = config.GlobalStack().get('output_encoding')
 
654
    if encoding is None:
 
655
        encoding = getattr(stream, "encoding", None)
 
656
    if encoding is None:
 
657
        encoding = osutils.get_terminal_encoding(trace=True)
 
658
    return encoding
 
659
 
 
660
 
 
661
def _unwrap_stream(stream):
 
662
    inner = getattr(stream, "buffer", None)
 
663
    if inner is None:
 
664
        inner = getattr(stream, "stream", stream)
 
665
    return inner
 
666
 
 
667
 
 
668
def _wrap_in_stream(stream, encoding=None, errors='replace'):
 
669
    if encoding is None:
 
670
        encoding = _get_stream_encoding(stream)
 
671
    encoded_stream = codecs.getreader(encoding)(stream, errors=errors)
 
672
    encoded_stream.encoding = encoding
 
673
    return encoded_stream
 
674
 
 
675
 
 
676
def _wrap_out_stream(stream, encoding=None, errors='replace'):
 
677
    if encoding is None:
 
678
        encoding = _get_stream_encoding(stream)
 
679
    encoded_stream = codecs.getwriter(encoding)(stream, errors=errors)
 
680
    encoded_stream.encoding = encoding
 
681
    return encoded_stream
 
682
 
 
683
 
484
684
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.
 
685
    """Decorates stream to interact better with progress and change encoding.
 
686
 
 
687
    Before writing to the wrapped stream, progress is cleared. Callers must
 
688
    ensure bulk output is terminated with a newline so progress won't overwrite
 
689
    partial lines.
 
690
 
 
691
    Additionally, the encoding and errors behaviour of the underlying stream
 
692
    can be changed at this point. If errors is set to 'exact' raw bytes may be
 
693
    written to the underlying stream.
489
694
    """
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):
 
695
 
 
696
    def __init__(self, ui_factory, stream, encoding=None, errors='strict'):
498
697
        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)
 
698
        # GZ 2017-05-21: Clean up semantics when callers are made saner.
 
699
        inner = _unwrap_stream(stream)
 
700
        self.raw_stream = None
 
701
        if errors == "exact":
 
702
            errors = "strict"
 
703
            self.raw_stream = inner
 
704
        if inner is None:
 
705
            self.wrapped_stream = stream
 
706
            if encoding is None:
 
707
                encoding = _get_stream_encoding(stream)
 
708
        else:
 
709
            self.wrapped_stream = _wrap_out_stream(inner, encoding, errors)
 
710
            if encoding is None:
 
711
                encoding = self.wrapped_stream.encoding
 
712
        self.encoding = encoding
 
713
        self.errors = errors
 
714
 
 
715
    def _write(self, to_write):
 
716
        if isinstance(to_write, bytes):
 
717
            try:
 
718
                to_write = to_write.decode(self.encoding, self.errors)
 
719
            except UnicodeDecodeError:
 
720
                self.raw_stream.write(to_write)
 
721
                return
 
722
        self.wrapped_stream.write(to_write)
504
723
 
505
724
    def flush(self):
506
725
        self.ui_factory.clear_term()
508
727
 
509
728
    def write(self, to_write):
510
729
        self.ui_factory.clear_term()
511
 
        self.wrapped_stream.write(to_write)
 
730
        self._write(to_write)
512
731
 
513
732
    def writelines(self, lines):
514
733
        self.ui_factory.clear_term()
515
 
        self.wrapped_stream.writelines(lines)
 
734
        for line in lines:
 
735
            self._write(line)