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

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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."""
18
17
 
19
 
from __future__ import absolute_import
 
18
"""Text UI, write output to the console.
 
19
"""
20
20
 
21
21
import codecs
22
 
import io
 
22
import getpass
23
23
import os
24
24
import sys
 
25
import time
25
26
import warnings
26
27
 
27
 
from ..lazy_import import lazy_import
 
28
from bzrlib.lazy_import import lazy_import
28
29
lazy_import(globals(), """
29
 
import getpass
30
 
import time
31
 
 
32
 
from breezy import (
 
30
from bzrlib import (
33
31
    debug,
34
32
    progress,
35
 
    )
36
 
""")
37
 
 
38
 
from .. import (
39
 
    config,
40
33
    osutils,
 
34
    symbol_versioning,
41
35
    trace,
42
36
    )
43
 
from ..sixish import (
44
 
    text_type,
45
 
    )
46
 
from . import (
 
37
 
 
38
""")
 
39
 
 
40
from bzrlib.osutils import watch_sigwinch
 
41
 
 
42
from bzrlib.ui import (
 
43
    UIFactory,
47
44
    NullProgressView,
48
 
    UIFactory,
49
45
    )
50
46
 
51
47
 
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
 
 
171
48
class TextUIFactory(UIFactory):
172
 
    """A UI factory for Text user interfaces."""
 
49
    """A UI factory for Text user interefaces."""
173
50
 
174
 
    def __init__(self, stdin, stdout, stderr):
175
 
        """Create a TextUIFactory."""
 
51
    def __init__(self,
 
52
                 stdin=None,
 
53
                 stdout=None,
 
54
                 stderr=None):
 
55
        """Create a TextUIFactory.
 
56
        """
176
57
        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...
177
60
        self.stdin = stdin
178
61
        self.stdout = stdout
179
62
        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()
185
63
        # paints progress, network activity, etc
186
64
        self._progress_view = self.make_progress_view()
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()
 
65
        # hook up the signals to watch for terminal size changes
 
66
        watch_sigwinch()
217
67
 
218
68
    def be_quiet(self, state):
219
69
        if state and not self._quiet:
232
82
        # to clear it.  We might need to separately check for the case of
233
83
        self._progress_view.clear()
234
84
 
 
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
 
235
97
    def get_integer(self, prompt):
236
98
        while True:
237
99
            self.prompt(prompt)
252
114
            password = self.stdin.readline()
253
115
            if not password:
254
116
                password = None
255
 
            else:
256
 
                if password[-1] == '\n':
257
 
                    password = password[:-1]
 
117
            elif password[-1] == '\n':
 
118
                password = password[:-1]
258
119
        return password
259
120
 
260
 
    def get_password(self, prompt=u'', **kwargs):
 
121
    def get_password(self, prompt='', **kwargs):
261
122
        """Prompt the user for a password.
262
123
 
263
124
        :param prompt: The prompt to present the user
288
149
        username = self.stdin.readline()
289
150
        if not username:
290
151
            username = None
291
 
        else:
292
 
            if username[-1] == '\n':
293
 
                username = username[:-1]
 
152
        elif username[-1] == '\n':
 
153
            username = username[:-1]
294
154
        return username
295
155
 
296
156
    def make_progress_view(self):
297
157
        """Construct and return a new ProgressView subclass for this UI.
298
158
        """
299
159
        # with --quiet, never any progress view
300
 
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
160
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
301
161
        # user specifically requests either text or no progress bars, always
302
162
        # do that.  otherwise, guess based on $TERM and tty presence.
303
163
        if self.is_quiet():
304
164
            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()
 
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()
313
173
 
314
174
    def _make_output_stream_explicit(self, encoding, encoding_type):
315
 
        return TextUIOutputStream(self, self.stdout, 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)
316
193
 
317
194
    def note(self, msg):
318
195
        """Write an already-formatted message, clearing the progress bar if necessary."""
321
198
 
322
199
    def prompt(self, prompt, **kwargs):
323
200
        """Emit prompt on the CLI.
324
 
 
 
201
        
325
202
        :param kwargs: Dictionary of arguments to insert into the prompt,
326
203
            to allow UIs to reformat the prompt.
327
204
        """
328
 
        if not isinstance(prompt, text_type):
329
 
            raise ValueError("prompt %r not a unicode string" % prompt)
330
205
        if kwargs:
331
206
            # See <https://launchpad.net/bugs/365891>
332
207
            prompt = prompt % kwargs
 
208
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
333
209
        self.clear_term()
334
 
        self.stdout.flush()
335
210
        self.stderr.write(prompt)
336
 
        self.stderr.flush()
337
211
 
338
212
    def report_transport_activity(self, transport, byte_count, direction):
339
213
        """Called by transports as they do IO.
342
216
        By default it does nothing.
343
217
        """
344
218
        self._progress_view.show_transport_activity(transport,
345
 
                                                    direction, byte_count)
 
219
            direction, byte_count)
346
220
 
347
221
    def log_transport_activity(self, display=False):
348
222
        """See UIFactory.log_transport_activity()"""
366
240
        """
367
241
        if not self._task_stack:
368
242
            warnings.warn("%r updated but no tasks are active" %
369
 
                          (task,))
 
243
                (task,))
370
244
        elif task != self._task_stack[-1]:
371
245
            # We used to check it was the top task, but it's hard to always
372
246
            # get this right and it's not necessarily useful: any actual
373
247
            # problems will be evident in use
374
 
            # warnings.warn("%r is not the top progress task %r" %
 
248
            #warnings.warn("%r is not the top progress task %r" %
375
249
            #     (task, self._task_stack[-1]))
376
250
            pass
377
251
        self._progress_view.show_progress(task)
388
262
        # be easier to test; that has a lot of test fallout so for now just
389
263
        # new code can call this
390
264
        if warning_id not in self.suppressed_warnings:
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)
 
265
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
 
266
                '\n')
403
267
 
404
268
 
405
269
class TextProgressView(object):
406
270
    """Display of progress bar and other information on a tty.
407
271
 
408
 
    This shows one line of text, including possibly a network indicator,
409
 
    spinner, progress bar, message, etc.
 
272
    This shows one line of text, including possibly a network indicator, spinner,
 
273
    progress bar, message, etc.
410
274
 
411
275
    One instance of this is created and held by the UI, and fed updates when a
412
276
    task wants to be painted.
417
281
    this only prints the stack from the nominated current task up to the root.
418
282
    """
419
283
 
420
 
    def __init__(self, term_file, encoding=None, errors=None):
 
284
    def __init__(self, term_file):
421
285
        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
426
286
        # true when there's output on the screen we may need to clear
427
287
        self._have_output = False
428
288
        self._last_transport_msg = ''
437
297
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
438
298
        self._first_byte_time = None
439
299
        self._fraction = 0
440
 
        # force the progress bar to be off, as at the moment it doesn't
 
300
        # force the progress bar to be off, as at the moment it doesn't 
441
301
        # correspond reliably to overall command progress
442
302
        self.enable_bar = False
443
303
 
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()
 
304
    def _show_line(self, s):
 
305
        # sys.stderr.write("progress %r\n" % s)
 
306
        width = osutils.terminal_width()
454
307
        if width is not None:
455
 
            u = pad_to_width(u, width, encoding_hint=self._encoding)
456
 
        self._term_file.write('\r' + u + '\r')
 
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')
457
312
 
458
313
    def clear(self):
459
314
        if self._have_output:
463
318
    def _render_bar(self):
464
319
        # return a string for the progress bar itself
465
320
        if self.enable_bar and (
466
 
                (self._last_task is None) or self._last_task.show_bar):
 
321
            (self._last_task is None) or self._last_task.show_bar):
467
322
            # If there's no task object, we show space for the bar anyhow.
468
323
            # That's because most invocations of bzr will end showing progress
469
324
            # at some point, though perhaps only after doing some initial IO.
470
325
            # It looks better to draw the progress bar initially rather than
471
326
            # to have what looks like an incomplete progress bar.
472
 
            spin_str = r'/-\|'[self._spin_pos % 4]
 
327
            spin_str =  r'/-\|'[self._spin_pos % 4]
473
328
            self._spin_pos += 1
474
329
            cols = 20
475
330
            if self._last_task is None:
479
334
                completion_fraction = \
480
335
                    self._last_task._overall_completion_fraction() or 0
481
336
            if (completion_fraction < self._fraction and 'progress' in
482
 
                    debug.debug_flags):
483
 
                debug.set_trace()
 
337
                debug.debug_flags):
 
338
                import pdb;pdb.set_trace()
484
339
            self._fraction = completion_fraction
485
340
            markers = int(round(float(cols) * completion_fraction)) - 1
486
341
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
487
342
            return bar_str
488
343
        elif (self._last_task is None) or self._last_task.show_spinner:
489
344
            # The last task wanted just a spinner, no bar
490
 
            spin_str = r'/-\|'[self._spin_pos % 4]
 
345
            spin_str =  r'/-\|'[self._spin_pos % 4]
491
346
            self._spin_pos += 1
492
347
            return spin_str + ' '
493
348
        else:
494
349
            return ''
495
350
 
496
351
    def _format_task(self, task):
497
 
        """Format task-specific parts of progress bar.
498
 
 
499
 
        :returns: (text_part, counter_part) both unicode strings.
500
 
        """
501
352
        if not task.show_count:
502
353
            s = ''
503
354
        elif task.current_cnt is not None and task.total_cnt is not None:
513
364
            t = t._parent_task
514
365
            if t.msg:
515
366
                m = t.msg + ':' + m
516
 
        return m, s
 
367
        return m + s
517
368
 
518
369
    def _render_line(self):
519
370
        bar_string = self._render_bar()
520
371
        if self._last_task:
521
 
            task_part, counter_part = self._format_task(self._last_task)
 
372
            task_msg = self._format_task(self._last_task)
522
373
        else:
523
 
            task_part = counter_part = ''
 
374
            task_msg = ''
524
375
        if self._last_task and not self._last_task.show_transport_activity:
525
376
            trans = ''
526
377
        else:
527
378
            trans = self._last_transport_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
 
379
            if trans:
 
380
                trans += ' | '
 
381
        return (bar_string + trans + task_msg)
551
382
 
552
383
    def _repaint(self):
553
384
        s = self._render_line()
556
387
 
557
388
    def show_progress(self, task):
558
389
        """Called by the task object when it has changed.
559
 
 
560
 
        :param task: The top task object; its parents are also included
 
390
        
 
391
        :param task: The top task object; its parents are also included 
561
392
            by following links.
562
393
        """
563
394
        must_update = task is not self._last_task
606
437
        elif now >= (self._transport_update_time + 0.5):
607
438
            # guard against clock stepping backwards, and don't update too
608
439
            # often
609
 
            rate = (self._bytes_since_update /
610
 
                    (now - self._transport_update_time))
 
440
            rate = (self._bytes_since_update
 
441
                    / (now - self._transport_update_time))
611
442
            # using base-10 units (see HACKING.txt).
612
 
            msg = ("%6dkB %5dkB/s " %
613
 
                   (self._total_byte_count / 1000, int(rate) / 1000,))
 
443
            msg = ("%6dkB %5dkB/s" %
 
444
                    (self._total_byte_count / 1000, int(rate) / 1000,))
614
445
            self._transport_update_time = now
615
446
            self._last_repaint = now
616
447
            self._bytes_since_update = 0
633
464
                  bps / 1000.,
634
465
                  self._bytes_by_direction['read'] / 1000.,
635
466
                  self._bytes_by_direction['write'] / 1000.,
636
 
                  ))
 
467
                 ))
637
468
        if self._bytes_by_direction['unknown'] > 0:
638
469
            msg += ' u:%.0fkB)' % (
639
470
                self._bytes_by_direction['unknown'] / 1000.
650
481
            self._term_file.write(msg + '\n')
651
482
 
652
483
 
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
 
 
692
484
class TextUIOutputStream(object):
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.
 
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.
702
489
    """
703
 
 
704
 
    def __init__(self, ui_factory, stream, encoding=None, errors='strict'):
 
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):
705
498
        self.ui_factory = ui_factory
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)
 
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)
731
504
 
732
505
    def flush(self):
733
506
        self.ui_factory.clear_term()
735
508
 
736
509
    def write(self, to_write):
737
510
        self.ui_factory.clear_term()
738
 
        self._write(to_write)
 
511
        self.wrapped_stream.write(to_write)
739
512
 
740
513
    def writelines(self, lines):
741
514
        self.ui_factory.clear_term()
742
 
        for line in lines:
743
 
            self._write(line)
 
515
        self.wrapped_stream.writelines(lines)