~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

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
 
106
134
    This tells the library how to display things to the user.  Through this
107
135
    layer different applications can choose the style of UI.
108
136
 
 
137
    UI Factories are also context managers, for some syntactic sugar some users
 
138
    need.
 
139
 
109
140
    :ivar suppressed_warnings: Identifiers for user warnings that should 
110
141
        no be emitted.
111
142
    """
115
146
            "%(from_format)s to %(to_format)s.\n"
116
147
            "This may take some time. Upgrade the repositories to the "
117
148
            "same format for better performance."
118
 
            )
 
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."),
119
169
        )
120
170
 
121
171
    def __init__(self):
123
173
        self.suppressed_warnings = set()
124
174
        self._quiet = False
125
175
 
 
176
    def __enter__(self):
 
177
        """Context manager entry support.
 
178
 
 
179
        Override in a concrete factory class if initialisation before use is
 
180
        needed.
 
181
        """
 
182
        return self # This is bound to the 'as' clause in a with statement.
 
183
 
 
184
    def __exit__(self, exc_type, exc_val, exc_tb):
 
185
        """Context manager exit support.
 
186
 
 
187
        Override in a concrete factory class if more cleanup than a simple
 
188
        self.clear_term() is needed when the UIFactory is finished with.
 
189
        """
 
190
        self.clear_term()
 
191
        return False # propogate exceptions.
 
192
 
126
193
    def be_quiet(self, state):
127
194
        """Tell the UI to be more quiet, or not.
128
195
 
131
198
        """
132
199
        self._quiet = state
133
200
 
134
 
    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):
135
220
        """Prompt the user for a password.
136
221
 
137
 
        :param prompt: The prompt to present the user
 
222
        :param prompt: The prompt to present the user (must be unicode)
138
223
        :param kwargs: Arguments which will be expanded into the prompt.
139
224
                       This lets front ends display different things if
140
225
                       they so choose.
158
243
        version of stdout, but in a GUI it might be appropriate to send it to a 
159
244
        window displaying the text.
160
245
     
161
 
        :param encoding: Unicode encoding for output; default is the 
162
 
            terminal encoding, which may be different from the user encoding.
 
246
        :param encoding: Unicode encoding for output; if not specified 
 
247
            uses the configured 'output_encoding' if any; otherwise the 
 
248
            terminal encoding. 
163
249
            (See get_terminal_encoding.)
164
250
 
165
251
        :param encoding_type: How to handle encoding errors:
167
253
        """
168
254
        # XXX: is the caller supposed to close the resulting object?
169
255
        if encoding is None:
170
 
            encoding = osutils.get_terminal_encoding()
 
256
            encoding = config.GlobalStack().get('output_encoding')
 
257
        if encoding is None:
 
258
            encoding = osutils.get_terminal_encoding(trace=True)
171
259
        if encoding_type is None:
172
260
            encoding_type = 'replace'
173
261
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
226
314
        try:
227
315
            template = self._user_warning_templates[warning_id]
228
316
        except KeyError:
229
 
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
230
 
            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
231
319
            return fail
232
320
        try:
233
321
            return template % message_args
234
322
        except ValueError, e:
235
 
            fail = "failed to format warning %r, %r: %s" % (
 
323
            fail = "bzr unprintable warning: %r, %r, %s" % (
236
324
                warning_id, message_args, e)
237
325
            warnings.warn(fail)   # so tests will fail etc
238
326
            return fail
239
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
 
240
348
    def get_boolean(self, prompt):
241
349
        """Get a boolean question answered from the user.
242
350
 
243
351
        :param prompt: a message to prompt the user with. Should be a single
244
 
        line without terminating \n.
 
352
            line without terminating \\n.
245
353
        :return: True or False for y/yes or n/no.
246
354
        """
247
 
        raise NotImplementedError(self.get_boolean)
 
355
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
 
356
        return 0 == choice
248
357
 
249
358
    def get_integer(self, prompt):
250
359
        """Get an integer from the user.
251
360
 
252
361
        :param prompt: a message to prompt the user with. Could be a multi-line
253
 
            prompt but without a terminating \n.
 
362
            prompt but without a terminating \\n.
254
363
 
255
364
        :return: A signed integer.
256
365
        """
264
373
        """
265
374
        return NullProgressView()
266
375
 
267
 
    def recommend_upgrade(self,
268
 
        current_format_name,
269
 
        basedir):
270
 
        # XXX: this should perhaps be in the TextUIFactory and the default can do
271
 
        # nothing
272
 
        #
273
 
        # XXX: Change to show_user_warning - that will accomplish the previous
274
 
        # xxx. -- mbp 2010-02-25
275
 
        trace.warning("%s is deprecated "
276
 
            "and a better format is available.\n"
277
 
            "It is recommended that you upgrade by "
278
 
            "running the command\n"
279
 
            "  bzr upgrade %s",
280
 
            current_format_name,
281
 
            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)
282
384
 
283
385
    def report_transport_activity(self, transport, byte_count, direction):
284
386
        """Called by transports as they do IO.
335
437
        """Show a warning to the user."""
336
438
        raise NotImplementedError(self.show_warning)
337
439
 
338
 
    def warn_cross_format_fetch(self, from_format, to_format):
339
 
        """Warn about a potentially slow cross-format transfer.
340
 
        
341
 
        This is deprecated in favor of show_user_warning, but retained for api
342
 
        compatibility in 2.0 and 2.1.
343
 
        """
344
 
        self.show_user_warning('cross_format_fetch', from_format=from_format,
345
 
            to_format=to_format)
346
 
 
347
 
    def warn_experimental_format_fetch(self, inter):
348
 
        """Warn about fetching into experimental repository formats."""
349
 
        if inter.target._format.experimental:
350
 
            trace.warning("Fetching into experimental format %s.\n"
351
 
                "This format may be unreliable or change in the future "
352
 
                "without an upgrade path.\n" % (inter.target._format,))
353
 
 
354
 
 
355
 
 
356
 
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):
357
452
    """A UI Factory which never prints anything.
358
453
 
359
454
    This is the default UI, if another one is never registered by a program
394
489
    def __repr__(self):
395
490
        return "%s(%r)" % (self.__class__.__name__, self.responses)
396
491
 
 
492
    def confirm_action(self, prompt, confirmation_id, args):
 
493
        return self.get_boolean(prompt % args)
 
494
 
397
495
    def get_boolean(self, prompt):
398
496
        return self.responses.pop(0)
399
497
 
400
498
    def get_integer(self, prompt):
401
499
        return self.responses.pop(0)
402
500
 
403
 
    def get_password(self, prompt='', **kwargs):
 
501
    def get_password(self, prompt=u'', **kwargs):
404
502
        return self.responses.pop(0)
405
503
 
406
504
    def get_username(self, prompt, **kwargs):