← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-05 14:12:23 UTC
  • mto: This revision was merged to the branch mainline in revision 6348.
  • Revision ID: jelmer@samba.org-20111205141223-8qxae4h37satlzgq
Move more functionality to vf_search.

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
23
21
import os
24
22
import sys
25
23
import time
26
 
import warnings
27
24
 
28
25
from bzrlib.lazy_import import lazy_import
29
26
lazy_import(globals(), """
 
27
import codecs
 
28
import getpass
 
29
import warnings
 
30
 
30
31
from bzrlib import (
31
32
    debug,
32
33
    progress,
33
34
    osutils,
34
 
    symbol_versioning,
35
35
    trace,
36
36
    )
37
37
 
38
38
""")
39
39
 
40
 
from bzrlib.osutils import watch_sigwinch
41
 
 
42
40
from bzrlib.ui import (
43
41
    UIFactory,
44
42
    NullProgressView,
45
43
    )
46
44
 
47
45
 
 
46
class _ChooseUI(object):
 
47
 
 
48
    """ Helper class for choose implementation.
 
49
    """
 
50
 
 
51
    def __init__(self, ui, msg, choices, default):
 
52
        self.ui = ui
 
53
        self._setup_mode()
 
54
        self._build_alternatives(msg, choices, default)
 
55
 
 
56
    def _setup_mode(self):
 
57
        """Setup input mode (line-based, char-based) and echo-back.
 
58
 
 
59
        Line-based input is used if the BZR_TEXTUI_INPUT environment
 
60
        variable is set to 'line-based', or if there is no controlling
 
61
        terminal.
 
62
        """
 
63
        if os.environ.get('BZR_TEXTUI_INPUT') != 'line-based' and \
 
64
           self.ui.stdin == sys.stdin and self.ui.stdin.isatty():
 
65
            self.line_based = False
 
66
            self.echo_back = True
 
67
        else:
 
68
            self.line_based = True
 
69
            self.echo_back = not self.ui.stdin.isatty()
 
70
 
 
71
    def _build_alternatives(self, msg, choices, default):
 
72
        """Parse choices string.
 
73
 
 
74
        Setup final prompt and the lists of choices and associated
 
75
        shortcuts.
 
76
        """
 
77
        index = 0
 
78
        help_list = []
 
79
        self.alternatives = {}
 
80
        choices = choices.split('\n')
 
81
        if default is not None and default not in range(0, len(choices)):
 
82
            raise ValueError("invalid default index")
 
83
        for c in choices:
 
84
            name = c.replace('&', '').lower()
 
85
            choice = (name, index)
 
86
            if name in self.alternatives:
 
87
                raise ValueError("duplicated choice: %s" % name)
 
88
            self.alternatives[name] = choice
 
89
            shortcut = c.find('&')
 
90
            if -1 != shortcut and (shortcut + 1) < len(c):
 
91
                help = c[:shortcut]
 
92
                help += '[' + c[shortcut + 1] + ']'
 
93
                help += c[(shortcut + 2):]
 
94
                shortcut = c[shortcut + 1]
 
95
            else:
 
96
                c = c.replace('&', '')
 
97
                shortcut = c[0]
 
98
                help = '[%s]%s' % (shortcut, c[1:])
 
99
            shortcut = shortcut.lower()
 
100
            if shortcut in self.alternatives:
 
101
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
102
            self.alternatives[shortcut] = choice
 
103
            # Add redirections for default.
 
104
            if index == default:
 
105
                self.alternatives[''] = choice
 
106
                self.alternatives['\r'] = choice
 
107
            help_list.append(help)
 
108
            index += 1
 
109
 
 
110
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
111
 
 
112
    def _getline(self):
 
113
        line = self.ui.stdin.readline()
 
114
        if '' == line:
 
115
            raise EOFError
 
116
        return line.strip()
 
117
 
 
118
    def _getchar(self):
 
119
        char = osutils.getchar()
 
120
        if char == chr(3): # INTR
 
121
            raise KeyboardInterrupt
 
122
        if char == chr(4): # EOF (^d, C-d)
 
123
            raise EOFError
 
124
        return char
 
125
 
 
126
    def interact(self):
 
127
        """Keep asking the user until a valid choice is made.
 
128
        """
 
129
        if self.line_based:
 
130
            getchoice = self._getline
 
131
        else:
 
132
            getchoice = self._getchar
 
133
        iter = 0
 
134
        while True:
 
135
            iter += 1
 
136
            if 1 == iter or self.line_based:
 
137
                self.ui.prompt(self.prompt)
 
138
            try:
 
139
                choice = getchoice()
 
140
            except EOFError:
 
141
                self.ui.stderr.write('\n')
 
142
                return None
 
143
            except KeyboardInterrupt:
 
144
                self.ui.stderr.write('\n')
 
145
                raise KeyboardInterrupt
 
146
            choice = choice.lower()
 
147
            if choice not in self.alternatives:
 
148
                # Not a valid choice, keep on asking.
 
149
                continue
 
150
            name, index = self.alternatives[choice]
 
151
            if self.echo_back:
 
152
                self.ui.stderr.write(name + '\n')
 
153
            return index
 
154
 
 
155
 
48
156
class TextUIFactory(UIFactory):
49
157
    """A UI factory for Text user interefaces."""
50
158
 
62
170
        self.stderr = stderr
63
171
        # paints progress, network activity, etc
64
172
        self._progress_view = self.make_progress_view()
65
 
        # hook up the signals to watch for terminal size changes
66
 
        watch_sigwinch()
 
173
 
 
174
    def choose(self, msg, choices, default=None):
 
175
        """Prompt the user for a list of alternatives.
 
176
 
 
177
        Support both line-based and char-based editing.
 
178
 
 
179
        In line-based mode, both the shortcut and full choice name are valid
 
180
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
181
        'YES ' are all valid input lines for choosing 'yes'.
 
182
 
 
183
        An empty line, when in line-based mode, or pressing enter in char-based
 
184
        mode will select the default choice (if any).
 
185
 
 
186
        Choice is echoed back if:
 
187
        - input is char-based; which means a controlling terminal is available,
 
188
          and osutils.getchar is used
 
189
        - input is line-based, and no controlling terminal is available
 
190
        """
 
191
 
 
192
        choose_ui = _ChooseUI(self, msg, choices, default)
 
193
        return choose_ui.interact()
67
194
 
68
195
    def be_quiet(self, state):
69
196
        if state and not self._quiet:
82
209
        # to clear it.  We might need to separately check for the case of
83
210
        self._progress_view.clear()
84
211
 
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
212
    def get_integer(self, prompt):
98
213
        while True:
99
214
            self.prompt(prompt)
118
233
                password = password[:-1]
119
234
        return password
120
235
 
121
 
    def get_password(self, prompt='', **kwargs):
 
236
    def get_password(self, prompt=u'', **kwargs):
122
237
        """Prompt the user for a password.
123
238
 
124
239
        :param prompt: The prompt to present the user
157
272
        """Construct and return a new ProgressView subclass for this UI.
158
273
        """
159
274
        # with --quiet, never any progress view
160
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
275
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
161
276
        # user specifically requests either text or no progress bars, always
162
277
        # do that.  otherwise, guess based on $TERM and tty presence.
163
278
        if self.is_quiet():
202
317
        :param kwargs: Dictionary of arguments to insert into the prompt,
203
318
            to allow UIs to reformat the prompt.
204
319
        """
 
320
        if type(prompt) != unicode:
 
321
            raise ValueError("prompt %r not a unicode string" % prompt)
205
322
        if kwargs:
206
323
            # See <https://launchpad.net/bugs/365891>
207
324
            prompt = prompt % kwargs
208
325
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
209
326
        self.clear_term()
 
327
        self.stdout.flush()
210
328
        self.stderr.write(prompt)
211
329
 
212
330
    def report_transport_activity(self, transport, byte_count, direction):
233
351
 
234
352
    def show_warning(self, msg):
235
353
        self.clear_term()
 
354
        if isinstance(msg, unicode):
 
355
            te = osutils.get_terminal_encoding()
 
356
            msg = msg.encode(te, 'replace')
236
357
        self.stderr.write("bzr: warning: %s\n" % msg)
237
358
 
238
359
    def _progress_updated(self, task):
301
422
        # correspond reliably to overall command progress
302
423
        self.enable_bar = False
303
424
 
 
425
    def _avail_width(self):
 
426
        # we need one extra space for terminals that wrap on last char
 
427
        w = osutils.terminal_width() 
 
428
        if w is None:
 
429
            return None
 
430
        else:
 
431
            return w - 1
 
432
 
304
433
    def _show_line(self, s):
305
434
        # sys.stderr.write("progress %r\n" % s)
306
 
        width = osutils.terminal_width()
 
435
        width = self._avail_width()
307
436
        if width is not None:
308
 
            # we need one extra space for terminals that wrap on last char
309
 
            width = width - 1
310
437
            s = '%-*.*s' % (width, width, s)
311
438
        self._term_file.write('\r' + s + '\r')
312
439
 
349
476
            return ''
350
477
 
351
478
    def _format_task(self, task):
 
479
        """Format task-specific parts of progress bar.
 
480
 
 
481
        :returns: (text_part, counter_part) both unicode strings.
 
482
        """
352
483
        if not task.show_count:
353
484
            s = ''
354
485
        elif task.current_cnt is not None and task.total_cnt is not None:
364
495
            t = t._parent_task
365
496
            if t.msg:
366
497
                m = t.msg + ':' + m
367
 
        return m + s
 
498
        return m, s
368
499
 
369
500
    def _render_line(self):
370
501
        bar_string = self._render_bar()
371
502
        if self._last_task:
372
 
            task_msg = self._format_task(self._last_task)
 
503
            task_part, counter_part = self._format_task(self._last_task)
373
504
        else:
374
 
            task_msg = ''
 
505
            task_part = counter_part = ''
375
506
        if self._last_task and not self._last_task.show_transport_activity:
376
507
            trans = ''
377
508
        else:
378
509
            trans = self._last_transport_msg
379
 
            if trans:
380
 
                trans += ' | '
381
 
        return (bar_string + trans + task_msg)
 
510
        # the bar separates the transport activity from the message, so even
 
511
        # if there's no bar or spinner, we must show something if both those
 
512
        # fields are present
 
513
        if (task_part or trans) and not bar_string:
 
514
            bar_string = '| '
 
515
        # preferentially truncate the task message if we don't have enough
 
516
        # space
 
517
        avail_width = self._avail_width()
 
518
        if avail_width is not None:
 
519
            # if terminal avail_width is unknown, don't truncate
 
520
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
521
            gap = current_len - avail_width
 
522
            if gap > 0:
 
523
                task_part = task_part[:-gap-2] + '..'
 
524
        s = trans + bar_string + task_part + counter_part
 
525
        if avail_width is not None:
 
526
            if len(s) < avail_width:
 
527
                s = s.ljust(avail_width)
 
528
            elif len(s) > avail_width:
 
529
                s = s[:avail_width]
 
530
        return s
382
531
 
383
532
    def _repaint(self):
384
533
        s = self._render_line()
440
589
            rate = (self._bytes_since_update
441
590
                    / (now - self._transport_update_time))
442
591
            # using base-10 units (see HACKING.txt).
443
 
            msg = ("%6dkB %5dkB/s" %
 
592
            msg = ("%6dkB %5dkB/s " %
444
593
                    (self._total_byte_count / 1000, int(rate) / 1000,))
445
594
            self._transport_update_time = now
446
595
            self._last_repaint = now