~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Andrew Bennetts
  • Date: 2010-07-29 04:07:27 UTC
  • mto: (5050.3.16 2.2)
  • mto: This revision was merged to the branch mainline in revision 5365.
  • Revision ID: andrew.bennetts@canonical.com-20100729040727-amlyw1jt3xhw17ku
Delete test_merge_into, and put those tests directly in test_merge.

Show diffs side-by-side

added added

removed removed

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