/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/__init__.py

  • Committer: Martin Pool
  • Date: 2009-07-27 06:28:35 UTC
  • mto: This revision was merged to the branch mainline in revision 4587.
  • Revision ID: mbp@sourcefrog.net-20090727062835-o66p8it658tq1sma
Add CountedLock.get_physical_lock_status

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/__init__.py
1
 
# Copyright (C) 2005-2011 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
22
22
Several levels are supported, and you can also register new factories such as
23
23
for a GUI.
24
24
 
25
 
breezy.ui.UIFactory
 
25
UIFactory
26
26
    Semi-abstract base class
27
27
 
28
 
breezy.ui.SilentUIFactory
 
28
SilentUIFactory
29
29
    Produces no output and cannot take any input; useful for programs using
30
 
    breezy in batch mode or for programs such as loggerhead.
 
30
    bzrlib in batch mode or for programs such as loggerhead.
31
31
 
32
 
breezy.ui.CannedInputUIFactory
33
 
    For use in testing; the input values to be returned are provided
 
32
CannedInputUIFactory
 
33
    For use in testing; the input values to be returned are provided 
34
34
    at construction.
35
35
 
36
 
breezy.ui.text.TextUIFactory
 
36
TextUIFactory
37
37
    Standard text command-line interface, with stdin, stdout, stderr.
38
38
    May make more or less advanced use of them, eg in drawing progress bars,
39
39
    depending on the detected capabilities of the terminal.
41
41
    back to working through the terminal.
42
42
"""
43
43
 
44
 
from __future__ import absolute_import
45
44
 
 
45
import os
 
46
import sys
46
47
import warnings
47
48
 
48
 
from ..lazy_import import lazy_import
 
49
from bzrlib.lazy_import import lazy_import
49
50
lazy_import(globals(), """
50
 
from breezy import (
51
 
    config,
 
51
import getpass
 
52
 
 
53
from bzrlib import (
 
54
    errors,
52
55
    osutils,
53
56
    progress,
 
57
    trace,
54
58
    )
55
59
""")
56
 
 
57
 
from ..sixish import (
58
 
    PY3,
59
 
    string_types,
60
 
    text_type,
 
60
from bzrlib.symbol_versioning import (
 
61
    deprecated_function,
 
62
    deprecated_in,
 
63
    deprecated_method,
61
64
    )
62
65
 
63
66
 
89
92
    if accepted_values is None:
90
93
        accepted_values = _valid_boolean_strings
91
94
    val = None
92
 
    if isinstance(s, string_types):
 
95
    if type(s) in (str, unicode):
93
96
        try:
94
97
            val = accepted_values[s.lower()]
95
98
        except KeyError:
97
100
    return val
98
101
 
99
102
 
100
 
class ConfirmationUserInterfacePolicy(object):
101
 
    """Wrapper for a UIFactory that allows or denies all confirmed actions."""
102
 
 
103
 
    def __init__(self, wrapped_ui, default_answer, specific_answers):
104
 
        """Generate a proxy UI that does no confirmations.
105
 
 
106
 
        :param wrapped_ui: Underlying UIFactory.
107
 
        :param default_answer: Bool for whether requests for
108
 
            confirmation from the user should be noninteractively accepted or
109
 
            denied.
110
 
        :param specific_answers: Map from confirmation_id to bool answer.
111
 
        """
112
 
        self.wrapped_ui = wrapped_ui
113
 
        self.default_answer = default_answer
114
 
        self.specific_answers = specific_answers
115
 
 
116
 
    def __getattr__(self, name):
117
 
        return getattr(self.wrapped_ui, name)
118
 
 
119
 
    def __repr__(self):
120
 
        return '%s(%r, %r, %r)' % (
121
 
            self.__class__.__name__,
122
 
            self.wrapped_ui,
123
 
            self.default_answer,
124
 
            self.specific_answers)
125
 
 
126
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
127
 
        if confirmation_id in self.specific_answers:
128
 
            return self.specific_answers[confirmation_id]
129
 
        elif self.default_answer is not None:
130
 
            return self.default_answer
131
 
        else:
132
 
            return self.wrapped_ui.confirm_action(
133
 
                prompt, confirmation_id, prompt_kwargs)
134
 
 
135
 
 
136
103
class UIFactory(object):
137
104
    """UI abstraction.
138
105
 
139
106
    This tells the library how to display things to the user.  Through this
140
107
    layer different applications can choose the style of UI.
141
 
 
142
 
    UI Factories are also context managers, for some syntactic sugar some users
143
 
    need.
144
 
 
145
 
    :ivar suppressed_warnings: Identifiers for user warnings that should
146
 
        no be emitted.
147
108
    """
148
109
 
149
 
    _user_warning_templates = dict(
150
 
        cross_format_fetch=("Doing on-the-fly conversion from "
151
 
                            "%(from_format)s to %(to_format)s.\n"
152
 
                            "This may take some time. Upgrade the repositories to the "
153
 
                            "same format for better performance."
154
 
                            ),
155
 
        experimental_format_fetch=("Fetching into experimental format "
156
 
                                   "%(to_format)s.\n"
157
 
                                   "This format may be unreliable or change in the future "
158
 
                                   "without an upgrade path.\n"),
159
 
        deprecated_command=(
160
 
            "The command 'brz %(deprecated_name)s' "
161
 
            "has been deprecated in brz %(deprecated_in_version)s. "
162
 
            "Please use 'brz %(recommended_name)s' instead."),
163
 
        deprecated_command_option=(
164
 
            "The option '%(deprecated_name)s' to 'brz %(command)s' "
165
 
            "has been deprecated in brz %(deprecated_in_version)s. "
166
 
            "Please use '%(recommended_name)s' instead."),
167
 
        recommend_upgrade=("%(current_format_name)s is deprecated "
168
 
                           "and a better format is available.\n"
169
 
                           "It is recommended that you upgrade by "
170
 
                           "running the command\n"
171
 
                           "  brz upgrade %(basedir)s"),
172
 
        locks_steal_dead=(
173
 
            u"Stole dead lock %(lock_url)s %(other_holder_info)s."),
174
 
        not_checking_ssl_cert=(
175
 
            u"Not checking SSL certificate for %(host)s."),
176
 
        )
177
 
 
178
110
    def __init__(self):
179
111
        self._task_stack = []
180
 
        self.suppressed_warnings = set()
181
 
        self._quiet = False
182
 
 
183
 
    def __enter__(self):
184
 
        """Context manager entry support.
185
 
 
186
 
        Override in a concrete factory class if initialisation before use is
187
 
        needed.
188
 
        """
189
 
        return self  # This is bound to the 'as' clause in a with statement.
190
 
 
191
 
    def __exit__(self, exc_type, exc_val, exc_tb):
192
 
        """Context manager exit support.
193
 
 
194
 
        Override in a concrete factory class if more cleanup than a simple
195
 
        self.clear_term() is needed when the UIFactory is finished with.
196
 
        """
197
 
        self.clear_term()
198
 
        return False  # propogate exceptions.
199
 
 
200
 
    def be_quiet(self, state):
201
 
        """Tell the UI to be more quiet, or not.
202
 
 
203
 
        Typically this suppresses progress bars; the application may also look
204
 
        at ui_factory.is_quiet().
205
 
        """
206
 
        self._quiet = state
207
 
 
208
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
209
 
        """Seek user confirmation for an action.
210
 
 
211
 
        If the UI is noninteractive, or the user does not want to be asked
212
 
        about this action, True is returned, indicating brz should just
213
 
        proceed.
214
 
 
215
 
        The confirmation id allows the user to configure certain actions to
216
 
        always be confirmed or always denied, and for UIs to specialize the
217
 
        display of particular confirmations.
218
 
 
219
 
        :param prompt: Suggested text to display to the user.
220
 
        :param prompt_kwargs: A dictionary of arguments that can be
221
 
            string-interpolated into the prompt.
222
 
        :param confirmation_id: Unique string identifier for the confirmation.
223
 
        """
224
 
        return self.get_boolean(prompt % prompt_kwargs)
225
 
 
226
 
    def get_password(self, prompt=u'', **kwargs):
 
112
 
 
113
    def get_password(self, prompt='', **kwargs):
227
114
        """Prompt the user for a password.
228
115
 
229
 
        :param prompt: The prompt to present the user (must be unicode)
 
116
        :param prompt: The prompt to present the user
230
117
        :param kwargs: Arguments which will be expanded into the prompt.
231
118
                       This lets front ends display different things if
232
119
                       they so choose.
238
125
        """
239
126
        raise NotImplementedError(self.get_password)
240
127
 
241
 
    def is_quiet(self):
242
 
        return self._quiet
243
 
 
244
 
    def make_output_stream(self, encoding=None, encoding_type='replace'):
245
 
        """Get a stream for sending out bulk text data.
246
 
 
247
 
        This is used for commands that produce bulk text, such as log or diff
248
 
        output, as opposed to user interaction.  This should work even for
249
 
        non-interactive user interfaces.  Typically this goes to a decorated
250
 
        version of stdout, but in a GUI it might be appropriate to send it to a
251
 
        window displaying the text.
252
 
 
253
 
        The caller may flush but should not close the returned stream.
254
 
 
255
 
        :param encoding: Unicode encoding for output; if not specified
256
 
            uses the configured 'output_encoding' if any; otherwise the
257
 
            terminal encoding.
258
 
            (See get_terminal_encoding.)
259
 
 
260
 
        :param encoding_type: How to handle encoding errors:
261
 
            replace/strict/escape/exact.  Default is replace.
262
 
        """
263
 
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
264
 
        return out_stream
265
 
 
266
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
267
 
        raise NotImplementedError("%s doesn't support make_output_stream"
268
 
                                  % (self.__class__.__name__))
269
 
 
270
128
    def nested_progress_bar(self):
271
129
        """Return a nested progress bar.
272
130
 
284
142
        """Called by the ProgressTask when it finishes"""
285
143
        if not self._task_stack:
286
144
            warnings.warn("%r finished but nothing is active"
287
 
                          % (task,))
288
 
        if task in self._task_stack:
289
 
            self._task_stack.remove(task)
 
145
                % (task,))
 
146
        elif task != self._task_stack[-1]:
 
147
            warnings.warn("%r is not the active task %r"
 
148
                % (task, self._task_stack[-1]))
290
149
        else:
291
 
            warnings.warn("%r is not in active stack %r"
292
 
                          % (task, self._task_stack))
 
150
            del self._task_stack[-1]
293
151
        if not self._task_stack:
294
152
            self._progress_all_finished()
295
153
 
312
170
        """
313
171
        pass
314
172
 
315
 
    def format_user_warning(self, warning_id, message_args):
316
 
        try:
317
 
            template = self._user_warning_templates[warning_id]
318
 
        except KeyError:
319
 
            fail = "brz warning: %r, %r" % (warning_id, message_args)
320
 
            warnings.warn("no template for warning: "
321
 
                          + fail)   # so tests will fail etc
322
 
            return text_type(fail)
323
 
        try:
324
 
            return text_type(template) % message_args
325
 
        except ValueError as e:
326
 
            fail = "brz unprintable warning: %r, %r, %s" % (
327
 
                warning_id, message_args, e)
328
 
            warnings.warn(fail)   # so tests will fail etc
329
 
            return text_type(fail)
330
 
 
331
 
    def choose(self, msg, choices, default=None):
332
 
        """Prompt the user for a list of alternatives.
333
 
 
334
 
        :param msg: message to be shown as part of the prompt.
335
 
 
336
 
        :param choices: list of choices, with the individual choices separated
337
 
            by '\n', e.g.: choose("Save changes?", "&Yes\n&No\n&Cancel"). The
338
 
            letter after the '&' is the shortcut key for that choice. Thus you
339
 
            can type 'c' to select "Cancel".  Shorcuts are case insensitive.
340
 
            The shortcut does not need to be the first letter. If a shorcut key
341
 
            is not provided, the first letter for the choice will be used.
342
 
 
343
 
        :param default: default choice (index), returned for example when enter
344
 
            is pressed for the console version.
345
 
 
346
 
        :return: the index fo the user choice (so '0', '1' or '2' for
347
 
            respectively yes/no/cancel in the previous example).
348
 
        """
349
 
        raise NotImplementedError(self.choose)
350
 
 
351
173
    def get_boolean(self, prompt):
352
174
        """Get a boolean question answered from the user.
353
175
 
354
176
        :param prompt: a message to prompt the user with. Should be a single
355
 
            line without terminating \\n.
 
177
        line without terminating \n.
356
178
        :return: True or False for y/yes or n/no.
357
179
        """
358
 
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
359
 
        return 0 == choice
360
 
 
361
 
    def get_integer(self, prompt):
362
 
        """Get an integer from the user.
363
 
 
364
 
        :param prompt: a message to prompt the user with. Could be a multi-line
365
 
            prompt but without a terminating \\n.
366
 
 
367
 
        :return: A signed integer.
368
 
        """
369
 
        raise NotImplementedError(self.get_integer)
 
180
        raise NotImplementedError(self.get_boolean)
370
181
 
371
182
    def make_progress_view(self):
372
183
        """Construct a new ProgressView object for this UI.
376
187
        """
377
188
        return NullProgressView()
378
189
 
379
 
    def recommend_upgrade(self, current_format_name, basedir):
380
 
        """Recommend the user upgrade a control directory.
381
 
 
382
 
        :param current_format_name: Description of the current format
383
 
        :param basedir: Location of the control dir
384
 
        """
385
 
        self.show_user_warning('recommend_upgrade',
386
 
                               current_format_name=current_format_name, basedir=basedir)
 
190
    def recommend_upgrade(self,
 
191
        current_format_name,
 
192
        basedir):
 
193
        # this should perhaps be in the TextUIFactory and the default can do
 
194
        # nothing
 
195
        trace.warning("%s is deprecated "
 
196
            "and a better format is available.\n"
 
197
            "It is recommended that you upgrade by "
 
198
            "running the command\n"
 
199
            "  bzr upgrade %s",
 
200
            current_format_name,
 
201
            basedir)
387
202
 
388
203
    def report_transport_activity(self, transport, byte_count, direction):
389
204
        """Called by transports as they do IO.
393
208
        """
394
209
        pass
395
210
 
396
 
    def log_transport_activity(self, display=False):
397
 
        """Write out whatever transport activity has been measured.
398
 
 
399
 
        Implementations are allowed to do nothing, but it is useful if they can
400
 
        write a line to the log file.
401
 
 
402
 
        :param display: If False, only log to disk, if True also try to display
403
 
            a message to the user.
404
 
        :return: None
405
 
        """
406
 
        # Default implementation just does nothing
407
 
        pass
408
 
 
409
 
    def show_user_warning(self, warning_id, **message_args):
410
 
        """Show a warning to the user.
411
 
 
412
 
        This is specifically for things that are under the user's control (eg
413
 
        outdated formats), not for internal program warnings like deprecated
414
 
        APIs.
415
 
 
416
 
        This can be overridden by UIFactory subclasses to show it in some
417
 
        appropriate way; the default UIFactory is noninteractive and does
418
 
        nothing.  format_user_warning maps it to a string, though other
419
 
        presentations can be used for particular UIs.
420
 
 
421
 
        :param warning_id: An identifier like 'cross_format_fetch' used to
422
 
            check if the message is suppressed and to look up the string.
423
 
        :param message_args: Arguments to be interpolated into the message.
424
 
        """
425
 
        pass
426
 
 
427
 
    def show_error(self, msg):
428
 
        """Show an error message (not an exception) to the user.
429
 
 
430
 
        The message should not have an error prefix or trailing newline.  That
431
 
        will be added by the factory if appropriate.
432
 
        """
433
 
        raise NotImplementedError(self.show_error)
434
 
 
435
 
    def show_message(self, msg):
436
 
        """Show a message to the user."""
437
 
        raise NotImplementedError(self.show_message)
438
 
 
439
 
    def show_warning(self, msg):
440
 
        """Show a warning to the user."""
441
 
        raise NotImplementedError(self.show_warning)
442
 
 
443
 
 
444
 
class NoninteractiveUIFactory(UIFactory):
445
 
    """Base class for UIs with no user."""
446
 
 
447
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
448
 
        return True
449
 
 
450
 
    def __repr__(self):
451
 
        return '%s()' % (self.__class__.__name__, )
452
 
 
453
 
 
454
 
class SilentUIFactory(NoninteractiveUIFactory):
 
211
 
 
212
 
 
213
class CLIUIFactory(UIFactory):
 
214
    """Deprecated in favor of TextUIFactory."""
 
215
 
 
216
    @deprecated_method(deprecated_in((1, 18, 0)))
 
217
    def __init__(self, stdin=None, stdout=None, stderr=None):
 
218
        UIFactory.__init__(self)
 
219
        self.stdin = stdin or sys.stdin
 
220
        self.stdout = stdout or sys.stdout
 
221
        self.stderr = stderr or sys.stderr
 
222
 
 
223
    _accepted_boolean_strings = dict(y=True, n=False, yes=True, no=False)
 
224
 
 
225
    def get_boolean(self, prompt):
 
226
        while True:
 
227
            self.prompt(prompt + "? [y/n]: ")
 
228
            line = self.stdin.readline()
 
229
            line = line.rstrip('\n')
 
230
            val = bool_from_string(line, self._accepted_boolean_strings)
 
231
            if val is not None:
 
232
                return val
 
233
 
 
234
    def get_non_echoed_password(self):
 
235
        isatty = getattr(self.stdin, 'isatty', None)
 
236
        if isatty is not None and isatty():
 
237
            # getpass() ensure the password is not echoed and other
 
238
            # cross-platform niceties
 
239
            password = getpass.getpass('')
 
240
        else:
 
241
            # echo doesn't make sense without a terminal
 
242
            password = self.stdin.readline()
 
243
            if not password:
 
244
                password = None
 
245
            elif password[-1] == '\n':
 
246
                password = password[:-1]
 
247
        return password
 
248
 
 
249
    def get_password(self, prompt='', **kwargs):
 
250
        """Prompt the user for a password.
 
251
 
 
252
        :param prompt: The prompt to present the user
 
253
        :param kwargs: Arguments which will be expanded into the prompt.
 
254
                       This lets front ends display different things if
 
255
                       they so choose.
 
256
        :return: The password string, return None if the user
 
257
                 canceled the request.
 
258
        """
 
259
        prompt += ': '
 
260
        self.prompt(prompt, **kwargs)
 
261
        # There's currently no way to say 'i decline to enter a password'
 
262
        # as opposed to 'my password is empty' -- does it matter?
 
263
        return self.get_non_echoed_password()
 
264
 
 
265
    def get_username(self, prompt, **kwargs):
 
266
        """Prompt the user for a username.
 
267
 
 
268
        :param prompt: The prompt to present the user
 
269
        :param kwargs: Arguments which will be expanded into the prompt.
 
270
                       This lets front ends display different things if
 
271
                       they so choose.
 
272
        :return: The username string, return None if the user
 
273
                 canceled the request.
 
274
        """
 
275
        prompt += ': '
 
276
        self.prompt(prompt, **kwargs)
 
277
        username = self.stdin.readline()
 
278
        if not username:
 
279
            username = None
 
280
        elif username[-1] == '\n':
 
281
            username = username[:-1]
 
282
        return username
 
283
 
 
284
    def prompt(self, prompt, **kwargs):
 
285
        """Emit prompt on the CLI.
 
286
        
 
287
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
288
            to allow UIs to reformat the prompt.
 
289
        """
 
290
        if kwargs:
 
291
            # See <https://launchpad.net/bugs/365891>
 
292
            prompt = prompt % kwargs
 
293
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
294
        self.clear_term()
 
295
        self.stderr.write(prompt)
 
296
 
 
297
    def note(self, msg):
 
298
        """Write an already-formatted message."""
 
299
        self.stdout.write(msg + '\n')
 
300
 
 
301
 
 
302
class SilentUIFactory(UIFactory):
455
303
    """A UI Factory which never prints anything.
456
304
 
457
305
    This is the default UI, if another one is never registered by a program
458
 
    using breezy, and it's also active for example inside 'brz serve'.
 
306
    using bzrlib, and it's also active for example inside 'bzr serve'.
459
307
 
460
308
    Methods that try to read from the user raise an error; methods that do
461
309
    output do nothing.
470
318
    def get_username(self, prompt, **kwargs):
471
319
        return None
472
320
 
473
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
474
 
        return NullOutputStream(encoding)
475
 
 
476
 
    def show_error(self, msg):
477
 
        pass
478
 
 
479
 
    def show_message(self, msg):
480
 
        pass
481
 
 
482
 
    def show_warning(self, msg):
483
 
        pass
484
 
 
485
321
 
486
322
class CannedInputUIFactory(SilentUIFactory):
487
323
    """A silent UI that return canned input."""
492
328
    def __repr__(self):
493
329
        return "%s(%r)" % (self.__class__.__name__, self.responses)
494
330
 
495
 
    def confirm_action(self, prompt, confirmation_id, args):
496
 
        return self.get_boolean(prompt % args)
497
 
 
498
331
    def get_boolean(self, prompt):
499
332
        return self.responses.pop(0)
500
333
 
501
 
    def get_integer(self, prompt):
502
 
        return self.responses.pop(0)
503
 
 
504
 
    def get_password(self, prompt=u'', **kwargs):
 
334
    def get_password(self, prompt='', **kwargs):
505
335
        return self.responses.pop(0)
506
336
 
507
337
    def get_username(self, prompt, **kwargs):
508
338
        return self.responses.pop(0)
509
 
 
 
339
    
510
340
    def assert_all_input_consumed(self):
511
341
        if self.responses:
512
342
            raise AssertionError("expected all input in %r to be consumed"
513
 
                                 % (self,))
 
343
                % (self,))
 
344
 
 
345
 
 
346
@deprecated_function(deprecated_in((1, 18, 0)))
 
347
def clear_decorator(func, *args, **kwargs):
 
348
    """Decorator that clears the term"""
 
349
    ui_factory.clear_term()
 
350
    func(*args, **kwargs)
514
351
 
515
352
 
516
353
ui_factory = SilentUIFactory()
523
360
    """
524
361
    # this is now always TextUIFactory, which in turn decides whether it
525
362
    # should display progress bars etc
526
 
    from .text import TextUIFactory
 
363
    from bzrlib.ui.text import TextUIFactory
527
364
    return TextUIFactory(stdin, stdout, stderr)
528
365
 
529
366
 
538
375
 
539
376
    def show_transport_activity(self, transport, direction, byte_count):
540
377
        pass
541
 
 
542
 
    def log_transport_activity(self, display=False):
543
 
        pass
544
 
 
545
 
 
546
 
class NullOutputStream(object):
547
 
    """Acts like a file, but discard all output."""
548
 
 
549
 
    def __init__(self, encoding):
550
 
        self.encoding = encoding
551
 
 
552
 
    def write(self, data):
553
 
        pass
554
 
 
555
 
    def writelines(self, data):
556
 
        pass
557
 
 
558
 
    def close(self):
559
 
        pass