~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Martin von Gagern
  • Date: 2011-09-19 08:49:15 UTC
  • mto: This revision was merged to the branch mainline in revision 6148.
  • Revision ID: martin.vgagern@gmx.net-20110919084915-vbumflqq3xqm1vez
Avoid using deprecated api in the unit tests for bzrlib.missing.

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.
108
135
 
 
136
    UI Factories are also context managers, for some syntactic sugar some users
 
137
    need.
 
138
 
109
139
    :ivar suppressed_warnings: Identifiers for user warnings that should 
110
140
        no be emitted.
111
141
    """
115
145
            "%(from_format)s to %(to_format)s.\n"
116
146
            "This may take some time. Upgrade the repositories to the "
117
147
            "same format for better performance."
118
 
            )
 
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
        deprecated_command_option=(
 
158
            "The option '%(deprecated_name)s' to 'bzr %(command)s' "
 
159
            "has been deprecated in bzr %(deprecated_in_version)s. "
 
160
            "Please use '%(recommended_name)s' instead."),
 
161
        recommend_upgrade=("%(current_format_name)s is deprecated "
 
162
            "and a better format is available.\n"
 
163
            "It is recommended that you upgrade by "
 
164
            "running the command\n"
 
165
            "  bzr upgrade %(basedir)s"),
 
166
        locks_steal_dead=(
 
167
            u"Stole dead lock %(lock_url)s %(other_holder_info)s."),
119
168
        )
120
169
 
121
170
    def __init__(self):
123
172
        self.suppressed_warnings = set()
124
173
        self._quiet = False
125
174
 
 
175
    def __enter__(self):
 
176
        """Context manager entry support.
 
177
 
 
178
        Override in a concrete factory class if initialisation before use is
 
179
        needed.
 
180
        """
 
181
        return self # This is bound to the 'as' clause in a with statement.
 
182
 
 
183
    def __exit__(self, exc_type, exc_val, exc_tb):
 
184
        """Context manager exit support.
 
185
 
 
186
        Override in a concrete factory class if more cleanup than a simple
 
187
        self.clear_term() is needed when the UIFactory is finished with.
 
188
        """
 
189
        self.clear_term()
 
190
        return False # propogate exceptions.
 
191
 
126
192
    def be_quiet(self, state):
127
193
        """Tell the UI to be more quiet, or not.
128
194
 
131
197
        """
132
198
        self._quiet = state
133
199
 
134
 
    def get_password(self, prompt='', **kwargs):
 
200
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
201
        """Seek user confirmation for an action.
 
202
 
 
203
        If the UI is noninteractive, or the user does not want to be asked
 
204
        about this action, True is returned, indicating bzr should just
 
205
        proceed.
 
206
 
 
207
        The confirmation id allows the user to configure certain actions to
 
208
        always be confirmed or always denied, and for UIs to specialize the
 
209
        display of particular confirmations.
 
210
 
 
211
        :param prompt: Suggested text to display to the user.
 
212
        :param prompt_kwargs: A dictionary of arguments that can be
 
213
            string-interpolated into the prompt.
 
214
        :param confirmation_id: Unique string identifier for the confirmation.
 
215
        """
 
216
        return self.get_boolean(prompt % prompt_kwargs)
 
217
 
 
218
    def get_password(self, prompt=u'', **kwargs):
135
219
        """Prompt the user for a password.
136
220
 
137
 
        :param prompt: The prompt to present the user
 
221
        :param prompt: The prompt to present the user (must be unicode)
138
222
        :param kwargs: Arguments which will be expanded into the prompt.
139
223
                       This lets front ends display different things if
140
224
                       they so choose.
158
242
        version of stdout, but in a GUI it might be appropriate to send it to a 
159
243
        window displaying the text.
160
244
     
161
 
        :param encoding: Unicode encoding for output; default is the 
162
 
            terminal encoding, which may be different from the user encoding.
 
245
        :param encoding: Unicode encoding for output; if not specified 
 
246
            uses the configured 'output_encoding' if any; otherwise the 
 
247
            terminal encoding. 
163
248
            (See get_terminal_encoding.)
164
249
 
165
250
        :param encoding_type: How to handle encoding errors:
167
252
        """
168
253
        # XXX: is the caller supposed to close the resulting object?
169
254
        if encoding is None:
170
 
            encoding = osutils.get_terminal_encoding()
 
255
            encoding = config.GlobalStack().get('output_encoding')
 
256
        if encoding is None:
 
257
            encoding = osutils.get_terminal_encoding(trace=True)
171
258
        if encoding_type is None:
172
259
            encoding_type = 'replace'
173
260
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
226
313
        try:
227
314
            template = self._user_warning_templates[warning_id]
228
315
        except KeyError:
229
 
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
230
 
            warnings.warn(fail)   # so tests will fail etc
 
316
            fail = "bzr warning: %r, %r" % (warning_id, message_args)
 
317
            warnings.warn("no template for warning: " + fail)   # so tests will fail etc
231
318
            return fail
232
319
        try:
233
320
            return template % message_args
234
321
        except ValueError, e:
235
 
            fail = "failed to format warning %r, %r: %s" % (
 
322
            fail = "bzr unprintable warning: %r, %r, %s" % (
236
323
                warning_id, message_args, e)
237
324
            warnings.warn(fail)   # so tests will fail etc
238
325
            return fail
241
328
        """Get a boolean question answered from the user.
242
329
 
243
330
        :param prompt: a message to prompt the user with. Should be a single
244
 
        line without terminating \n.
 
331
            line without terminating \\n.
245
332
        :return: True or False for y/yes or n/no.
246
333
        """
247
334
        raise NotImplementedError(self.get_boolean)
250
337
        """Get an integer from the user.
251
338
 
252
339
        :param prompt: a message to prompt the user with. Could be a multi-line
253
 
            prompt but without a terminating \n.
 
340
            prompt but without a terminating \\n.
254
341
 
255
342
        :return: A signed integer.
256
343
        """
264
351
        """
265
352
        return NullProgressView()
266
353
 
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)
 
354
    def recommend_upgrade(self, current_format_name, basedir):
 
355
        """Recommend the user upgrade a control directory.
 
356
 
 
357
        :param current_format_name: Description of the current format
 
358
        :param basedir: Location of the control dir
 
359
        """
 
360
        self.show_user_warning('recommend_upgrade',
 
361
            current_format_name=current_format_name, basedir=basedir)
282
362
 
283
363
    def report_transport_activity(self, transport, byte_count, direction):
284
364
        """Called by transports as they do IO.
335
415
        """Show a warning to the user."""
336
416
        raise NotImplementedError(self.show_warning)
337
417
 
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):
 
418
 
 
419
class NoninteractiveUIFactory(UIFactory):
 
420
    """Base class for UIs with no user."""
 
421
 
 
422
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
423
        return True
 
424
 
 
425
    def __repr__(self):
 
426
        return '%s()' % (self.__class__.__name__, )
 
427
 
 
428
 
 
429
class SilentUIFactory(NoninteractiveUIFactory):
357
430
    """A UI Factory which never prints anything.
358
431
 
359
432
    This is the default UI, if another one is never registered by a program
394
467
    def __repr__(self):
395
468
        return "%s(%r)" % (self.__class__.__name__, self.responses)
396
469
 
 
470
    def confirm_action(self, prompt, confirmation_id, args):
 
471
        return self.get_boolean(prompt % args)
 
472
 
397
473
    def get_boolean(self, prompt):
398
474
        return self.responses.pop(0)
399
475
 
400
476
    def get_integer(self, prompt):
401
477
        return self.responses.pop(0)
402
478
 
403
 
    def get_password(self, prompt='', **kwargs):
 
479
    def get_password(self, prompt=u'', **kwargs):
404
480
        return self.responses.pop(0)
405
481
 
406
482
    def get_username(self, prompt, **kwargs):