/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 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
18
18
"""Text UI, write output to the console.
19
19
"""
20
20
 
21
 
from __future__ import absolute_import
22
 
 
 
21
import codecs
 
22
import getpass
23
23
import os
24
24
import sys
25
25
import time
 
26
import warnings
26
27
 
27
28
from bzrlib.lazy_import import lazy_import
28
29
lazy_import(globals(), """
29
 
import codecs
30
 
import getpass
31
 
import warnings
32
 
 
33
30
from bzrlib import (
34
31
    debug,
35
32
    progress,
36
33
    osutils,
 
34
    symbol_versioning,
37
35
    trace,
38
36
    )
39
37
 
40
38
""")
41
39
 
 
40
from bzrlib.osutils import watch_sigwinch
 
41
 
42
42
from bzrlib.ui import (
43
43
    UIFactory,
44
44
    NullProgressView,
45
45
    )
46
46
 
47
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
 
 
158
48
class TextUIFactory(UIFactory):
159
49
    """A UI factory for Text user interefaces."""
160
50
 
172
62
        self.stderr = stderr
173
63
        # paints progress, network activity, etc
174
64
        self._progress_view = self.make_progress_view()
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()
 
65
        # hook up the signals to watch for terminal size changes
 
66
        watch_sigwinch()
196
67
 
197
68
    def be_quiet(self, state):
198
69
        if state and not self._quiet:
211
82
        # to clear it.  We might need to separately check for the case of
212
83
        self._progress_view.clear()
213
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
 
214
97
    def get_integer(self, prompt):
215
98
        while True:
216
99
            self.prompt(prompt)
235
118
                password = password[:-1]
236
119
        return password
237
120
 
238
 
    def get_password(self, prompt=u'', **kwargs):
 
121
    def get_password(self, prompt='', **kwargs):
239
122
        """Prompt the user for a password.
240
123
 
241
124
        :param prompt: The prompt to present the user
274
157
        """Construct and return a new ProgressView subclass for this UI.
275
158
        """
276
159
        # with --quiet, never any progress view
277
 
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
160
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
278
161
        # user specifically requests either text or no progress bars, always
279
162
        # do that.  otherwise, guess based on $TERM and tty presence.
280
163
        if self.is_quiet():
319
202
        :param kwargs: Dictionary of arguments to insert into the prompt,
320
203
            to allow UIs to reformat the prompt.
321
204
        """
322
 
        if type(prompt) != unicode:
323
 
            raise ValueError("prompt %r not a unicode string" % prompt)
324
205
        if kwargs:
325
206
            # See <https://launchpad.net/bugs/365891>
326
207
            prompt = prompt % kwargs
327
208
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
328
209
        self.clear_term()
329
 
        self.stdout.flush()
330
210
        self.stderr.write(prompt)
331
211
 
332
212
    def report_transport_activity(self, transport, byte_count, direction):
353
233
 
354
234
    def show_warning(self, msg):
355
235
        self.clear_term()
356
 
        if isinstance(msg, unicode):
357
 
            te = osutils.get_terminal_encoding()
358
 
            msg = msg.encode(te, 'replace')
359
236
        self.stderr.write("bzr: warning: %s\n" % msg)
360
237
 
361
238
    def _progress_updated(self, task):
424
301
        # correspond reliably to overall command progress
425
302
        self.enable_bar = False
426
303
 
427
 
    def _avail_width(self):
428
 
        # we need one extra space for terminals that wrap on last char
429
 
        w = osutils.terminal_width() 
430
 
        if w is None:
431
 
            return None
432
 
        else:
433
 
            return w - 1
434
 
 
435
304
    def _show_line(self, s):
436
305
        # sys.stderr.write("progress %r\n" % s)
437
 
        width = self._avail_width()
 
306
        width = osutils.terminal_width()
438
307
        if width is not None:
 
308
            # we need one extra space for terminals that wrap on last char
 
309
            width = width - 1
439
310
            s = '%-*.*s' % (width, width, s)
440
311
        self._term_file.write('\r' + s + '\r')
441
312
 
478
349
            return ''
479
350
 
480
351
    def _format_task(self, task):
481
 
        """Format task-specific parts of progress bar.
482
 
 
483
 
        :returns: (text_part, counter_part) both unicode strings.
484
 
        """
485
352
        if not task.show_count:
486
353
            s = ''
487
354
        elif task.current_cnt is not None and task.total_cnt is not None:
497
364
            t = t._parent_task
498
365
            if t.msg:
499
366
                m = t.msg + ':' + m
500
 
        return m, s
 
367
        return m + s
501
368
 
502
369
    def _render_line(self):
503
370
        bar_string = self._render_bar()
504
371
        if self._last_task:
505
 
            task_part, counter_part = self._format_task(self._last_task)
 
372
            task_msg = self._format_task(self._last_task)
506
373
        else:
507
 
            task_part = counter_part = ''
 
374
            task_msg = ''
508
375
        if self._last_task and not self._last_task.show_transport_activity:
509
376
            trans = ''
510
377
        else:
511
378
            trans = self._last_transport_msg
512
 
        # the bar separates the transport activity from the message, so even
513
 
        # if there's no bar or spinner, we must show something if both those
514
 
        # fields are present
515
 
        if (task_part or trans) and not bar_string:
516
 
            bar_string = '| '
517
 
        # preferentially truncate the task message if we don't have enough
518
 
        # space
519
 
        avail_width = self._avail_width()
520
 
        if avail_width is not None:
521
 
            # if terminal avail_width is unknown, don't truncate
522
 
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
523
 
            gap = current_len - avail_width
524
 
            if gap > 0:
525
 
                task_part = task_part[:-gap-2] + '..'
526
 
        s = trans + bar_string + task_part + counter_part
527
 
        if avail_width is not None:
528
 
            if len(s) < avail_width:
529
 
                s = s.ljust(avail_width)
530
 
            elif len(s) > avail_width:
531
 
                s = s[:avail_width]
532
 
        return s
 
379
            if trans:
 
380
                trans += ' | '
 
381
        return (bar_string + trans + task_msg)
533
382
 
534
383
    def _repaint(self):
535
384
        s = self._render_line()
591
440
            rate = (self._bytes_since_update
592
441
                    / (now - self._transport_update_time))
593
442
            # using base-10 units (see HACKING.txt).
594
 
            msg = ("%6dkB %5dkB/s " %
 
443
            msg = ("%6dkB %5dkB/s" %
595
444
                    (self._total_byte_count / 1000, int(rate) / 1000,))
596
445
            self._transport_update_time = now
597
446
            self._last_repaint = now