/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-06-03 23:48:08 UTC
  • mfrom: (7316 work)
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190603234808-15yk5c7054tj8e2b
Merge trunk.

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