/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 breezy/ui/__init__.py

  • Committer: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/ui/__init__.py
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
22
22
Several levels are supported, and you can also register new factories such as
23
23
for a GUI.
24
24
 
25
 
bzrlib.ui.UIFactory
 
25
breezy.ui.UIFactory
26
26
    Semi-abstract base class
27
27
 
28
 
bzrlib.ui.SilentUIFactory
 
28
breezy.ui.SilentUIFactory
29
29
    Produces no output and cannot take any input; useful for programs using
30
 
    bzrlib in batch mode or for programs such as loggerhead.
 
30
    breezy in batch mode or for programs such as loggerhead.
31
31
 
32
 
bzrlib.ui.CannedInputUIFactory
33
 
    For use in testing; the input values to be returned are provided 
 
32
breezy.ui.CannedInputUIFactory
 
33
    For use in testing; the input values to be returned are provided
34
34
    at construction.
35
35
 
36
 
bzrlib.ui.text.TextUIFactory
 
36
breezy.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
 
 
45
 
import os
46
 
import sys
47
44
import warnings
48
45
 
49
 
from bzrlib.lazy_import import lazy_import
 
46
from ..lazy_import import lazy_import
50
47
lazy_import(globals(), """
51
 
import getpass
52
 
 
53
 
from bzrlib import (
54
 
    errors,
 
48
from breezy import (
 
49
    config,
55
50
    osutils,
56
51
    progress,
57
 
    trace,
58
52
    )
59
53
""")
60
 
from bzrlib.symbol_versioning import (
61
 
    deprecated_function,
62
 
    deprecated_in,
63
 
    deprecated_method,
64
 
    )
65
54
 
66
55
 
67
56
_valid_boolean_strings = dict(yes=True, no=False,
92
81
    if accepted_values is None:
93
82
        accepted_values = _valid_boolean_strings
94
83
    val = None
95
 
    if type(s) in (str, unicode):
 
84
    if isinstance(s, str):
96
85
        try:
97
86
            val = accepted_values[s.lower()]
98
87
        except KeyError:
100
89
    return val
101
90
 
102
91
 
 
92
class ConfirmationUserInterfacePolicy(object):
 
93
    """Wrapper for a UIFactory that allows or denies all confirmed actions."""
 
94
 
 
95
    def __init__(self, wrapped_ui, default_answer, specific_answers):
 
96
        """Generate a proxy UI that does no confirmations.
 
97
 
 
98
        :param wrapped_ui: Underlying UIFactory.
 
99
        :param default_answer: Bool for whether requests for
 
100
            confirmation from the user should be noninteractively accepted or
 
101
            denied.
 
102
        :param specific_answers: Map from confirmation_id to bool answer.
 
103
        """
 
104
        self.wrapped_ui = wrapped_ui
 
105
        self.default_answer = default_answer
 
106
        self.specific_answers = specific_answers
 
107
 
 
108
    def __getattr__(self, name):
 
109
        return getattr(self.wrapped_ui, name)
 
110
 
 
111
    def __repr__(self):
 
112
        return '%s(%r, %r, %r)' % (
 
113
            self.__class__.__name__,
 
114
            self.wrapped_ui,
 
115
            self.default_answer,
 
116
            self.specific_answers)
 
117
 
 
118
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
119
        if confirmation_id in self.specific_answers:
 
120
            return self.specific_answers[confirmation_id]
 
121
        elif self.default_answer is not None:
 
122
            return self.default_answer
 
123
        else:
 
124
            return self.wrapped_ui.confirm_action(
 
125
                prompt, confirmation_id, prompt_kwargs)
 
126
 
 
127
 
103
128
class UIFactory(object):
104
129
    """UI abstraction.
105
130
 
106
131
    This tells the library how to display things to the user.  Through this
107
132
    layer different applications can choose the style of UI.
108
133
 
109
 
    :ivar suppressed_warnings: Identifiers for user warnings that should 
 
134
    UI Factories are also context managers, for some syntactic sugar some users
 
135
    need.
 
136
 
 
137
    :ivar suppressed_warnings: Identifiers for user warnings that should
110
138
        no be emitted.
111
139
    """
112
140
 
113
141
    _user_warning_templates = dict(
114
142
        cross_format_fetch=("Doing on-the-fly conversion from "
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
 
            )
 
143
                            "%(from_format)s to %(to_format)s.\n"
 
144
                            "This may take some time. Upgrade the repositories to the "
 
145
                            "same format for better performance."
 
146
                            ),
 
147
        experimental_format_fetch=("Fetching into experimental format "
 
148
                                   "%(to_format)s.\n"
 
149
                                   "This format may be unreliable or change in the future "
 
150
                                   "without an upgrade path.\n"),
 
151
        deprecated_command=(
 
152
            "The command 'brz %(deprecated_name)s' "
 
153
            "has been deprecated in brz %(deprecated_in_version)s. "
 
154
            "Please use 'brz %(recommended_name)s' instead."),
 
155
        deprecated_command_option=(
 
156
            "The option '%(deprecated_name)s' to 'brz %(command)s' "
 
157
            "has been deprecated in brz %(deprecated_in_version)s. "
 
158
            "Please use '%(recommended_name)s' instead."),
 
159
        recommend_upgrade=("%(current_format_name)s is deprecated "
 
160
                           "and a better format is available.\n"
 
161
                           "It is recommended that you upgrade by "
 
162
                           "running the command\n"
 
163
                           "  brz upgrade %(basedir)s"),
 
164
        locks_steal_dead=(
 
165
            u"Stole dead lock %(lock_url)s %(other_holder_info)s."),
 
166
        not_checking_ssl_cert=(
 
167
            u"Not checking SSL certificate for %(host)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 brz 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.
149
233
    def is_quiet(self):
150
234
        return self._quiet
151
235
 
152
 
    def make_output_stream(self, encoding=None, encoding_type=None):
 
236
    def make_output_stream(self, encoding=None, encoding_type='replace'):
153
237
        """Get a stream for sending out bulk text data.
154
238
 
155
239
        This is used for commands that produce bulk text, such as log or diff
156
240
        output, as opposed to user interaction.  This should work even for
157
241
        non-interactive user interfaces.  Typically this goes to a decorated
158
 
        version of stdout, but in a GUI it might be appropriate to send it to a 
 
242
        version of stdout, but in a GUI it might be appropriate to send it to a
159
243
        window displaying the text.
160
 
     
161
 
        :param encoding: Unicode encoding for output; default is the 
162
 
            terminal encoding, which may be different from the user encoding.
 
244
 
 
245
        The caller may flush but should not close the returned stream.
 
246
 
 
247
        :param encoding: Unicode encoding for output; if not specified
 
248
            uses the configured 'output_encoding' if any; otherwise the
 
249
            terminal encoding.
163
250
            (See get_terminal_encoding.)
164
251
 
165
252
        :param encoding_type: How to handle encoding errors:
166
253
            replace/strict/escape/exact.  Default is replace.
167
254
        """
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'
173
255
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
174
256
        return out_stream
175
257
 
176
258
    def _make_output_stream_explicit(self, encoding, encoding_type):
177
259
        raise NotImplementedError("%s doesn't support make_output_stream"
178
 
            % (self.__class__.__name__))
 
260
                                  % (self.__class__.__name__))
179
261
 
180
262
    def nested_progress_bar(self):
181
263
        """Return a nested progress bar.
194
276
        """Called by the ProgressTask when it finishes"""
195
277
        if not self._task_stack:
196
278
            warnings.warn("%r finished but nothing is active"
197
 
                % (task,))
 
279
                          % (task,))
198
280
        if task in self._task_stack:
199
281
            self._task_stack.remove(task)
200
282
        else:
201
283
            warnings.warn("%r is not in active stack %r"
202
 
                % (task, self._task_stack))
 
284
                          % (task, self._task_stack))
203
285
        if not self._task_stack:
204
286
            self._progress_all_finished()
205
287
 
226
308
        try:
227
309
            template = self._user_warning_templates[warning_id]
228
310
        except KeyError:
229
 
            fail = "failed to format warning %r, %r" % (warning_id, message_args)
230
 
            warnings.warn(fail)   # so tests will fail etc
231
 
            return fail
 
311
            fail = "brz warning: %r, %r" % (warning_id, message_args)
 
312
            warnings.warn("no template for warning: "
 
313
                          + fail)   # so tests will fail etc
 
314
            return str(fail)
232
315
        try:
233
 
            return template % message_args
234
 
        except ValueError, e:
235
 
            fail = "failed to format warning %r, %r: %s" % (
 
316
            return str(template) % message_args
 
317
        except ValueError as e:
 
318
            fail = "brz unprintable warning: %r, %r, %s" % (
236
319
                warning_id, message_args, e)
237
320
            warnings.warn(fail)   # so tests will fail etc
238
 
            return fail
 
321
            return str(fail)
 
322
 
 
323
    def choose(self, msg, choices, default=None):
 
324
        """Prompt the user for a list of alternatives.
 
325
 
 
326
        :param msg: message to be shown as part of the prompt.
 
327
 
 
328
        :param choices: list of choices, with the individual choices separated
 
329
            by '\n', e.g.: choose("Save changes?", "&Yes\n&No\n&Cancel"). The
 
330
            letter after the '&' is the shortcut key for that choice. Thus you
 
331
            can type 'c' to select "Cancel".  Shorcuts are case insensitive.
 
332
            The shortcut does not need to be the first letter. If a shorcut key
 
333
            is not provided, the first letter for the choice will be used.
 
334
 
 
335
        :param default: default choice (index), returned for example when enter
 
336
            is pressed for the console version.
 
337
 
 
338
        :return: the index fo the user choice (so '0', '1' or '2' for
 
339
            respectively yes/no/cancel in the previous example).
 
340
        """
 
341
        raise NotImplementedError(self.choose)
239
342
 
240
343
    def get_boolean(self, prompt):
241
344
        """Get a boolean question answered from the user.
242
345
 
243
346
        :param prompt: a message to prompt the user with. Should be a single
244
 
        line without terminating \n.
 
347
            line without terminating \\n.
245
348
        :return: True or False for y/yes or n/no.
246
349
        """
247
 
        raise NotImplementedError(self.get_boolean)
 
350
        choice = self.choose(prompt + '?', '&yes\n&no', default=None)
 
351
        return 0 == choice
248
352
 
249
353
    def get_integer(self, prompt):
250
354
        """Get an integer from the user.
251
355
 
252
356
        :param prompt: a message to prompt the user with. Could be a multi-line
253
 
            prompt but without a terminating \n.
 
357
            prompt but without a terminating \\n.
254
358
 
255
359
        :return: A signed integer.
256
360
        """
264
368
        """
265
369
        return NullProgressView()
266
370
 
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)
 
371
    def recommend_upgrade(self, current_format_name, basedir):
 
372
        """Recommend the user upgrade a control directory.
 
373
 
 
374
        :param current_format_name: Description of the current format
 
375
        :param basedir: Location of the control dir
 
376
        """
 
377
        self.show_user_warning('recommend_upgrade',
 
378
                               current_format_name=current_format_name, basedir=basedir)
282
379
 
283
380
    def report_transport_activity(self, transport, byte_count, direction):
284
381
        """Called by transports as they do IO.
308
405
        outdated formats), not for internal program warnings like deprecated
309
406
        APIs.
310
407
 
311
 
        This can be overridden by UIFactory subclasses to show it in some 
 
408
        This can be overridden by UIFactory subclasses to show it in some
312
409
        appropriate way; the default UIFactory is noninteractive and does
313
410
        nothing.  format_user_warning maps it to a string, though other
314
411
        presentations can be used for particular UIs.
315
412
 
316
 
        :param warning_id: An identifier like 'cross_format_fetch' used to 
 
413
        :param warning_id: An identifier like 'cross_format_fetch' used to
317
414
            check if the message is suppressed and to look up the string.
318
415
        :param message_args: Arguments to be interpolated into the message.
319
416
        """
321
418
 
322
419
    def show_error(self, msg):
323
420
        """Show an error message (not an exception) to the user.
324
 
        
 
421
 
325
422
        The message should not have an error prefix or trailing newline.  That
326
423
        will be added by the factory if appropriate.
327
424
        """
335
432
        """Show a warning to the user."""
336
433
        raise NotImplementedError(self.show_warning)
337
434
 
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):
 
435
 
 
436
class NoninteractiveUIFactory(UIFactory):
 
437
    """Base class for UIs with no user."""
 
438
 
 
439
    def confirm_action(self, prompt, confirmation_id, prompt_kwargs):
 
440
        return True
 
441
 
 
442
    def __repr__(self):
 
443
        return '%s()' % (self.__class__.__name__, )
 
444
 
 
445
 
 
446
class SilentUIFactory(NoninteractiveUIFactory):
357
447
    """A UI Factory which never prints anything.
358
448
 
359
449
    This is the default UI, if another one is never registered by a program
360
 
    using bzrlib, and it's also active for example inside 'bzr serve'.
 
450
    using breezy, and it's also active for example inside 'brz serve'.
361
451
 
362
452
    Methods that try to read from the user raise an error; methods that do
363
453
    output do nothing.
394
484
    def __repr__(self):
395
485
        return "%s(%r)" % (self.__class__.__name__, self.responses)
396
486
 
 
487
    def confirm_action(self, prompt, confirmation_id, args):
 
488
        return self.get_boolean(prompt % args)
 
489
 
397
490
    def get_boolean(self, prompt):
398
491
        return self.responses.pop(0)
399
492
 
400
493
    def get_integer(self, prompt):
401
494
        return self.responses.pop(0)
402
495
 
403
 
    def get_password(self, prompt='', **kwargs):
 
496
    def get_password(self, prompt=u'', **kwargs):
404
497
        return self.responses.pop(0)
405
498
 
406
499
    def get_username(self, prompt, **kwargs):
409
502
    def assert_all_input_consumed(self):
410
503
        if self.responses:
411
504
            raise AssertionError("expected all input in %r to be consumed"
412
 
                % (self,))
 
505
                                 % (self,))
413
506
 
414
507
 
415
508
ui_factory = SilentUIFactory()
422
515
    """
423
516
    # this is now always TextUIFactory, which in turn decides whether it
424
517
    # should display progress bars etc
425
 
    from bzrlib.ui.text import TextUIFactory
 
518
    from .text import TextUIFactory
426
519
    return TextUIFactory(stdin, stdout, stderr)
427
520
 
428
521