~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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
42
42
"""
43
43
 
44
44
 
 
45
import os
 
46
import sys
45
47
import warnings
46
48
 
47
49
from bzrlib.lazy_import import lazy_import
48
50
lazy_import(globals(), """
 
51
import getpass
 
52
 
49
53
from bzrlib import (
50
 
    config,
 
54
    errors,
51
55
    osutils,
52
56
    progress,
53
57
    trace,
54
58
    )
55
59
""")
 
60
from bzrlib.symbol_versioning import (
 
61
    deprecated_function,
 
62
    deprecated_in,
 
63
    deprecated_method,
 
64
    )
56
65
 
57
66
 
58
67
_valid_boolean_strings = dict(yes=True, no=False,
91
100
    return val
92
101
 
93
102
 
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
 
 
130
103
class UIFactory(object):
131
104
    """UI abstraction.
132
105
 
133
106
    This tells the library how to display things to the user.  Through this
134
107
    layer different applications can choose the style of UI.
135
108
 
136
 
    UI Factories are also context managers, for some syntactic sugar some users
137
 
    need.
138
 
 
139
109
    :ivar suppressed_warnings: Identifiers for user warnings that should 
140
110
        no be emitted.
141
111
    """
145
115
            "%(from_format)s to %(to_format)s.\n"
146
116
            "This may take some time. Upgrade the repositories to the "
147
117
            "same format for better performance."
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."),
 
118
            )
168
119
        )
169
120
 
170
121
    def __init__(self):
172
123
        self.suppressed_warnings = set()
173
124
        self._quiet = False
174
125
 
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
 
 
192
126
    def be_quiet(self, state):
193
127
        """Tell the UI to be more quiet, or not.
194
128
 
197
131
        """
198
132
        self._quiet = state
199
133
 
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):
 
134
    def get_password(self, prompt='', **kwargs):
219
135
        """Prompt the user for a password.
220
136
 
221
 
        :param prompt: The prompt to present the user (must be unicode)
 
137
        :param prompt: The prompt to present the user
222
138
        :param kwargs: Arguments which will be expanded into the prompt.
223
139
                       This lets front ends display different things if
224
140
                       they so choose.
242
158
        version of stdout, but in a GUI it might be appropriate to send it to a 
243
159
        window displaying the text.
244
160
     
245
 
        :param encoding: Unicode encoding for output; if not specified 
246
 
            uses the configured 'output_encoding' if any; otherwise the 
247
 
            terminal encoding. 
 
161
        :param encoding: Unicode encoding for output; default is the 
 
162
            terminal encoding, which may be different from the user encoding.
248
163
            (See get_terminal_encoding.)
249
164
 
250
165
        :param encoding_type: How to handle encoding errors:
252
167
        """
253
168
        # XXX: is the caller supposed to close the resulting object?
254
169
        if encoding is None:
255
 
            encoding = config.GlobalStack().get('output_encoding')
256
 
        if encoding is None:
257
 
            encoding = osutils.get_terminal_encoding(trace=True)
 
170
            encoding = osutils.get_terminal_encoding()
258
171
        if encoding_type is None:
259
172
            encoding_type = 'replace'
260
173
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
313
226
        try:
314
227
            template = self._user_warning_templates[warning_id]
315
228
        except KeyError:
316
 
            fail = "bzr warning: %r, %r" % (warning_id, message_args)
317
 
            warnings.warn("no template for warning: " + fail)   # so tests will fail etc
 
229
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
 
230
            warnings.warn(fail)   # so tests will fail etc
318
231
            return fail
319
232
        try:
320
233
            return template % message_args
321
234
        except ValueError, e:
322
 
            fail = "bzr unprintable warning: %r, %r, %s" % (
 
235
            fail = "failed to format warning %r, %r: %s" % (
323
236
                warning_id, message_args, e)
324
237
            warnings.warn(fail)   # so tests will fail etc
325
238
            return fail
328
241
        """Get a boolean question answered from the user.
329
242
 
330
243
        :param prompt: a message to prompt the user with. Should be a single
331
 
            line without terminating \\n.
 
244
        line without terminating \n.
332
245
        :return: True or False for y/yes or n/no.
333
246
        """
334
247
        raise NotImplementedError(self.get_boolean)
337
250
        """Get an integer from the user.
338
251
 
339
252
        :param prompt: a message to prompt the user with. Could be a multi-line
340
 
            prompt but without a terminating \\n.
 
253
            prompt but without a terminating \n.
341
254
 
342
255
        :return: A signed integer.
343
256
        """
351
264
        """
352
265
        return NullProgressView()
353
266
 
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)
 
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)
362
282
 
363
283
    def report_transport_activity(self, transport, byte_count, direction):
364
284
        """Called by transports as they do IO.
415
335
        """Show a warning to the user."""
416
336
        raise NotImplementedError(self.show_warning)
417
337
 
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):
 
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):
430
357
    """A UI Factory which never prints anything.
431
358
 
432
359
    This is the default UI, if another one is never registered by a program
467
394
    def __repr__(self):
468
395
        return "%s(%r)" % (self.__class__.__name__, self.responses)
469
396
 
470
 
    def confirm_action(self, prompt, confirmation_id, args):
471
 
        return self.get_boolean(prompt % args)
472
 
 
473
397
    def get_boolean(self, prompt):
474
398
        return self.responses.pop(0)
475
399
 
476
400
    def get_integer(self, prompt):
477
401
        return self.responses.pop(0)
478
402
 
479
 
    def get_password(self, prompt=u'', **kwargs):
 
403
    def get_password(self, prompt='', **kwargs):
480
404
        return self.responses.pop(0)
481
405
 
482
406
    def get_username(self, prompt, **kwargs):