~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 08:40:16 UTC
  • mfrom: (5642.4.6 712474-module-available)
  • Revision ID: pqm@pqm.ubuntu.com-20110817084016-600z65qzqmmt44w7
(vila) ModuleAvailableFeature don't try to imported already imported
 modules. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
42
42
"""
43
43
 
44
44
 
45
 
import os
46
 
import sys
47
45
import warnings
48
46
 
49
47
from bzrlib.lazy_import import lazy_import
50
48
lazy_import(globals(), """
51
 
import getpass
52
 
 
53
49
from bzrlib import (
54
 
    errors,
 
50
    config,
55
51
    osutils,
56
52
    progress,
57
53
    trace,
58
54
    )
59
55
""")
60
 
from bzrlib.symbol_versioning import (
61
 
    deprecated_function,
62
 
    deprecated_in,
63
 
    deprecated_method,
64
 
    )
65
56
 
66
57
 
67
58
_valid_boolean_strings = dict(yes=True, no=False,
100
91
    return val
101
92
 
102
93
 
 
94
class ConfirmationUserInterfacePolicy(object):
 
95
    """Wrapper for a UIFactory that allows or denies all confirmed actions."""
 
96
 
 
97
    def __init__(self, wrapped_ui, default_answer, specific_answers):
 
98
        """Generate a proxy UI that does no confirmations.
 
99
 
 
100
        :param wrapped_ui: Underlying UIFactory.
 
101
        :param default_answer: Bool for whether requests for
 
102
            confirmation from the user should be noninteractively accepted or
 
103
            denied.
 
104
        :param specific_answers: Map from confirmation_id to bool answer.
 
105
        """
 
106
        self.wrapped_ui = wrapped_ui
 
107
        self.default_answer = default_answer
 
108
        self.specific_answers = specific_answers
 
109
 
 
110
    def __getattr__(self, name):
 
111
        return getattr(self.wrapped_ui, name)
 
112
 
 
113
    def __repr__(self):
 
114
        return '%s(%r, %r, %r)' % (
 
115
            self.__class__.__name__,
 
116
            self.wrapped_ui,
 
117
            self.default_answer, 
 
118
            self.specific_answers)
 
119
 
 
120
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
121
        if confirmation_id in self.specific_answers:
 
122
            return self.specific_answers[confirmation_id]
 
123
        elif self.default_answer is not None:
 
124
            return self.default_answer
 
125
        else:
 
126
            return self.wrapped_ui.confirm_action(
 
127
                prompt, confirmation_id, prompt_kwargs)
 
128
 
 
129
 
103
130
class UIFactory(object):
104
131
    """UI abstraction.
105
132
 
106
133
    This tells the library how to display things to the user.  Through this
107
134
    layer different applications can choose the style of UI.
 
135
 
 
136
    UI Factories are also context managers, for some syntactic sugar some users
 
137
    need.
 
138
 
 
139
    :ivar suppressed_warnings: Identifiers for user warnings that should 
 
140
        no be emitted.
108
141
    """
109
142
 
 
143
    _user_warning_templates = dict(
 
144
        cross_format_fetch=("Doing on-the-fly conversion from "
 
145
            "%(from_format)s to %(to_format)s.\n"
 
146
            "This may take some time. Upgrade the repositories to the "
 
147
            "same format for better performance."
 
148
            ),
 
149
        experimental_format_fetch=("Fetching into experimental format "
 
150
            "%(to_format)s.\n"
 
151
            "This format may be unreliable or change in the future "
 
152
            "without an upgrade path.\n"),
 
153
        deprecated_command=(
 
154
            "The command 'bzr %(deprecated_name)s' "
 
155
            "has been deprecated in bzr %(deprecated_in_version)s. "
 
156
            "Please use 'bzr %(recommended_name)s' instead."),
 
157
        recommend_upgrade=("%(current_format_name)s is deprecated "
 
158
            "and a better format is available.\n"
 
159
            "It is recommended that you upgrade by "
 
160
            "running the command\n"
 
161
            "  bzr upgrade %(basedir)s"),
 
162
        locks_steal_dead=(
 
163
            u"Stole dead lock %(lock_url)s %(other_holder_info)s."),
 
164
        )
 
165
 
110
166
    def __init__(self):
111
167
        self._task_stack = []
 
168
        self.suppressed_warnings = set()
112
169
        self._quiet = False
113
170
 
 
171
    def __enter__(self):
 
172
        """Context manager entry support.
 
173
 
 
174
        Override in a concrete factory class if initialisation before use is
 
175
        needed.
 
176
        """
 
177
        return self # This is bound to the 'as' clause in a with statement.
 
178
 
 
179
    def __exit__(self, exc_type, exc_val, exc_tb):
 
180
        """Context manager exit support.
 
181
 
 
182
        Override in a concrete factory class if more cleanup than a simple
 
183
        self.clear_term() is needed when the UIFactory is finished with.
 
184
        """
 
185
        self.clear_term()
 
186
        return False # propogate exceptions.
 
187
 
114
188
    def be_quiet(self, state):
115
189
        """Tell the UI to be more quiet, or not.
116
190
 
119
193
        """
120
194
        self._quiet = state
121
195
 
122
 
    def get_password(self, prompt='', **kwargs):
 
196
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
197
        """Seek user confirmation for an action.
 
198
 
 
199
        If the UI is noninteractive, or the user does not want to be asked
 
200
        about this action, True is returned, indicating bzr should just
 
201
        proceed.
 
202
 
 
203
        The confirmation id allows the user to configure certain actions to
 
204
        always be confirmed or always denied, and for UIs to specialize the
 
205
        display of particular confirmations.
 
206
 
 
207
        :param prompt: Suggested text to display to the user.
 
208
        :param prompt_kwargs: A dictionary of arguments that can be
 
209
            string-interpolated into the prompt.
 
210
        :param confirmation_id: Unique string identifier for the confirmation.
 
211
        """
 
212
        return self.get_boolean(prompt % prompt_kwargs)
 
213
 
 
214
    def get_password(self, prompt=u'', **kwargs):
123
215
        """Prompt the user for a password.
124
216
 
125
 
        :param prompt: The prompt to present the user
 
217
        :param prompt: The prompt to present the user (must be unicode)
126
218
        :param kwargs: Arguments which will be expanded into the prompt.
127
219
                       This lets front ends display different things if
128
220
                       they so choose.
146
238
        version of stdout, but in a GUI it might be appropriate to send it to a 
147
239
        window displaying the text.
148
240
     
149
 
        :param encoding: Unicode encoding for output; default is the 
150
 
            terminal encoding, which may be different from the user encoding.
 
241
        :param encoding: Unicode encoding for output; if not specified 
 
242
            uses the configured 'output_encoding' if any; otherwise the 
 
243
            terminal encoding. 
151
244
            (See get_terminal_encoding.)
152
245
 
153
246
        :param encoding_type: How to handle encoding errors:
155
248
        """
156
249
        # XXX: is the caller supposed to close the resulting object?
157
250
        if encoding is None:
158
 
            encoding = osutils.get_terminal_encoding()
 
251
            encoding = config.GlobalStack().get('output_encoding')
 
252
        if encoding is None:
 
253
            encoding = osutils.get_terminal_encoding(trace=True)
159
254
        if encoding_type is None:
160
255
            encoding_type = 'replace'
161
256
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
210
305
        """
211
306
        pass
212
307
 
 
308
    def format_user_warning(self, warning_id, message_args):
 
309
        try:
 
310
            template = self._user_warning_templates[warning_id]
 
311
        except KeyError:
 
312
            fail = "bzr warning: %r, %r" % (warning_id, message_args)
 
313
            warnings.warn("no template for warning: " + fail)   # so tests will fail etc
 
314
            return fail
 
315
        try:
 
316
            return template % message_args
 
317
        except ValueError, e:
 
318
            fail = "bzr unprintable warning: %r, %r, %s" % (
 
319
                warning_id, message_args, e)
 
320
            warnings.warn(fail)   # so tests will fail etc
 
321
            return fail
 
322
 
213
323
    def get_boolean(self, prompt):
214
324
        """Get a boolean question answered from the user.
215
325
 
216
326
        :param prompt: a message to prompt the user with. Should be a single
217
 
        line without terminating \n.
 
327
            line without terminating \\n.
218
328
        :return: True or False for y/yes or n/no.
219
329
        """
220
330
        raise NotImplementedError(self.get_boolean)
223
333
        """Get an integer from the user.
224
334
 
225
335
        :param prompt: a message to prompt the user with. Could be a multi-line
226
 
            prompt but without a terminating \n.
 
336
            prompt but without a terminating \\n.
227
337
 
228
338
        :return: A signed integer.
229
339
        """
237
347
        """
238
348
        return NullProgressView()
239
349
 
240
 
    def recommend_upgrade(self,
241
 
        current_format_name,
242
 
        basedir):
243
 
        # this should perhaps be in the TextUIFactory and the default can do
244
 
        # nothing
245
 
        trace.warning("%s is deprecated "
246
 
            "and a better format is available.\n"
247
 
            "It is recommended that you upgrade by "
248
 
            "running the command\n"
249
 
            "  bzr upgrade %s",
250
 
            current_format_name,
251
 
            basedir)
 
350
    def recommend_upgrade(self, current_format_name, basedir):
 
351
        """Recommend the user upgrade a control directory.
 
352
 
 
353
        :param current_format_name: Description of the current format
 
354
        :param basedir: Location of the control dir
 
355
        """
 
356
        self.show_user_warning('recommend_upgrade',
 
357
            current_format_name=current_format_name, basedir=basedir)
252
358
 
253
359
    def report_transport_activity(self, transport, byte_count, direction):
254
360
        """Called by transports as they do IO.
271
377
        # Default implementation just does nothing
272
378
        pass
273
379
 
 
380
    def show_user_warning(self, warning_id, **message_args):
 
381
        """Show a warning to the user.
 
382
 
 
383
        This is specifically for things that are under the user's control (eg
 
384
        outdated formats), not for internal program warnings like deprecated
 
385
        APIs.
 
386
 
 
387
        This can be overridden by UIFactory subclasses to show it in some 
 
388
        appropriate way; the default UIFactory is noninteractive and does
 
389
        nothing.  format_user_warning maps it to a string, though other
 
390
        presentations can be used for particular UIs.
 
391
 
 
392
        :param warning_id: An identifier like 'cross_format_fetch' used to 
 
393
            check if the message is suppressed and to look up the string.
 
394
        :param message_args: Arguments to be interpolated into the message.
 
395
        """
 
396
        pass
 
397
 
274
398
    def show_error(self, msg):
275
399
        """Show an error message (not an exception) to the user.
276
400
        
287
411
        """Show a warning to the user."""
288
412
        raise NotImplementedError(self.show_warning)
289
413
 
290
 
    def warn_cross_format_fetch(self, from_format, to_format):
291
 
        """Warn about a potentially slow cross-format transfer"""
292
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
293
 
        trace.warning("Doing on-the-fly conversion from %s to %s.\n"
294
 
            "This may take some time. Upgrade the repositories to the "
295
 
            "same format for better performance.\n" %
296
 
            (from_format, to_format))
297
 
 
298
 
    def warn_experimental_format_fetch(self, inter):
299
 
        """Warn about fetching into experimental repository formats."""
300
 
        if inter.target._format.experimental:
301
 
            trace.warning("Fetching into experimental format %s.\n"
302
 
                "This format may be unreliable or change in the future "
303
 
                "without an upgrade path.\n" % (inter.target._format,))
304
 
 
305
 
 
306
 
 
307
 
class SilentUIFactory(UIFactory):
 
414
 
 
415
class NoninteractiveUIFactory(UIFactory):
 
416
    """Base class for UIs with no user."""
 
417
 
 
418
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
419
        return True
 
420
 
 
421
    def __repr__(self):
 
422
        return '%s()' % (self.__class__.__name__, )
 
423
 
 
424
 
 
425
class SilentUIFactory(NoninteractiveUIFactory):
308
426
    """A UI Factory which never prints anything.
309
427
 
310
428
    This is the default UI, if another one is never registered by a program
345
463
    def __repr__(self):
346
464
        return "%s(%r)" % (self.__class__.__name__, self.responses)
347
465
 
 
466
    def confirm_action(self, prompt, confirmation_id, args):
 
467
        return self.get_boolean(prompt % args)
 
468
 
348
469
    def get_boolean(self, prompt):
349
470
        return self.responses.pop(0)
350
471
 
351
472
    def get_integer(self, prompt):
352
473
        return self.responses.pop(0)
353
474
 
354
 
    def get_password(self, prompt='', **kwargs):
 
475
    def get_password(self, prompt=u'', **kwargs):
355
476
        return self.responses.pop(0)
356
477
 
357
478
    def get_username(self, prompt, **kwargs):