← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Andrew Starr-Bochicchio
  • Date: 2015-07-31 01:04:41 UTC
  • mto: This revision was merged to the branch mainline in revision 6606.
  • Revision ID: a.starr.b@gmail.com-20150731010441-3domwjjtnjijxlr2
https://launchpad.net/bugs/1480015
Use hexlify() from binascii directly as paramiko removed hexify().

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/__init__.py
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."),
 
169
        not_checking_ssl_cert=(
 
170
            u"Not checking SSL certificate for %(host)s."),
122
171
        )
123
172
 
124
173
    def __init__(self):
151
200
        """
152
201
        self._quiet = state
153
202
 
154
 
    def get_password(self, prompt='', **kwargs):
 
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):
155
222
        """Prompt the user for a password.
156
223
 
157
 
        :param prompt: The prompt to present the user
 
224
        :param prompt: The prompt to present the user (must be unicode)
158
225
        :param kwargs: Arguments which will be expanded into the prompt.
159
226
                       This lets front ends display different things if
160
227
                       they so choose.
188
255
        """
189
256
        # XXX: is the caller supposed to close the resulting object?
190
257
        if encoding is None:
191
 
            from bzrlib import config
192
 
            encoding = config.GlobalConfig().get_user_option(
193
 
                'output_encoding')
 
258
            encoding = config.GlobalStack().get('output_encoding')
194
259
        if encoding is None:
195
260
            encoding = osutils.get_terminal_encoding(trace=True)
196
261
        if encoding_type is None:
251
316
        try:
252
317
            template = self._user_warning_templates[warning_id]
253
318
        except KeyError:
254
 
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
255
 
            warnings.warn(fail)   # so tests will fail etc
 
319
            fail = "bzr warning: %r, %r" % (warning_id, message_args)
 
320
            warnings.warn("no template for warning: " + fail)   # so tests will fail etc
256
321
            return fail
257
322
        try:
258
323
            return template % message_args
259
324
        except ValueError, e:
260
 
            fail = "failed to format warning %r, %r: %s" % (
 
325
            fail = "bzr unprintable warning: %r, %r, %s" % (
261
326
                warning_id, message_args, e)
262
327
            warnings.warn(fail)   # so tests will fail etc
263
328
            return fail
264
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
 
265
350
    def get_boolean(self, prompt):
266
351
        """Get a boolean question answered from the user.
267
352
 
268
353
        :param prompt: a message to prompt the user with. Should be a single
269
 
        line without terminating \n.
 
354
            line without terminating \\n.
270
355
        :return: True or False for y/yes or n/no.
271
356
        """
272
 
        raise NotImplementedError(self.get_boolean)
 
357
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
 
358
        return 0 == choice
273
359
 
274
360
    def get_integer(self, prompt):
275
361
        """Get an integer from the user.
276
362
 
277
363
        :param prompt: a message to prompt the user with. Could be a multi-line
278
 
            prompt but without a terminating \n.
 
364
            prompt but without a terminating \\n.
279
365
 
280
366
        :return: A signed integer.
281
367
        """
289
375
        """
290
376
        return NullProgressView()
291
377
 
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)
 
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)
307
386
 
308
387
    def report_transport_activity(self, transport, byte_count, direction):
309
388
        """Called by transports as they do IO.
360
439
        """Show a warning to the user."""
361
440
        raise NotImplementedError(self.show_warning)
362
441
 
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):
 
442
 
 
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):
381
454
    """A UI Factory which never prints anything.
382
455
 
383
456
    This is the default UI, if another one is never registered by a program
418
491
    def __repr__(self):
419
492
        return "%s(%r)" % (self.__class__.__name__, self.responses)
420
493
 
 
494
    def confirm_action(self, prompt, confirmation_id, args):
 
495
        return self.get_boolean(prompt % args)
 
496
 
421
497
    def get_boolean(self, prompt):
422
498
        return self.responses.pop(0)
423
499
 
424
500
    def get_integer(self, prompt):
425
501
        return self.responses.pop(0)
426
502
 
427
 
    def get_password(self, prompt='', **kwargs):
 
503
    def get_password(self, prompt=u'', **kwargs):
428
504
        return self.responses.pop(0)
429
505
 
430
506
    def get_username(self, prompt, **kwargs):