← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Launchpad Translations on behalf of bzr-core
  • Date: 2013-03-29 04:30:34 UTC
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20130329043034-xbst4001gnhtm0mi
Launchpad automatic translations update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
18
18
"""Text UI, write output to the console.
19
19
"""
20
20
 
21
 
import codecs
22
 
import getpass
 
21
from __future__ import absolute_import
 
22
 
23
23
import os
24
24
import sys
25
25
import time
26
 
import warnings
27
26
 
28
27
from bzrlib.lazy_import import lazy_import
29
28
lazy_import(globals(), """
 
29
import codecs
 
30
import getpass
 
31
import warnings
 
32
 
30
33
from bzrlib import (
31
34
    debug,
32
35
    progress,
33
36
    osutils,
34
 
    symbol_versioning,
35
37
    trace,
36
38
    )
37
39
 
43
45
    )
44
46
 
45
47
 
 
48
class _ChooseUI(object):
 
49
 
 
50
    """ Helper class for choose implementation.
 
51
    """
 
52
 
 
53
    def __init__(self, ui, msg, choices, default):
 
54
        self.ui = ui
 
55
        self._setup_mode()
 
56
        self._build_alternatives(msg, choices, default)
 
57
 
 
58
    def _setup_mode(self):
 
59
        """Setup input mode (line-based, char-based) and echo-back.
 
60
 
 
61
        Line-based input is used if the BZR_TEXTUI_INPUT environment
 
62
        variable is set to 'line-based', or if there is no controlling
 
63
        terminal.
 
64
        """
 
65
        if os.environ.get('BZR_TEXTUI_INPUT') != 'line-based' and \
 
66
           self.ui.stdin == sys.stdin and self.ui.stdin.isatty():
 
67
            self.line_based = False
 
68
            self.echo_back = True
 
69
        else:
 
70
            self.line_based = True
 
71
            self.echo_back = not self.ui.stdin.isatty()
 
72
 
 
73
    def _build_alternatives(self, msg, choices, default):
 
74
        """Parse choices string.
 
75
 
 
76
        Setup final prompt and the lists of choices and associated
 
77
        shortcuts.
 
78
        """
 
79
        index = 0
 
80
        help_list = []
 
81
        self.alternatives = {}
 
82
        choices = choices.split('\n')
 
83
        if default is not None and default not in range(0, len(choices)):
 
84
            raise ValueError("invalid default index")
 
85
        for c in choices:
 
86
            name = c.replace('&', '').lower()
 
87
            choice = (name, index)
 
88
            if name in self.alternatives:
 
89
                raise ValueError("duplicated choice: %s" % name)
 
90
            self.alternatives[name] = choice
 
91
            shortcut = c.find('&')
 
92
            if -1 != shortcut and (shortcut + 1) < len(c):
 
93
                help = c[:shortcut]
 
94
                help += '[' + c[shortcut + 1] + ']'
 
95
                help += c[(shortcut + 2):]
 
96
                shortcut = c[shortcut + 1]
 
97
            else:
 
98
                c = c.replace('&', '')
 
99
                shortcut = c[0]
 
100
                help = '[%s]%s' % (shortcut, c[1:])
 
101
            shortcut = shortcut.lower()
 
102
            if shortcut in self.alternatives:
 
103
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
104
            self.alternatives[shortcut] = choice
 
105
            # Add redirections for default.
 
106
            if index == default:
 
107
                self.alternatives[''] = choice
 
108
                self.alternatives['\r'] = choice
 
109
            help_list.append(help)
 
110
            index += 1
 
111
 
 
112
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
113
 
 
114
    def _getline(self):
 
115
        line = self.ui.stdin.readline()
 
116
        if '' == line:
 
117
            raise EOFError
 
118
        return line.strip()
 
119
 
 
120
    def _getchar(self):
 
121
        char = osutils.getchar()
 
122
        if char == chr(3): # INTR
 
123
            raise KeyboardInterrupt
 
124
        if char == chr(4): # EOF (^d, C-d)
 
125
            raise EOFError
 
126
        return char
 
127
 
 
128
    def interact(self):
 
129
        """Keep asking the user until a valid choice is made.
 
130
        """
 
131
        if self.line_based:
 
132
            getchoice = self._getline
 
133
        else:
 
134
            getchoice = self._getchar
 
135
        iter = 0
 
136
        while True:
 
137
            iter += 1
 
138
            if 1 == iter or self.line_based:
 
139
                self.ui.prompt(self.prompt)
 
140
            try:
 
141
                choice = getchoice()
 
142
            except EOFError:
 
143
                self.ui.stderr.write('\n')
 
144
                return None
 
145
            except KeyboardInterrupt:
 
146
                self.ui.stderr.write('\n')
 
147
                raise KeyboardInterrupt
 
148
            choice = choice.lower()
 
149
            if choice not in self.alternatives:
 
150
                # Not a valid choice, keep on asking.
 
151
                continue
 
152
            name, index = self.alternatives[choice]
 
153
            if self.echo_back:
 
154
                self.ui.stderr.write(name + '\n')
 
155
            return index
 
156
 
 
157
 
46
158
class TextUIFactory(UIFactory):
47
159
    """A UI factory for Text user interefaces."""
48
160
 
61
173
        # paints progress, network activity, etc
62
174
        self._progress_view = self.make_progress_view()
63
175
 
 
176
    def choose(self, msg, choices, default=None):
 
177
        """Prompt the user for a list of alternatives.
 
178
 
 
179
        Support both line-based and char-based editing.
 
180
 
 
181
        In line-based mode, both the shortcut and full choice name are valid
 
182
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
183
        'YES ' are all valid input lines for choosing 'yes'.
 
184
 
 
185
        An empty line, when in line-based mode, or pressing enter in char-based
 
186
        mode will select the default choice (if any).
 
187
 
 
188
        Choice is echoed back if:
 
189
        - input is char-based; which means a controlling terminal is available,
 
190
          and osutils.getchar is used
 
191
        - input is line-based, and no controlling terminal is available
 
192
        """
 
193
 
 
194
        choose_ui = _ChooseUI(self, msg, choices, default)
 
195
        return choose_ui.interact()
 
196
 
64
197
    def be_quiet(self, state):
65
198
        if state and not self._quiet:
66
199
            self.clear_term()
78
211
        # to clear it.  We might need to separately check for the case of
79
212
        self._progress_view.clear()
80
213
 
81
 
    def get_boolean(self, prompt):
82
 
        while True:
83
 
            self.prompt(prompt + "? [y/n]: ")
84
 
            line = self.stdin.readline().lower()
85
 
            if line in ('y\n', 'yes\n'):
86
 
                return True
87
 
            elif line in ('n\n', 'no\n'):
88
 
                return False
89
 
            elif line in ('', None):
90
 
                # end-of-file; possibly should raise an error here instead
91
 
                return None
92
 
 
93
214
    def get_integer(self, prompt):
94
215
        while True:
95
216
            self.prompt(prompt)
114
235
                password = password[:-1]
115
236
        return password
116
237
 
117
 
    def get_password(self, prompt='', **kwargs):
 
238
    def get_password(self, prompt=u'', **kwargs):
118
239
        """Prompt the user for a password.
119
240
 
120
241
        :param prompt: The prompt to present the user
198
319
        :param kwargs: Dictionary of arguments to insert into the prompt,
199
320
            to allow UIs to reformat the prompt.
200
321
        """
 
322
        if type(prompt) != unicode:
 
323
            raise ValueError("prompt %r not a unicode string" % prompt)
201
324
        if kwargs:
202
325
            # See <https://launchpad.net/bugs/365891>
203
326
            prompt = prompt % kwargs
204
327
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
205
328
        self.clear_term()
 
329
        self.stdout.flush()
206
330
        self.stderr.write(prompt)
207
331
 
208
332
    def report_transport_activity(self, transport, byte_count, direction):
280
404
    this only prints the stack from the nominated current task up to the root.
281
405
    """
282
406
 
283
 
    def __init__(self, term_file):
 
407
    def __init__(self, term_file, encoding=None, errors="replace"):
284
408
        self._term_file = term_file
 
409
        if encoding is None:
 
410
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
 
411
        else:
 
412
            self._encoding = encoding
 
413
        self._encoding_errors = errors
285
414
        # true when there's output on the screen we may need to clear
286
415
        self._have_output = False
287
416
        self._last_transport_msg = ''
300
429
        # correspond reliably to overall command progress
301
430
        self.enable_bar = False
302
431
 
303
 
    def _show_line(self, s):
304
 
        # sys.stderr.write("progress %r\n" % s)
305
 
        width = osutils.terminal_width()
 
432
    def _avail_width(self):
 
433
        # we need one extra space for terminals that wrap on last char
 
434
        w = osutils.terminal_width() 
 
435
        if w is None:
 
436
            return None
 
437
        else:
 
438
            return w - 1
 
439
 
 
440
    def _show_line(self, u):
 
441
        s = u.encode(self._encoding, self._encoding_errors)
 
442
        width = self._avail_width()
306
443
        if width is not None:
307
 
            # we need one extra space for terminals that wrap on last char
308
 
            width = width - 1
 
444
            # GZ 2012-03-28: Counting bytes is wrong for calculating width of
 
445
            #                text but better than counting codepoints.
309
446
            s = '%-*.*s' % (width, width, s)
310
447
        self._term_file.write('\r' + s + '\r')
311
448
 
348
485
            return ''
349
486
 
350
487
    def _format_task(self, task):
 
488
        """Format task-specific parts of progress bar.
 
489
 
 
490
        :returns: (text_part, counter_part) both unicode strings.
 
491
        """
351
492
        if not task.show_count:
352
493
            s = ''
353
494
        elif task.current_cnt is not None and task.total_cnt is not None:
363
504
            t = t._parent_task
364
505
            if t.msg:
365
506
                m = t.msg + ':' + m
366
 
        return m + s
 
507
        return m, s
367
508
 
368
509
    def _render_line(self):
369
510
        bar_string = self._render_bar()
370
511
        if self._last_task:
371
 
            task_msg = self._format_task(self._last_task)
 
512
            task_part, counter_part = self._format_task(self._last_task)
372
513
        else:
373
 
            task_msg = ''
 
514
            task_part = counter_part = ''
374
515
        if self._last_task and not self._last_task.show_transport_activity:
375
516
            trans = ''
376
517
        else:
377
518
            trans = self._last_transport_msg
378
 
            if trans:
379
 
                trans += ' | '
380
 
        return (bar_string + trans + task_msg)
 
519
        # the bar separates the transport activity from the message, so even
 
520
        # if there's no bar or spinner, we must show something if both those
 
521
        # fields are present
 
522
        if (task_part or trans) and not bar_string:
 
523
            bar_string = '| '
 
524
        # preferentially truncate the task message if we don't have enough
 
525
        # space
 
526
        avail_width = self._avail_width()
 
527
        if avail_width is not None:
 
528
            # if terminal avail_width is unknown, don't truncate
 
529
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
530
            gap = current_len - avail_width
 
531
            if gap > 0:
 
532
                task_part = task_part[:-gap-2] + '..'
 
533
        s = trans + bar_string + task_part + counter_part
 
534
        if avail_width is not None:
 
535
            if len(s) < avail_width:
 
536
                s = s.ljust(avail_width)
 
537
            elif len(s) > avail_width:
 
538
                s = s[:avail_width]
 
539
        return s
381
540
 
382
541
    def _repaint(self):
383
542
        s = self._render_line()
439
598
            rate = (self._bytes_since_update
440
599
                    / (now - self._transport_update_time))
441
600
            # using base-10 units (see HACKING.txt).
442
 
            msg = ("%6dkB %5dkB/s" %
 
601
            msg = ("%6dkB %5dkB/s " %
443
602
                    (self._total_byte_count / 1000, int(rate) / 1000,))
444
603
            self._transport_update_time = now
445
604
            self._last_repaint = now