~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: John Arbash Meinel
  • Date: 2009-11-18 15:47:16 UTC
  • mto: This revision was merged to the branch mainline in revision 4810.
  • Revision ID: john@arbash-meinel.com-20091118154716-meiszr5ej7ohas3v
Move all the stat comparison and platform checkning code to assertEqualStat.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
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
49
from bzrlib.lazy_import import lazy_import
49
50
lazy_import(globals(), """
 
51
import getpass
 
52
 
50
53
from bzrlib import (
51
 
    config,
 
54
    errors,
52
55
    osutils,
53
56
    progress,
54
57
    trace,
55
58
    )
56
59
""")
 
60
from bzrlib.symbol_versioning import (
 
61
    deprecated_function,
 
62
    deprecated_in,
 
63
    deprecated_method,
 
64
    )
57
65
 
58
66
 
59
67
_valid_boolean_strings = dict(yes=True, no=False,
92
100
    return val
93
101
 
94
102
 
95
 
class ConfirmationUserInterfacePolicy(object):
96
 
    """Wrapper for a UIFactory that allows or denies all confirmed actions."""
97
 
 
98
 
    def __init__(self, wrapped_ui, default_answer, specific_answers):
99
 
        """Generate a proxy UI that does no confirmations.
100
 
 
101
 
        :param wrapped_ui: Underlying UIFactory.
102
 
        :param default_answer: Bool for whether requests for
103
 
            confirmation from the user should be noninteractively accepted or
104
 
            denied.
105
 
        :param specific_answers: Map from confirmation_id to bool answer.
106
 
        """
107
 
        self.wrapped_ui = wrapped_ui
108
 
        self.default_answer = default_answer
109
 
        self.specific_answers = specific_answers
110
 
 
111
 
    def __getattr__(self, name):
112
 
        return getattr(self.wrapped_ui, name)
113
 
 
114
 
    def __repr__(self):
115
 
        return '%s(%r, %r, %r)' % (
116
 
            self.__class__.__name__,
117
 
            self.wrapped_ui,
118
 
            self.default_answer, 
119
 
            self.specific_answers)
120
 
 
121
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
122
 
        if confirmation_id in self.specific_answers:
123
 
            return self.specific_answers[confirmation_id]
124
 
        elif self.default_answer is not None:
125
 
            return self.default_answer
126
 
        else:
127
 
            return self.wrapped_ui.confirm_action(
128
 
                prompt, confirmation_id, prompt_kwargs)
129
 
 
130
 
 
131
103
class UIFactory(object):
132
104
    """UI abstraction.
133
105
 
134
106
    This tells the library how to display things to the user.  Through this
135
107
    layer different applications can choose the style of UI.
136
 
 
137
 
    UI Factories are also context managers, for some syntactic sugar some users
138
 
    need.
139
 
 
140
 
    :ivar suppressed_warnings: Identifiers for user warnings that should 
141
 
        no be emitted.
142
108
    """
143
109
 
144
 
    _user_warning_templates = dict(
145
 
        cross_format_fetch=("Doing on-the-fly conversion from "
146
 
            "%(from_format)s to %(to_format)s.\n"
147
 
            "This may take some time. Upgrade the repositories to the "
148
 
            "same format for better performance."
149
 
            ),
150
 
        experimental_format_fetch=("Fetching into experimental format "
151
 
            "%(to_format)s.\n"
152
 
            "This format may be unreliable or change in the future "
153
 
            "without an upgrade path.\n"),
154
 
        deprecated_command=(
155
 
            "The command 'bzr %(deprecated_name)s' "
156
 
            "has been deprecated in bzr %(deprecated_in_version)s. "
157
 
            "Please use 'bzr %(recommended_name)s' instead."),
158
 
        deprecated_command_option=(
159
 
            "The option '%(deprecated_name)s' to 'bzr %(command)s' "
160
 
            "has been deprecated in bzr %(deprecated_in_version)s. "
161
 
            "Please use '%(recommended_name)s' instead."),
162
 
        recommend_upgrade=("%(current_format_name)s is deprecated "
163
 
            "and a better format is available.\n"
164
 
            "It is recommended that you upgrade by "
165
 
            "running the command\n"
166
 
            "  bzr upgrade %(basedir)s"),
167
 
        locks_steal_dead=(
168
 
            u"Stole dead lock %(lock_url)s %(other_holder_info)s."),
169
 
        not_checking_ssl_cert=(
170
 
            u"Not checking SSL certificate for %(host)s."),
171
 
        )
172
 
 
173
110
    def __init__(self):
174
111
        self._task_stack = []
175
 
        self.suppressed_warnings = set()
176
 
        self._quiet = False
177
 
 
178
 
    def __enter__(self):
179
 
        """Context manager entry support.
180
 
 
181
 
        Override in a concrete factory class if initialisation before use is
182
 
        needed.
183
 
        """
184
 
        return self # This is bound to the 'as' clause in a with statement.
185
 
 
186
 
    def __exit__(self, exc_type, exc_val, exc_tb):
187
 
        """Context manager exit support.
188
 
 
189
 
        Override in a concrete factory class if more cleanup than a simple
190
 
        self.clear_term() is needed when the UIFactory is finished with.
191
 
        """
192
 
        self.clear_term()
193
 
        return False # propogate exceptions.
194
 
 
195
 
    def be_quiet(self, state):
196
 
        """Tell the UI to be more quiet, or not.
197
 
 
198
 
        Typically this suppresses progress bars; the application may also look
199
 
        at ui_factory.is_quiet().
200
 
        """
201
 
        self._quiet = state
202
 
 
203
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
204
 
        """Seek user confirmation for an action.
205
 
 
206
 
        If the UI is noninteractive, or the user does not want to be asked
207
 
        about this action, True is returned, indicating bzr should just
208
 
        proceed.
209
 
 
210
 
        The confirmation id allows the user to configure certain actions to
211
 
        always be confirmed or always denied, and for UIs to specialize the
212
 
        display of particular confirmations.
213
 
 
214
 
        :param prompt: Suggested text to display to the user.
215
 
        :param prompt_kwargs: A dictionary of arguments that can be
216
 
            string-interpolated into the prompt.
217
 
        :param confirmation_id: Unique string identifier for the confirmation.
218
 
        """
219
 
        return self.get_boolean(prompt % prompt_kwargs)
220
 
 
221
 
    def get_password(self, prompt=u'', **kwargs):
 
112
 
 
113
    def get_password(self, prompt='', **kwargs):
222
114
        """Prompt the user for a password.
223
115
 
224
 
        :param prompt: The prompt to present the user (must be unicode)
 
116
        :param prompt: The prompt to present the user
225
117
        :param kwargs: Arguments which will be expanded into the prompt.
226
118
                       This lets front ends display different things if
227
119
                       they so choose.
233
125
        """
234
126
        raise NotImplementedError(self.get_password)
235
127
 
236
 
    def is_quiet(self):
237
 
        return self._quiet
238
 
 
239
 
    def make_output_stream(self, encoding=None, encoding_type=None):
240
 
        """Get a stream for sending out bulk text data.
241
 
 
242
 
        This is used for commands that produce bulk text, such as log or diff
243
 
        output, as opposed to user interaction.  This should work even for
244
 
        non-interactive user interfaces.  Typically this goes to a decorated
245
 
        version of stdout, but in a GUI it might be appropriate to send it to a 
246
 
        window displaying the text.
247
 
     
248
 
        :param encoding: Unicode encoding for output; if not specified 
249
 
            uses the configured 'output_encoding' if any; otherwise the 
250
 
            terminal encoding. 
251
 
            (See get_terminal_encoding.)
252
 
 
253
 
        :param encoding_type: How to handle encoding errors:
254
 
            replace/strict/escape/exact.  Default is replace.
255
 
        """
256
 
        # XXX: is the caller supposed to close the resulting object?
257
 
        if encoding is None:
258
 
            encoding = config.GlobalStack().get('output_encoding')
259
 
        if encoding is None:
260
 
            encoding = osutils.get_terminal_encoding(trace=True)
261
 
        if encoding_type is None:
262
 
            encoding_type = 'replace'
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
 
285
143
        if not self._task_stack:
286
144
            warnings.warn("%r finished but nothing is active"
287
145
                % (task,))
288
 
        if task in self._task_stack:
289
 
            self._task_stack.remove(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 = "bzr warning: %r, %r" % (warning_id, message_args)
320
 
            warnings.warn("no template for warning: " + fail)   # so tests will fail etc
321
 
            return fail
322
 
        try:
323
 
            return template % message_args
324
 
        except ValueError, e:
325
 
            fail = "bzr unprintable warning: %r, %r, %s" % (
326
 
                warning_id, message_args, e)
327
 
            warnings.warn(fail)   # so tests will fail etc
328
 
            return fail
329
 
 
330
 
    def choose(self, msg, choices, default=None):
331
 
        """Prompt the user for a list of alternatives.
332
 
 
333
 
        :param msg: message to be shown as part of the prompt.
334
 
 
335
 
        :param choices: list of choices, with the individual choices separated
336
 
            by '\n', e.g.: choose("Save changes?", "&Yes\n&No\n&Cancel"). The
337
 
            letter after the '&' is the shortcut key for that choice. Thus you
338
 
            can type 'c' to select "Cancel".  Shorcuts are case insensitive.
339
 
            The shortcut does not need to be the first letter. If a shorcut key
340
 
            is not provided, the first letter for the choice will be used.
341
 
 
342
 
        :param default: default choice (index), returned for example when enter
343
 
            is pressed for the console version.
344
 
 
345
 
        :return: the index fo the user choice (so '0', '1' or '2' for
346
 
            respectively yes/no/cancel in the previous example).
347
 
        """
348
 
        raise NotImplementedError(self.choose)
349
 
 
350
173
    def get_boolean(self, prompt):
351
174
        """Get a boolean question answered from the user.
352
175
 
353
176
        :param prompt: a message to prompt the user with. Should be a single
354
 
            line without terminating \\n.
 
177
        line without terminating \n.
355
178
        :return: True or False for y/yes or n/no.
356
179
        """
357
 
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
358
 
        return 0 == choice
359
 
 
360
 
    def get_integer(self, prompt):
361
 
        """Get an integer from the user.
362
 
 
363
 
        :param prompt: a message to prompt the user with. Could be a multi-line
364
 
            prompt but without a terminating \\n.
365
 
 
366
 
        :return: A signed integer.
367
 
        """
368
 
        raise NotImplementedError(self.get_integer)
 
180
        raise NotImplementedError(self.get_boolean)
369
181
 
370
182
    def make_progress_view(self):
371
183
        """Construct a new ProgressView object for this UI.
375
187
        """
376
188
        return NullProgressView()
377
189
 
378
 
    def recommend_upgrade(self, current_format_name, basedir):
379
 
        """Recommend the user upgrade a control directory.
380
 
 
381
 
        :param current_format_name: Description of the current format
382
 
        :param basedir: Location of the control dir
383
 
        """
384
 
        self.show_user_warning('recommend_upgrade',
385
 
            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)
386
202
 
387
203
    def report_transport_activity(self, transport, byte_count, direction):
388
204
        """Called by transports as they do IO.
392
208
        """
393
209
        pass
394
210
 
395
 
    def log_transport_activity(self, display=False):
396
 
        """Write out whatever transport activity has been measured.
397
 
 
398
 
        Implementations are allowed to do nothing, but it is useful if they can
399
 
        write a line to the log file.
400
 
 
401
 
        :param display: If False, only log to disk, if True also try to display
402
 
            a message to the user.
403
 
        :return: None
404
 
        """
405
 
        # Default implementation just does nothing
406
 
        pass
407
 
 
408
 
    def show_user_warning(self, warning_id, **message_args):
409
 
        """Show a warning to the user.
410
 
 
411
 
        This is specifically for things that are under the user's control (eg
412
 
        outdated formats), not for internal program warnings like deprecated
413
 
        APIs.
414
 
 
415
 
        This can be overridden by UIFactory subclasses to show it in some 
416
 
        appropriate way; the default UIFactory is noninteractive and does
417
 
        nothing.  format_user_warning maps it to a string, though other
418
 
        presentations can be used for particular UIs.
419
 
 
420
 
        :param warning_id: An identifier like 'cross_format_fetch' used to 
421
 
            check if the message is suppressed and to look up the string.
422
 
        :param message_args: Arguments to be interpolated into the message.
423
 
        """
424
 
        pass
425
 
 
426
211
    def show_error(self, msg):
427
212
        """Show an error message (not an exception) to the user.
428
213
        
429
214
        The message should not have an error prefix or trailing newline.  That
430
 
        will be added by the factory if appropriate.
 
215
        will be added by the factory if appropriate. 
431
216
        """
432
217
        raise NotImplementedError(self.show_error)
433
218
 
440
225
        raise NotImplementedError(self.show_warning)
441
226
 
442
227
 
443
 
class NoninteractiveUIFactory(UIFactory):
444
 
    """Base class for UIs with no user."""
445
 
 
446
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
447
 
        return True
448
 
 
449
 
    def __repr__(self):
450
 
        return '%s()' % (self.__class__.__name__, )
451
 
 
452
 
 
453
 
class SilentUIFactory(NoninteractiveUIFactory):
 
228
 
 
229
class SilentUIFactory(UIFactory):
454
230
    """A UI Factory which never prints anything.
455
231
 
456
232
    This is the default UI, if another one is never registered by a program
469
245
    def get_username(self, prompt, **kwargs):
470
246
        return None
471
247
 
472
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
473
 
        return NullOutputStream(encoding)
474
 
 
475
248
    def show_error(self, msg):
476
249
        pass
477
250
 
491
264
    def __repr__(self):
492
265
        return "%s(%r)" % (self.__class__.__name__, self.responses)
493
266
 
494
 
    def confirm_action(self, prompt, confirmation_id, args):
495
 
        return self.get_boolean(prompt % args)
496
 
 
497
267
    def get_boolean(self, prompt):
498
268
        return self.responses.pop(0)
499
269
 
500
 
    def get_integer(self, prompt):
501
 
        return self.responses.pop(0)
502
 
 
503
 
    def get_password(self, prompt=u'', **kwargs):
 
270
    def get_password(self, prompt='', **kwargs):
504
271
        return self.responses.pop(0)
505
272
 
506
273
    def get_username(self, prompt, **kwargs):
507
274
        return self.responses.pop(0)
508
 
 
 
275
    
509
276
    def assert_all_input_consumed(self):
510
277
        if self.responses:
511
278
            raise AssertionError("expected all input in %r to be consumed"
537
304
 
538
305
    def show_transport_activity(self, transport, direction, byte_count):
539
306
        pass
540
 
 
541
 
    def log_transport_activity(self, display=False):
542
 
        pass
543
 
 
544
 
 
545
 
class NullOutputStream(object):
546
 
    """Acts like a file, but discard all output."""
547
 
 
548
 
    def __init__(self, encoding):
549
 
        self.encoding = encoding
550
 
 
551
 
    def write(self, data):
552
 
        pass
553
 
 
554
 
    def writelines(self, data):
555
 
        pass
556
 
 
557
 
    def close(self):
558
 
        pass