~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Jelmer Vernooij
  • Date: 2009-05-27 08:33:37 UTC
  • mto: (4398.5.1 bencode_serializer)
  • mto: This revision was merged to the branch mainline in revision 4410.
  • Revision ID: jelmer@samba.org-20090527083337-fij2klthhtsdl2hy
Fix copyright headers, add _bencode_py.py to the list of files that do not have to have canonical copyright.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
 
"""Abstraction for interacting with the user.
18
 
 
19
 
Applications can choose different types of UI, and they deal with displaying
20
 
messages or progress to the user, and with gathering different types of input.
21
 
 
22
 
Several levels are supported, and you can also register new factories such as
23
 
for a GUI.
24
 
 
25
 
bzrlib.ui.UIFactory
26
 
    Semi-abstract base class
27
 
 
28
 
bzrlib.ui.SilentUIFactory
29
 
    Produces no output and cannot take any input; useful for programs using
30
 
    bzrlib in batch mode or for programs such as loggerhead.
31
 
 
32
 
bzrlib.ui.CannedInputUIFactory
33
 
    For use in testing; the input values to be returned are provided 
34
 
    at construction.
35
 
 
36
 
bzrlib.ui.text.TextUIFactory
37
 
    Standard text command-line interface, with stdin, stdout, stderr.
38
 
    May make more or less advanced use of them, eg in drawing progress bars,
39
 
    depending on the detected capabilities of the terminal.
40
 
    GUIs may choose to subclass this so that unimplemented methods fall
41
 
    back to working through the terminal.
 
17
"""UI abstraction.
 
18
 
 
19
This tells the library how to display things to the user.  Through this
 
20
layer different applications can choose the style of UI.
 
21
 
 
22
At the moment this layer is almost trivial: the application can just
 
23
choose the style of progress bar.
 
24
 
 
25
Set the ui_factory member to define the behaviour.  The default
 
26
displays no output.
42
27
"""
43
28
 
44
 
 
45
29
import os
46
30
import sys
47
31
import warnings
57
41
    trace,
58
42
    )
59
43
""")
60
 
from bzrlib.symbol_versioning import (
61
 
    deprecated_function,
62
 
    deprecated_in,
63
 
    deprecated_method,
64
 
    )
65
 
 
66
 
 
67
 
_valid_boolean_strings = dict(yes=True, no=False,
68
 
                              y=True, n=False,
69
 
                              on=True, off=False,
70
 
                              true=True, false=False)
71
 
_valid_boolean_strings['1'] = True
72
 
_valid_boolean_strings['0'] = False
73
 
 
74
 
 
75
 
def bool_from_string(s, accepted_values=None):
76
 
    """Returns a boolean if the string can be interpreted as such.
77
 
 
78
 
    Interpret case insensitive strings as booleans. The default values
79
 
    includes: 'yes', 'no, 'y', 'n', 'true', 'false', '0', '1', 'on',
80
 
    'off'. Alternative values can be provided with the 'accepted_values'
81
 
    parameter.
82
 
 
83
 
    :param s: A string that should be interpreted as a boolean. It should be of
84
 
        type string or unicode.
85
 
 
86
 
    :param accepted_values: An optional dict with accepted strings as keys and
87
 
        True/False as values. The strings will be tested against a lowered
88
 
        version of 's'.
89
 
 
90
 
    :return: True or False for accepted strings, None otherwise.
91
 
    """
92
 
    if accepted_values is None:
93
 
        accepted_values = _valid_boolean_strings
94
 
    val = None
95
 
    if type(s) in (str, unicode):
96
 
        try:
97
 
            val = accepted_values[s.lower()]
98
 
        except KeyError:
99
 
            pass
100
 
    return val
101
44
 
102
45
 
103
46
class UIFactory(object):
105
48
 
106
49
    This tells the library how to display things to the user.  Through this
107
50
    layer different applications can choose the style of UI.
108
 
 
109
 
    :ivar suppressed_warnings: Identifiers for user warnings that should 
110
 
        no be emitted.
111
51
    """
112
52
 
113
 
    _user_warning_templates = dict(
114
 
        cross_format_fetch=("Doing on-the-fly conversion from "
115
 
            "%(from_format)s to %(to_format)s.\n"
116
 
            "This may take some time. Upgrade the repositories to the "
117
 
            "same format for better performance."
118
 
            )
119
 
        )
120
 
 
121
53
    def __init__(self):
122
54
        self._task_stack = []
123
 
        self.suppressed_warnings = set()
124
 
        self._quiet = False
125
 
 
126
 
    def be_quiet(self, state):
127
 
        """Tell the UI to be more quiet, or not.
128
 
 
129
 
        Typically this suppresses progress bars; the application may also look
130
 
        at ui_factory.is_quiet().
131
 
        """
132
 
        self._quiet = state
133
55
 
134
56
    def get_password(self, prompt='', **kwargs):
135
57
        """Prompt the user for a password.
146
68
        """
147
69
        raise NotImplementedError(self.get_password)
148
70
 
149
 
    def is_quiet(self):
150
 
        return self._quiet
151
 
 
152
 
    def make_output_stream(self, encoding=None, encoding_type=None):
153
 
        """Get a stream for sending out bulk text data.
154
 
 
155
 
        This is used for commands that produce bulk text, such as log or diff
156
 
        output, as opposed to user interaction.  This should work even for
157
 
        non-interactive user interfaces.  Typically this goes to a decorated
158
 
        version of stdout, but in a GUI it might be appropriate to send it to a 
159
 
        window displaying the text.
160
 
     
161
 
        :param encoding: Unicode encoding for output; default is the 
162
 
            terminal encoding, which may be different from the user encoding.
163
 
            (See get_terminal_encoding.)
164
 
 
165
 
        :param encoding_type: How to handle encoding errors:
166
 
            replace/strict/escape/exact.  Default is replace.
167
 
        """
168
 
        # XXX: is the caller supposed to close the resulting object?
169
 
        if encoding is None:
170
 
            encoding = osutils.get_terminal_encoding()
171
 
        if encoding_type is None:
172
 
            encoding_type = 'replace'
173
 
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
174
 
        return out_stream
175
 
 
176
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
177
 
        raise NotImplementedError("%s doesn't support make_output_stream"
178
 
            % (self.__class__.__name__))
179
 
 
180
71
    def nested_progress_bar(self):
181
72
        """Return a nested progress bar.
182
73
 
195
86
        if not self._task_stack:
196
87
            warnings.warn("%r finished but nothing is active"
197
88
                % (task,))
198
 
        if task in self._task_stack:
199
 
            self._task_stack.remove(task)
 
89
        elif task != self._task_stack[-1]:
 
90
            warnings.warn("%r is not the active task %r"
 
91
                % (task, self._task_stack[-1]))
200
92
        else:
201
 
            warnings.warn("%r is not in active stack %r"
202
 
                % (task, self._task_stack))
 
93
            del self._task_stack[-1]
203
94
        if not self._task_stack:
204
95
            self._progress_all_finished()
205
96
 
222
113
        """
223
114
        pass
224
115
 
225
 
    def format_user_warning(self, warning_id, message_args):
226
 
        try:
227
 
            template = self._user_warning_templates[warning_id]
228
 
        except KeyError:
229
 
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
230
 
            warnings.warn(fail)   # so tests will fail etc
231
 
            return fail
232
 
        try:
233
 
            return template % message_args
234
 
        except ValueError, e:
235
 
            fail = "failed to format warning %r, %r: %s" % (
236
 
                warning_id, message_args, e)
237
 
            warnings.warn(fail)   # so tests will fail etc
238
 
            return fail
239
 
 
240
116
    def get_boolean(self, prompt):
241
117
        """Get a boolean question answered from the user.
242
118
 
246
122
        """
247
123
        raise NotImplementedError(self.get_boolean)
248
124
 
249
 
    def get_integer(self, prompt):
250
 
        """Get an integer from the user.
251
 
 
252
 
        :param prompt: a message to prompt the user with. Could be a multi-line
253
 
            prompt but without a terminating \n.
254
 
 
255
 
        :return: A signed integer.
256
 
        """
257
 
        raise NotImplementedError(self.get_integer)
258
 
 
259
 
    def make_progress_view(self):
260
 
        """Construct a new ProgressView object for this UI.
261
 
 
262
 
        Application code should normally not call this but instead
263
 
        nested_progress_bar().
264
 
        """
265
 
        return NullProgressView()
266
 
 
267
125
    def recommend_upgrade(self,
268
126
        current_format_name,
269
127
        basedir):
270
 
        # XXX: this should perhaps be in the TextUIFactory and the default can do
 
128
        # this should perhaps be in the TextUIFactory and the default can do
271
129
        # nothing
272
 
        #
273
 
        # XXX: Change to show_user_warning - that will accomplish the previous
274
 
        # xxx. -- mbp 2010-02-25
275
130
        trace.warning("%s is deprecated "
276
131
            "and a better format is available.\n"
277
132
            "It is recommended that you upgrade by "
288
143
        """
289
144
        pass
290
145
 
291
 
    def log_transport_activity(self, display=False):
292
 
        """Write out whatever transport activity has been measured.
293
 
 
294
 
        Implementations are allowed to do nothing, but it is useful if they can
295
 
        write a line to the log file.
296
 
 
297
 
        :param display: If False, only log to disk, if True also try to display
298
 
            a message to the user.
299
 
        :return: None
300
 
        """
301
 
        # Default implementation just does nothing
302
 
        pass
303
 
 
304
 
    def show_user_warning(self, warning_id, **message_args):
305
 
        """Show a warning to the user.
306
 
 
307
 
        This is specifically for things that are under the user's control (eg
308
 
        outdated formats), not for internal program warnings like deprecated
309
 
        APIs.
310
 
 
311
 
        This can be overridden by UIFactory subclasses to show it in some 
312
 
        appropriate way; the default UIFactory is noninteractive and does
313
 
        nothing.  format_user_warning maps it to a string, though other
314
 
        presentations can be used for particular UIs.
315
 
 
316
 
        :param warning_id: An identifier like 'cross_format_fetch' used to 
317
 
            check if the message is suppressed and to look up the string.
318
 
        :param message_args: Arguments to be interpolated into the message.
319
 
        """
320
 
        pass
321
 
 
322
 
    def show_error(self, msg):
323
 
        """Show an error message (not an exception) to the user.
324
 
        
325
 
        The message should not have an error prefix or trailing newline.  That
326
 
        will be added by the factory if appropriate.
327
 
        """
328
 
        raise NotImplementedError(self.show_error)
329
 
 
330
 
    def show_message(self, msg):
331
 
        """Show a message to the user."""
332
 
        raise NotImplementedError(self.show_message)
333
 
 
334
 
    def show_warning(self, msg):
335
 
        """Show a warning to the user."""
336
 
        raise NotImplementedError(self.show_warning)
337
 
 
338
 
    def warn_cross_format_fetch(self, from_format, to_format):
339
 
        """Warn about a potentially slow cross-format transfer.
340
 
        
341
 
        This is deprecated in favor of show_user_warning, but retained for api
342
 
        compatibility in 2.0 and 2.1.
343
 
        """
344
 
        self.show_user_warning('cross_format_fetch', from_format=from_format,
345
 
            to_format=to_format)
346
 
 
347
 
    def warn_experimental_format_fetch(self, inter):
348
 
        """Warn about fetching into experimental repository formats."""
349
 
        if inter.target._format.experimental:
350
 
            trace.warning("Fetching into experimental format %s.\n"
351
 
                "This format may be unreliable or change in the future "
352
 
                "without an upgrade path.\n" % (inter.target._format,))
353
 
 
354
 
 
355
 
 
356
 
class SilentUIFactory(UIFactory):
 
146
 
 
147
 
 
148
class CLIUIFactory(UIFactory):
 
149
    """Common behaviour for command line UI factories.
 
150
 
 
151
    This is suitable for dumb terminals that can't repaint existing text."""
 
152
 
 
153
    def __init__(self, stdin=None, stdout=None, stderr=None):
 
154
        UIFactory.__init__(self)
 
155
        self.stdin = stdin or sys.stdin
 
156
        self.stdout = stdout or sys.stdout
 
157
        self.stderr = stderr or sys.stderr
 
158
 
 
159
    def get_boolean(self, prompt):
 
160
        # FIXME: make a regexp and handle case variations as well.
 
161
        while True:
 
162
            self.prompt(prompt + "? [y/n]: ")
 
163
            line = self.stdin.readline()
 
164
            if line in ('y\n', 'yes\n'):
 
165
                return True
 
166
            if line in ('n\n', 'no\n'):
 
167
                return False
 
168
 
 
169
    def get_non_echoed_password(self):
 
170
        isatty = getattr(self.stdin, 'isatty', None)
 
171
        if isatty is not None and isatty():
 
172
            # getpass() ensure the password is not echoed and other
 
173
            # cross-platform niceties
 
174
            password = getpass.getpass('')
 
175
        else:
 
176
            # echo doesn't make sense without a terminal
 
177
            password = self.stdin.readline()
 
178
            if not password:
 
179
                password = None
 
180
            elif password[-1] == '\n':
 
181
                password = password[:-1]
 
182
        return password
 
183
 
 
184
    def get_password(self, prompt='', **kwargs):
 
185
        """Prompt the user for a password.
 
186
 
 
187
        :param prompt: The prompt to present the user
 
188
        :param kwargs: Arguments which will be expanded into the prompt.
 
189
                       This lets front ends display different things if
 
190
                       they so choose.
 
191
        :return: The password string, return None if the user
 
192
                 canceled the request.
 
193
        """
 
194
        prompt += ': '
 
195
        self.prompt(prompt, **kwargs)
 
196
        # There's currently no way to say 'i decline to enter a password'
 
197
        # as opposed to 'my password is empty' -- does it matter?
 
198
        return self.get_non_echoed_password()
 
199
 
 
200
    def get_username(self, prompt, **kwargs):
 
201
        """Prompt the user for a username.
 
202
 
 
203
        :param prompt: The prompt to present the user
 
204
        :param kwargs: Arguments which will be expanded into the prompt.
 
205
                       This lets front ends display different things if
 
206
                       they so choose.
 
207
        :return: The username string, return None if the user
 
208
                 canceled the request.
 
209
        """
 
210
        prompt += ': '
 
211
        self.prompt(prompt, **kwargs)
 
212
        username = self.stdin.readline()
 
213
        if not username:
 
214
            username = None
 
215
        elif username[-1] == '\n':
 
216
            username = username[:-1]
 
217
        return username
 
218
 
 
219
    def prompt(self, prompt, **kwargs):
 
220
        """Emit prompt on the CLI.
 
221
        
 
222
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
223
            to allow UIs to reformat the prompt.
 
224
        """
 
225
        if kwargs:
 
226
            # See <https://launchpad.net/bugs/365891>
 
227
            prompt = prompt % kwargs
 
228
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
229
        self.clear_term()
 
230
        self.stdout.write(prompt)
 
231
 
 
232
    def note(self, msg):
 
233
        """Write an already-formatted message."""
 
234
        self.stdout.write(msg + '\n')
 
235
 
 
236
 
 
237
class SilentUIFactory(CLIUIFactory):
357
238
    """A UI Factory which never prints anything.
358
239
 
359
 
    This is the default UI, if another one is never registered by a program
360
 
    using bzrlib, and it's also active for example inside 'bzr serve'.
361
 
 
362
 
    Methods that try to read from the user raise an error; methods that do
363
 
    output do nothing.
 
240
    This is the default UI, if another one is never registered.
364
241
    """
365
242
 
366
243
    def __init__(self):
367
 
        UIFactory.__init__(self)
 
244
        CLIUIFactory.__init__(self)
 
245
 
 
246
    def get_password(self, prompt='', **kwargs):
 
247
        return None
 
248
 
 
249
    def get_username(self, prompt='', **kwargs):
 
250
        return None
 
251
 
 
252
    def prompt(self, prompt, **kwargs):
 
253
        pass
368
254
 
369
255
    def note(self, msg):
370
256
        pass
371
257
 
372
 
    def get_username(self, prompt, **kwargs):
373
 
        return None
374
 
 
375
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
376
 
        return NullOutputStream(encoding)
377
 
 
378
 
    def show_error(self, msg):
379
 
        pass
380
 
 
381
 
    def show_message(self, msg):
382
 
        pass
383
 
 
384
 
    def show_warning(self, msg):
385
 
        pass
386
 
 
387
 
 
388
 
class CannedInputUIFactory(SilentUIFactory):
389
 
    """A silent UI that return canned input."""
390
 
 
391
 
    def __init__(self, responses):
392
 
        self.responses = responses
393
 
 
394
 
    def __repr__(self):
395
 
        return "%s(%r)" % (self.__class__.__name__, self.responses)
396
 
 
397
 
    def get_boolean(self, prompt):
398
 
        return self.responses.pop(0)
399
 
 
400
 
    def get_integer(self, prompt):
401
 
        return self.responses.pop(0)
402
 
 
403
 
    def get_password(self, prompt='', **kwargs):
404
 
        return self.responses.pop(0)
405
 
 
406
 
    def get_username(self, prompt, **kwargs):
407
 
        return self.responses.pop(0)
408
 
 
409
 
    def assert_all_input_consumed(self):
410
 
        if self.responses:
411
 
            raise AssertionError("expected all input in %r to be consumed"
412
 
                % (self,))
 
258
 
 
259
def clear_decorator(func, *args, **kwargs):
 
260
    """Decorator that clears the term"""
 
261
    ui_factory.clear_term()
 
262
    func(*args, **kwargs)
413
263
 
414
264
 
415
265
ui_factory = SilentUIFactory()
416
 
# IMPORTANT: never import this symbol directly. ONLY ever access it as
417
 
# ui.ui_factory, so that you refer to the current value.
 
266
"""IMPORTANT: never import this symbol directly. ONLY ever access it as
 
267
ui.ui_factory."""
418
268
 
419
269
 
420
270
def make_ui_for_terminal(stdin, stdout, stderr):
421
271
    """Construct and return a suitable UIFactory for a text mode program.
 
272
 
 
273
    If stdout is a smart terminal, this gets a smart UIFactory with
 
274
    progress indicators, etc.  If it's a dumb terminal, just plain text output.
422
275
    """
423
 
    # this is now always TextUIFactory, which in turn decides whether it
424
 
    # should display progress bars etc
425
 
    from bzrlib.ui.text import TextUIFactory
426
 
    return TextUIFactory(stdin, stdout, stderr)
427
 
 
428
 
 
429
 
class NullProgressView(object):
430
 
    """Soak up and ignore progress information."""
431
 
 
432
 
    def clear(self):
433
 
        pass
434
 
 
435
 
    def show_progress(self, task):
436
 
        pass
437
 
 
438
 
    def show_transport_activity(self, transport, direction, byte_count):
439
 
        pass
440
 
 
441
 
    def log_transport_activity(self, display=False):
442
 
        pass
443
 
 
444
 
 
445
 
class NullOutputStream(object):
446
 
    """Acts like a file, but discard all output."""
447
 
 
448
 
    def __init__(self, encoding):
449
 
        self.encoding = encoding
450
 
 
451
 
    def write(self, data):
452
 
        pass
453
 
 
454
 
    def writelines(self, data):
455
 
        pass
456
 
 
457
 
    def close(self):
458
 
        pass
 
276
    cls = None
 
277
    isatty = getattr(stdin, 'isatty', None)
 
278
    if isatty is None:
 
279
        cls = CLIUIFactory
 
280
    elif not isatty():
 
281
        cls = CLIUIFactory
 
282
    elif os.environ.get('TERM') in ('dumb', ''):
 
283
        # e.g. emacs compile window
 
284
        cls = CLIUIFactory
 
285
    # User may know better, otherwise default to TextUIFactory
 
286
    if (   os.environ.get('BZR_USE_TEXT_UI', None) is not None
 
287
        or cls is None):
 
288
        from bzrlib.ui.text import TextUIFactory
 
289
        cls = TextUIFactory
 
290
    return cls(stdin=stdin, stdout=stdout, stderr=stderr)