~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-24 13:14:06 UTC
  • mto: (6445.4.5 nested-trees-spec)
  • mto: This revision was merged to the branch mainline in revision 6518.
  • Revision ID: jelmer@samba.org-20120124131406-wedftkorbpv37bm0
Import nested tree doc from devnotes.

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
41
41
    back to working through the terminal.
42
42
"""
43
43
 
 
44
from __future__ import absolute_import
44
45
 
45
 
import os
46
 
import sys
47
46
import warnings
48
47
 
49
48
from bzrlib.lazy_import import lazy_import
50
49
lazy_import(globals(), """
51
 
import getpass
52
 
 
53
50
from bzrlib import (
54
 
    errors,
 
51
    config,
55
52
    osutils,
56
53
    progress,
57
54
    trace,
58
55
    )
59
56
""")
60
 
from bzrlib.symbol_versioning import (
61
 
    deprecated_function,
62
 
    deprecated_in,
63
 
    deprecated_method,
64
 
    )
65
57
 
66
58
 
67
59
_valid_boolean_strings = dict(yes=True, no=False,
100
92
    return val
101
93
 
102
94
 
 
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
 
103
131
class UIFactory(object):
104
132
    """UI abstraction.
105
133
 
118
146
            "%(from_format)s to %(to_format)s.\n"
119
147
            "This may take some time. Upgrade the repositories to the "
120
148
            "same format for better performance."
121
 
            )
 
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."),
122
169
        )
123
170
 
124
171
    def __init__(self):
151
198
        """
152
199
        self._quiet = state
153
200
 
154
 
    def get_password(self, prompt='', **kwargs):
 
201
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
202
        """Seek user confirmation for an action.
 
203
 
 
204
        If the UI is noninteractive, or the user does not want to be asked
 
205
        about this action, True is returned, indicating bzr should just
 
206
        proceed.
 
207
 
 
208
        The confirmation id allows the user to configure certain actions to
 
209
        always be confirmed or always denied, and for UIs to specialize the
 
210
        display of particular confirmations.
 
211
 
 
212
        :param prompt: Suggested text to display to the user.
 
213
        :param prompt_kwargs: A dictionary of arguments that can be
 
214
            string-interpolated into the prompt.
 
215
        :param confirmation_id: Unique string identifier for the confirmation.
 
216
        """
 
217
        return self.get_boolean(prompt % prompt_kwargs)
 
218
 
 
219
    def get_password(self, prompt=u'', **kwargs):
155
220
        """Prompt the user for a password.
156
221
 
157
 
        :param prompt: The prompt to present the user
 
222
        :param prompt: The prompt to present the user (must be unicode)
158
223
        :param kwargs: Arguments which will be expanded into the prompt.
159
224
                       This lets front ends display different things if
160
225
                       they so choose.
188
253
        """
189
254
        # XXX: is the caller supposed to close the resulting object?
190
255
        if encoding is None:
191
 
            from bzrlib import config
192
 
            encoding = config.GlobalConfig().get_user_option(
193
 
                'output_encoding')
 
256
            encoding = config.GlobalStack().get('output_encoding')
194
257
        if encoding is None:
195
258
            encoding = osutils.get_terminal_encoding(trace=True)
196
259
        if encoding_type is None:
251
314
        try:
252
315
            template = self._user_warning_templates[warning_id]
253
316
        except KeyError:
254
 
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
255
 
            warnings.warn(fail)   # so tests will fail etc
 
317
            fail = "bzr warning: %r, %r" % (warning_id, message_args)
 
318
            warnings.warn("no template for warning: " + fail)   # so tests will fail etc
256
319
            return fail
257
320
        try:
258
321
            return template % message_args
259
322
        except ValueError, e:
260
 
            fail = "failed to format warning %r, %r: %s" % (
 
323
            fail = "bzr unprintable warning: %r, %r, %s" % (
261
324
                warning_id, message_args, e)
262
325
            warnings.warn(fail)   # so tests will fail etc
263
326
            return fail
264
327
 
 
328
    def choose(self, msg, choices, default=None):
 
329
        """Prompt the user for a list of alternatives.
 
330
 
 
331
        :param msg: message to be shown as part of the prompt.
 
332
 
 
333
        :param choices: list of choices, with the individual choices separated
 
334
            by '\n', e.g.: choose("Save changes?", "&Yes\n&No\n&Cancel"). The
 
335
            letter after the '&' is the shortcut key for that choice. Thus you
 
336
            can type 'c' to select "Cancel".  Shorcuts are case insensitive.
 
337
            The shortcut does not need to be the first letter. If a shorcut key
 
338
            is not provided, the first letter for the choice will be used.
 
339
 
 
340
        :param default: default choice (index), returned for example when enter
 
341
            is pressed for the console version.
 
342
 
 
343
        :return: the index fo the user choice (so '0', '1' or '2' for
 
344
            respectively yes/no/cancel in the previous example).
 
345
        """
 
346
        raise NotImplementedError(self.choose)
 
347
 
265
348
    def get_boolean(self, prompt):
266
349
        """Get a boolean question answered from the user.
267
350
 
268
351
        :param prompt: a message to prompt the user with. Should be a single
269
 
        line without terminating \n.
 
352
            line without terminating \\n.
270
353
        :return: True or False for y/yes or n/no.
271
354
        """
272
 
        raise NotImplementedError(self.get_boolean)
 
355
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
 
356
        return 0 == choice
273
357
 
274
358
    def get_integer(self, prompt):
275
359
        """Get an integer from the user.
276
360
 
277
361
        :param prompt: a message to prompt the user with. Could be a multi-line
278
 
            prompt but without a terminating \n.
 
362
            prompt but without a terminating \\n.
279
363
 
280
364
        :return: A signed integer.
281
365
        """
289
373
        """
290
374
        return NullProgressView()
291
375
 
292
 
    def recommend_upgrade(self,
293
 
        current_format_name,
294
 
        basedir):
295
 
        # XXX: this should perhaps be in the TextUIFactory and the default can do
296
 
        # nothing
297
 
        #
298
 
        # XXX: Change to show_user_warning - that will accomplish the previous
299
 
        # xxx. -- mbp 2010-02-25
300
 
        trace.warning("%s is deprecated "
301
 
            "and a better format is available.\n"
302
 
            "It is recommended that you upgrade by "
303
 
            "running the command\n"
304
 
            "  bzr upgrade %s",
305
 
            current_format_name,
306
 
            basedir)
 
376
    def recommend_upgrade(self, current_format_name, basedir):
 
377
        """Recommend the user upgrade a control directory.
 
378
 
 
379
        :param current_format_name: Description of the current format
 
380
        :param basedir: Location of the control dir
 
381
        """
 
382
        self.show_user_warning('recommend_upgrade',
 
383
            current_format_name=current_format_name, basedir=basedir)
307
384
 
308
385
    def report_transport_activity(self, transport, byte_count, direction):
309
386
        """Called by transports as they do IO.
360
437
        """Show a warning to the user."""
361
438
        raise NotImplementedError(self.show_warning)
362
439
 
363
 
    def warn_cross_format_fetch(self, from_format, to_format):
364
 
        """Warn about a potentially slow cross-format transfer.
365
 
        
366
 
        This is deprecated in favor of show_user_warning, but retained for api
367
 
        compatibility in 2.0 and 2.1.
368
 
        """
369
 
        self.show_user_warning('cross_format_fetch', from_format=from_format,
370
 
            to_format=to_format)
371
 
 
372
 
    def warn_experimental_format_fetch(self, inter):
373
 
        """Warn about fetching into experimental repository formats."""
374
 
        if inter.target._format.experimental:
375
 
            trace.warning("Fetching into experimental format %s.\n"
376
 
                "This format may be unreliable or change in the future "
377
 
                "without an upgrade path.\n" % (inter.target._format,))
378
 
 
379
 
 
380
 
class SilentUIFactory(UIFactory):
 
440
 
 
441
class NoninteractiveUIFactory(UIFactory):
 
442
    """Base class for UIs with no user."""
 
443
 
 
444
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
445
        return True
 
446
 
 
447
    def __repr__(self):
 
448
        return '%s()' % (self.__class__.__name__, )
 
449
 
 
450
 
 
451
class SilentUIFactory(NoninteractiveUIFactory):
381
452
    """A UI Factory which never prints anything.
382
453
 
383
454
    This is the default UI, if another one is never registered by a program
418
489
    def __repr__(self):
419
490
        return "%s(%r)" % (self.__class__.__name__, self.responses)
420
491
 
 
492
    def confirm_action(self, prompt, confirmation_id, args):
 
493
        return self.get_boolean(prompt % args)
 
494
 
421
495
    def get_boolean(self, prompt):
422
496
        return self.responses.pop(0)
423
497
 
424
498
    def get_integer(self, prompt):
425
499
        return self.responses.pop(0)
426
500
 
427
 
    def get_password(self, prompt='', **kwargs):
 
501
    def get_password(self, prompt=u'', **kwargs):
428
502
        return self.responses.pop(0)
429
503
 
430
504
    def get_username(self, prompt, **kwargs):