/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/__init__.py
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
22
22
Several levels are supported, and you can also register new factories such as
23
23
for a GUI.
24
24
 
25
 
breezy.ui.UIFactory
 
25
bzrlib.ui.UIFactory
26
26
    Semi-abstract base class
27
27
 
28
 
breezy.ui.SilentUIFactory
 
28
bzrlib.ui.SilentUIFactory
29
29
    Produces no output and cannot take any input; useful for programs using
30
 
    breezy in batch mode or for programs such as loggerhead.
 
30
    bzrlib in batch mode or for programs such as loggerhead.
31
31
 
32
 
breezy.ui.CannedInputUIFactory
33
 
    For use in testing; the input values to be returned are provided
 
32
bzrlib.ui.CannedInputUIFactory
 
33
    For use in testing; the input values to be returned are provided 
34
34
    at construction.
35
35
 
36
 
breezy.ui.text.TextUIFactory
 
36
bzrlib.ui.text.TextUIFactory
37
37
    Standard text command-line interface, with stdin, stdout, stderr.
38
38
    May make more or less advanced use of them, eg in drawing progress bars,
39
39
    depending on the detected capabilities of the terminal.
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
 
from ..lazy_import import lazy_import
 
49
from bzrlib.lazy_import import lazy_import
49
50
lazy_import(globals(), """
50
 
from breezy import (
51
 
    config,
 
51
import getpass
 
52
 
 
53
from bzrlib import (
 
54
    errors,
52
55
    osutils,
53
56
    progress,
 
57
    trace,
54
58
    )
55
59
""")
56
 
 
57
 
from ..sixish import (
58
 
    PY3,
59
 
    string_types,
60
 
    text_type,
 
60
from bzrlib.symbol_versioning import (
 
61
    deprecated_function,
 
62
    deprecated_in,
 
63
    deprecated_method,
61
64
    )
62
65
 
63
66
 
89
92
    if accepted_values is None:
90
93
        accepted_values = _valid_boolean_strings
91
94
    val = None
92
 
    if isinstance(s, string_types):
 
95
    if type(s) in (str, unicode):
93
96
        try:
94
97
            val = accepted_values[s.lower()]
95
98
        except KeyError:
97
100
    return val
98
101
 
99
102
 
100
 
class ConfirmationUserInterfacePolicy(object):
101
 
    """Wrapper for a UIFactory that allows or denies all confirmed actions."""
102
 
 
103
 
    def __init__(self, wrapped_ui, default_answer, specific_answers):
104
 
        """Generate a proxy UI that does no confirmations.
105
 
 
106
 
        :param wrapped_ui: Underlying UIFactory.
107
 
        :param default_answer: Bool for whether requests for
108
 
            confirmation from the user should be noninteractively accepted or
109
 
            denied.
110
 
        :param specific_answers: Map from confirmation_id to bool answer.
111
 
        """
112
 
        self.wrapped_ui = wrapped_ui
113
 
        self.default_answer = default_answer
114
 
        self.specific_answers = specific_answers
115
 
 
116
 
    def __getattr__(self, name):
117
 
        return getattr(self.wrapped_ui, name)
118
 
 
119
 
    def __repr__(self):
120
 
        return '%s(%r, %r, %r)' % (
121
 
            self.__class__.__name__,
122
 
            self.wrapped_ui,
123
 
            self.default_answer,
124
 
            self.specific_answers)
125
 
 
126
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
127
 
        if confirmation_id in self.specific_answers:
128
 
            return self.specific_answers[confirmation_id]
129
 
        elif self.default_answer is not None:
130
 
            return self.default_answer
131
 
        else:
132
 
            return self.wrapped_ui.confirm_action(
133
 
                prompt, confirmation_id, prompt_kwargs)
134
 
 
135
 
 
136
103
class UIFactory(object):
137
104
    """UI abstraction.
138
105
 
139
106
    This tells the library how to display things to the user.  Through this
140
107
    layer different applications can choose the style of UI.
141
108
 
142
 
    UI Factories are also context managers, for some syntactic sugar some users
143
 
    need.
144
 
 
145
 
    :ivar suppressed_warnings: Identifiers for user warnings that should
 
109
    :ivar suppressed_warnings: Identifiers for user warnings that should 
146
110
        no be emitted.
147
111
    """
148
112
 
149
113
    _user_warning_templates = dict(
150
114
        cross_format_fetch=("Doing on-the-fly conversion from "
151
 
                            "%(from_format)s to %(to_format)s.\n"
152
 
                            "This may take some time. Upgrade the repositories to the "
153
 
                            "same format for better performance."
154
 
                            ),
155
 
        experimental_format_fetch=("Fetching into experimental format "
156
 
                                   "%(to_format)s.\n"
157
 
                                   "This format may be unreliable or change in the future "
158
 
                                   "without an upgrade path.\n"),
159
 
        deprecated_command=(
160
 
            "The command 'brz %(deprecated_name)s' "
161
 
            "has been deprecated in brz %(deprecated_in_version)s. "
162
 
            "Please use 'brz %(recommended_name)s' instead."),
163
 
        deprecated_command_option=(
164
 
            "The option '%(deprecated_name)s' to 'brz %(command)s' "
165
 
            "has been deprecated in brz %(deprecated_in_version)s. "
166
 
            "Please use '%(recommended_name)s' instead."),
167
 
        recommend_upgrade=("%(current_format_name)s is deprecated "
168
 
                           "and a better format is available.\n"
169
 
                           "It is recommended that you upgrade by "
170
 
                           "running the command\n"
171
 
                           "  brz upgrade %(basedir)s"),
172
 
        locks_steal_dead=(
173
 
            u"Stole dead lock %(lock_url)s %(other_holder_info)s."),
174
 
        not_checking_ssl_cert=(
175
 
            u"Not checking SSL certificate for %(host)s."),
 
115
            "%(from_format)s to %(to_format)s.\n"
 
116
            "This may take some time. Upgrade the repositories to the "
 
117
            "same format for better performance."
 
118
            )
176
119
        )
177
120
 
178
121
    def __init__(self):
180
123
        self.suppressed_warnings = set()
181
124
        self._quiet = False
182
125
 
183
 
    def __enter__(self):
184
 
        """Context manager entry support.
185
 
 
186
 
        Override in a concrete factory class if initialisation before use is
187
 
        needed.
188
 
        """
189
 
        return self  # This is bound to the 'as' clause in a with statement.
190
 
 
191
 
    def __exit__(self, exc_type, exc_val, exc_tb):
192
 
        """Context manager exit support.
193
 
 
194
 
        Override in a concrete factory class if more cleanup than a simple
195
 
        self.clear_term() is needed when the UIFactory is finished with.
196
 
        """
197
 
        self.clear_term()
198
 
        return False  # propogate exceptions.
199
 
 
200
126
    def be_quiet(self, state):
201
127
        """Tell the UI to be more quiet, or not.
202
128
 
205
131
        """
206
132
        self._quiet = state
207
133
 
208
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
209
 
        """Seek user confirmation for an action.
210
 
 
211
 
        If the UI is noninteractive, or the user does not want to be asked
212
 
        about this action, True is returned, indicating brz should just
213
 
        proceed.
214
 
 
215
 
        The confirmation id allows the user to configure certain actions to
216
 
        always be confirmed or always denied, and for UIs to specialize the
217
 
        display of particular confirmations.
218
 
 
219
 
        :param prompt: Suggested text to display to the user.
220
 
        :param prompt_kwargs: A dictionary of arguments that can be
221
 
            string-interpolated into the prompt.
222
 
        :param confirmation_id: Unique string identifier for the confirmation.
223
 
        """
224
 
        return self.get_boolean(prompt % prompt_kwargs)
225
 
 
226
 
    def get_password(self, prompt=u'', **kwargs):
 
134
    def get_password(self, prompt='', **kwargs):
227
135
        """Prompt the user for a password.
228
136
 
229
 
        :param prompt: The prompt to present the user (must be unicode)
 
137
        :param prompt: The prompt to present the user
230
138
        :param kwargs: Arguments which will be expanded into the prompt.
231
139
                       This lets front ends display different things if
232
140
                       they so choose.
241
149
    def is_quiet(self):
242
150
        return self._quiet
243
151
 
244
 
    def make_output_stream(self, encoding=None, encoding_type='replace'):
 
152
    def make_output_stream(self, encoding=None, encoding_type=None):
245
153
        """Get a stream for sending out bulk text data.
246
154
 
247
155
        This is used for commands that produce bulk text, such as log or diff
248
156
        output, as opposed to user interaction.  This should work even for
249
157
        non-interactive user interfaces.  Typically this goes to a decorated
250
 
        version of stdout, but in a GUI it might be appropriate to send it to a
 
158
        version of stdout, but in a GUI it might be appropriate to send it to a 
251
159
        window displaying the text.
252
 
 
253
 
        The caller may flush but should not close the returned stream.
254
 
 
255
 
        :param encoding: Unicode encoding for output; if not specified
256
 
            uses the configured 'output_encoding' if any; otherwise the
257
 
            terminal encoding.
 
160
     
 
161
        :param encoding: Unicode encoding for output; default is the 
 
162
            terminal encoding, which may be different from the user encoding.
258
163
            (See get_terminal_encoding.)
259
164
 
260
165
        :param encoding_type: How to handle encoding errors:
261
166
            replace/strict/escape/exact.  Default is replace.
262
167
        """
 
168
        # XXX: is the caller supposed to close the resulting object?
 
169
        if encoding is None:
 
170
            encoding = osutils.get_terminal_encoding()
 
171
        if encoding_type is None:
 
172
            encoding_type = 'replace'
263
173
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
264
174
        return out_stream
265
175
 
266
176
    def _make_output_stream_explicit(self, encoding, encoding_type):
267
177
        raise NotImplementedError("%s doesn't support make_output_stream"
268
 
                                  % (self.__class__.__name__))
 
178
            % (self.__class__.__name__))
269
179
 
270
180
    def nested_progress_bar(self):
271
181
        """Return a nested progress bar.
284
194
        """Called by the ProgressTask when it finishes"""
285
195
        if not self._task_stack:
286
196
            warnings.warn("%r finished but nothing is active"
287
 
                          % (task,))
 
197
                % (task,))
288
198
        if task in self._task_stack:
289
199
            self._task_stack.remove(task)
290
200
        else:
291
201
            warnings.warn("%r is not in active stack %r"
292
 
                          % (task, self._task_stack))
 
202
                % (task, self._task_stack))
293
203
        if not self._task_stack:
294
204
            self._progress_all_finished()
295
205
 
316
226
        try:
317
227
            template = self._user_warning_templates[warning_id]
318
228
        except KeyError:
319
 
            fail = "brz warning: %r, %r" % (warning_id, message_args)
320
 
            warnings.warn("no template for warning: "
321
 
                          + fail)   # so tests will fail etc
322
 
            return text_type(fail)
 
229
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
 
230
            warnings.warn(fail)   # so tests will fail etc
 
231
            return fail
323
232
        try:
324
 
            return text_type(template) % message_args
325
 
        except ValueError as e:
326
 
            fail = "brz unprintable warning: %r, %r, %s" % (
 
233
            return template % message_args
 
234
        except ValueError, e:
 
235
            fail = "failed to format warning %r, %r: %s" % (
327
236
                warning_id, message_args, e)
328
237
            warnings.warn(fail)   # so tests will fail etc
329
 
            return text_type(fail)
330
 
 
331
 
    def choose(self, msg, choices, default=None):
332
 
        """Prompt the user for a list of alternatives.
333
 
 
334
 
        :param msg: message to be shown as part of the prompt.
335
 
 
336
 
        :param choices: list of choices, with the individual choices separated
337
 
            by '\n', e.g.: choose("Save changes?", "&Yes\n&No\n&Cancel"). The
338
 
            letter after the '&' is the shortcut key for that choice. Thus you
339
 
            can type 'c' to select "Cancel".  Shorcuts are case insensitive.
340
 
            The shortcut does not need to be the first letter. If a shorcut key
341
 
            is not provided, the first letter for the choice will be used.
342
 
 
343
 
        :param default: default choice (index), returned for example when enter
344
 
            is pressed for the console version.
345
 
 
346
 
        :return: the index fo the user choice (so '0', '1' or '2' for
347
 
            respectively yes/no/cancel in the previous example).
348
 
        """
349
 
        raise NotImplementedError(self.choose)
 
238
            return fail
350
239
 
351
240
    def get_boolean(self, prompt):
352
241
        """Get a boolean question answered from the user.
353
242
 
354
243
        :param prompt: a message to prompt the user with. Should be a single
355
 
            line without terminating \\n.
 
244
        line without terminating \n.
356
245
        :return: True or False for y/yes or n/no.
357
246
        """
358
 
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
359
 
        return 0 == choice
 
247
        raise NotImplementedError(self.get_boolean)
360
248
 
361
249
    def get_integer(self, prompt):
362
250
        """Get an integer from the user.
363
251
 
364
252
        :param prompt: a message to prompt the user with. Could be a multi-line
365
 
            prompt but without a terminating \\n.
 
253
            prompt but without a terminating \n.
366
254
 
367
255
        :return: A signed integer.
368
256
        """
376
264
        """
377
265
        return NullProgressView()
378
266
 
379
 
    def recommend_upgrade(self, current_format_name, basedir):
380
 
        """Recommend the user upgrade a control directory.
381
 
 
382
 
        :param current_format_name: Description of the current format
383
 
        :param basedir: Location of the control dir
384
 
        """
385
 
        self.show_user_warning('recommend_upgrade',
386
 
                               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)
387
282
 
388
283
    def report_transport_activity(self, transport, byte_count, direction):
389
284
        """Called by transports as they do IO.
413
308
        outdated formats), not for internal program warnings like deprecated
414
309
        APIs.
415
310
 
416
 
        This can be overridden by UIFactory subclasses to show it in some
 
311
        This can be overridden by UIFactory subclasses to show it in some 
417
312
        appropriate way; the default UIFactory is noninteractive and does
418
313
        nothing.  format_user_warning maps it to a string, though other
419
314
        presentations can be used for particular UIs.
420
315
 
421
 
        :param warning_id: An identifier like 'cross_format_fetch' used to
 
316
        :param warning_id: An identifier like 'cross_format_fetch' used to 
422
317
            check if the message is suppressed and to look up the string.
423
318
        :param message_args: Arguments to be interpolated into the message.
424
319
        """
426
321
 
427
322
    def show_error(self, msg):
428
323
        """Show an error message (not an exception) to the user.
429
 
 
 
324
        
430
325
        The message should not have an error prefix or trailing newline.  That
431
326
        will be added by the factory if appropriate.
432
327
        """
440
335
        """Show a warning to the user."""
441
336
        raise NotImplementedError(self.show_warning)
442
337
 
443
 
 
444
 
class NoninteractiveUIFactory(UIFactory):
445
 
    """Base class for UIs with no user."""
446
 
 
447
 
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
448
 
        return True
449
 
 
450
 
    def __repr__(self):
451
 
        return '%s()' % (self.__class__.__name__, )
452
 
 
453
 
 
454
 
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):
455
357
    """A UI Factory which never prints anything.
456
358
 
457
359
    This is the default UI, if another one is never registered by a program
458
 
    using breezy, and it's also active for example inside 'brz serve'.
 
360
    using bzrlib, and it's also active for example inside 'bzr serve'.
459
361
 
460
362
    Methods that try to read from the user raise an error; methods that do
461
363
    output do nothing.
492
394
    def __repr__(self):
493
395
        return "%s(%r)" % (self.__class__.__name__, self.responses)
494
396
 
495
 
    def confirm_action(self, prompt, confirmation_id, args):
496
 
        return self.get_boolean(prompt % args)
497
 
 
498
397
    def get_boolean(self, prompt):
499
398
        return self.responses.pop(0)
500
399
 
501
400
    def get_integer(self, prompt):
502
401
        return self.responses.pop(0)
503
402
 
504
 
    def get_password(self, prompt=u'', **kwargs):
 
403
    def get_password(self, prompt='', **kwargs):
505
404
        return self.responses.pop(0)
506
405
 
507
406
    def get_username(self, prompt, **kwargs):
510
409
    def assert_all_input_consumed(self):
511
410
        if self.responses:
512
411
            raise AssertionError("expected all input in %r to be consumed"
513
 
                                 % (self,))
 
412
                % (self,))
514
413
 
515
414
 
516
415
ui_factory = SilentUIFactory()
523
422
    """
524
423
    # this is now always TextUIFactory, which in turn decides whether it
525
424
    # should display progress bars etc
526
 
    from .text import TextUIFactory
 
425
    from bzrlib.ui.text import TextUIFactory
527
426
    return TextUIFactory(stdin, stdout, stderr)
528
427
 
529
428