~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Danny van Heumen
  • Date: 2010-03-09 21:42:11 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309214211-iqh42x6qcikgd9p3
Reverted now-useless TODO list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
UIFactory
26
26
    Semi-abstract base class
27
27
 
28
 
bzrlib.ui.SilentUIFactory
 
28
SilentUIFactory
29
29
    Produces no output and cannot take any input; useful for programs using
30
30
    bzrlib in batch mode or for programs such as loggerhead.
31
31
 
32
 
bzrlib.ui.CannedInputUIFactory
 
32
CannedInputUIFactory
33
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
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.
105
105
 
106
106
    This tells the library how to display things to the user.  Through this
107
107
    layer different applications can choose the style of UI.
108
 
 
109
 
    :ivar suppressed_warnings: Identifiers for user warnings that should 
110
 
        no be emitted.
111
108
    """
112
109
 
113
 
    _user_warning_templates = dict(
114
 
        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
 
            )
119
 
        )
120
 
 
121
110
    def __init__(self):
122
111
        self._task_stack = []
123
 
        self.suppressed_warnings = set()
124
 
        self._quiet = False
125
 
 
126
 
    def be_quiet(self, state):
127
 
        """Tell the UI to be more quiet, or not.
128
 
 
129
 
        Typically this suppresses progress bars; the application may also look
130
 
        at ui_factory.is_quiet().
131
 
        """
132
 
        self._quiet = state
133
112
 
134
113
    def get_password(self, prompt='', **kwargs):
135
114
        """Prompt the user for a password.
146
125
        """
147
126
        raise NotImplementedError(self.get_password)
148
127
 
149
 
    def is_quiet(self):
150
 
        return self._quiet
151
 
 
152
 
    def make_output_stream(self, encoding=None, encoding_type=None):
153
 
        """Get a stream for sending out bulk text data.
154
 
 
155
 
        This is used for commands that produce bulk text, such as log or diff
156
 
        output, as opposed to user interaction.  This should work even for
157
 
        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 
159
 
        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.
163
 
            (See get_terminal_encoding.)
164
 
 
165
 
        :param encoding_type: How to handle encoding errors:
166
 
            replace/strict/escape/exact.  Default is replace.
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'
173
 
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
174
 
        return out_stream
175
 
 
176
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
177
 
        raise NotImplementedError("%s doesn't support make_output_stream"
178
 
            % (self.__class__.__name__))
179
 
 
180
128
    def nested_progress_bar(self):
181
129
        """Return a nested progress bar.
182
130
 
195
143
        if not self._task_stack:
196
144
            warnings.warn("%r finished but nothing is active"
197
145
                % (task,))
198
 
        if task in self._task_stack:
199
 
            self._task_stack.remove(task)
 
146
        elif task != self._task_stack[-1]:
 
147
            warnings.warn("%r is not the active task %r"
 
148
                % (task, self._task_stack[-1]))
200
149
        else:
201
 
            warnings.warn("%r is not in active stack %r"
202
 
                % (task, self._task_stack))
 
150
            del self._task_stack[-1]
203
151
        if not self._task_stack:
204
152
            self._progress_all_finished()
205
153
 
222
170
        """
223
171
        pass
224
172
 
225
 
    def format_user_warning(self, warning_id, message_args):
226
 
        try:
227
 
            template = self._user_warning_templates[warning_id]
228
 
        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
232
 
        try:
233
 
            return template % message_args
234
 
        except ValueError, e:
235
 
            fail = "failed to format warning %r, %r: %s" % (
236
 
                warning_id, message_args, e)
237
 
            warnings.warn(fail)   # so tests will fail etc
238
 
            return fail
239
 
 
240
173
    def get_boolean(self, prompt):
241
174
        """Get a boolean question answered from the user.
242
175
 
246
179
        """
247
180
        raise NotImplementedError(self.get_boolean)
248
181
 
249
 
    def get_integer(self, prompt):
250
 
        """Get an integer from the user.
251
 
 
252
 
        :param prompt: a message to prompt the user with. Could be a multi-line
253
 
            prompt but without a terminating \n.
254
 
 
255
 
        :return: A signed integer.
256
 
        """
257
 
        raise NotImplementedError(self.get_integer)
258
 
 
259
182
    def make_progress_view(self):
260
183
        """Construct a new ProgressView object for this UI.
261
184
 
267
190
    def recommend_upgrade(self,
268
191
        current_format_name,
269
192
        basedir):
270
 
        # XXX: this should perhaps be in the TextUIFactory and the default can do
 
193
        # this should perhaps be in the TextUIFactory and the default can do
271
194
        # nothing
272
 
        #
273
 
        # XXX: Change to show_user_warning - that will accomplish the previous
274
 
        # xxx. -- mbp 2010-02-25
275
195
        trace.warning("%s is deprecated "
276
196
            "and a better format is available.\n"
277
197
            "It is recommended that you upgrade by "
288
208
        """
289
209
        pass
290
210
 
291
 
    def log_transport_activity(self, display=False):
292
 
        """Write out whatever transport activity has been measured.
293
 
 
294
 
        Implementations are allowed to do nothing, but it is useful if they can
295
 
        write a line to the log file.
296
 
 
297
 
        :param display: If False, only log to disk, if True also try to display
298
 
            a message to the user.
299
 
        :return: None
300
 
        """
301
 
        # Default implementation just does nothing
302
 
        pass
303
 
 
304
 
    def show_user_warning(self, warning_id, **message_args):
305
 
        """Show a warning to the user.
306
 
 
307
 
        This is specifically for things that are under the user's control (eg
308
 
        outdated formats), not for internal program warnings like deprecated
309
 
        APIs.
310
 
 
311
 
        This can be overridden by UIFactory subclasses to show it in some 
312
 
        appropriate way; the default UIFactory is noninteractive and does
313
 
        nothing.  format_user_warning maps it to a string, though other
314
 
        presentations can be used for particular UIs.
315
 
 
316
 
        :param warning_id: An identifier like 'cross_format_fetch' used to 
317
 
            check if the message is suppressed and to look up the string.
318
 
        :param message_args: Arguments to be interpolated into the message.
319
 
        """
320
 
        pass
321
 
 
322
 
    def show_error(self, msg):
323
 
        """Show an error message (not an exception) to the user.
324
 
        
325
 
        The message should not have an error prefix or trailing newline.  That
326
 
        will be added by the factory if appropriate.
327
 
        """
328
 
        raise NotImplementedError(self.show_error)
329
 
 
330
 
    def show_message(self, msg):
331
 
        """Show a message to the user."""
332
 
        raise NotImplementedError(self.show_message)
333
 
 
334
 
    def show_warning(self, msg):
335
 
        """Show a warning to the user."""
336
 
        raise NotImplementedError(self.show_warning)
337
 
 
338
211
    def warn_cross_format_fetch(self, from_format, to_format):
339
 
        """Warn about a potentially slow cross-format transfer.
 
212
        """Warn about a potentially slow cross-format transfer"""
 
213
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
214
        trace.warning("Doing on-the-fly conversion from %s to %s.\n"
 
215
            "This may take some time. Upgrade the repositories to the "
 
216
            "same format for better performance.\n" %
 
217
            (from_format, to_format))
 
218
 
 
219
 
 
220
class CLIUIFactory(UIFactory):
 
221
    """Deprecated in favor of TextUIFactory."""
 
222
 
 
223
    @deprecated_method(deprecated_in((1, 18, 0)))
 
224
    def __init__(self, stdin=None, stdout=None, stderr=None):
 
225
        UIFactory.__init__(self)
 
226
        self.stdin = stdin or sys.stdin
 
227
        self.stdout = stdout or sys.stdout
 
228
        self.stderr = stderr or sys.stderr
 
229
 
 
230
    _accepted_boolean_strings = dict(y=True, n=False, yes=True, no=False)
 
231
 
 
232
    def get_boolean(self, prompt):
 
233
        while True:
 
234
            self.prompt(prompt + "? [y/n]: ")
 
235
            line = self.stdin.readline()
 
236
            line = line.rstrip('\n')
 
237
            val = bool_from_string(line, self._accepted_boolean_strings)
 
238
            if val is not None:
 
239
                return val
 
240
 
 
241
    def get_non_echoed_password(self):
 
242
        isatty = getattr(self.stdin, 'isatty', None)
 
243
        if isatty is not None and isatty():
 
244
            # getpass() ensure the password is not echoed and other
 
245
            # cross-platform niceties
 
246
            password = getpass.getpass('')
 
247
        else:
 
248
            # echo doesn't make sense without a terminal
 
249
            password = self.stdin.readline()
 
250
            if not password:
 
251
                password = None
 
252
            elif password[-1] == '\n':
 
253
                password = password[:-1]
 
254
        return password
 
255
 
 
256
    def get_password(self, prompt='', **kwargs):
 
257
        """Prompt the user for a password.
 
258
 
 
259
        :param prompt: The prompt to present the user
 
260
        :param kwargs: Arguments which will be expanded into the prompt.
 
261
                       This lets front ends display different things if
 
262
                       they so choose.
 
263
        :return: The password string, return None if the user
 
264
                 canceled the request.
 
265
        """
 
266
        prompt += ': '
 
267
        self.prompt(prompt, **kwargs)
 
268
        # There's currently no way to say 'i decline to enter a password'
 
269
        # as opposed to 'my password is empty' -- does it matter?
 
270
        return self.get_non_echoed_password()
 
271
 
 
272
    def get_username(self, prompt, **kwargs):
 
273
        """Prompt the user for a username.
 
274
 
 
275
        :param prompt: The prompt to present the user
 
276
        :param kwargs: Arguments which will be expanded into the prompt.
 
277
                       This lets front ends display different things if
 
278
                       they so choose.
 
279
        :return: The username string, return None if the user
 
280
                 canceled the request.
 
281
        """
 
282
        prompt += ': '
 
283
        self.prompt(prompt, **kwargs)
 
284
        username = self.stdin.readline()
 
285
        if not username:
 
286
            username = None
 
287
        elif username[-1] == '\n':
 
288
            username = username[:-1]
 
289
        return username
 
290
 
 
291
    def prompt(self, prompt, **kwargs):
 
292
        """Emit prompt on the CLI.
340
293
        
341
 
        This is deprecated in favor of show_user_warning, but retained for api
342
 
        compatibility in 2.0 and 2.1.
 
294
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
295
            to allow UIs to reformat the prompt.
343
296
        """
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
 
 
 
297
        if kwargs:
 
298
            # See <https://launchpad.net/bugs/365891>
 
299
            prompt = prompt % kwargs
 
300
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
301
        self.clear_term()
 
302
        self.stderr.write(prompt)
 
303
 
 
304
    def note(self, msg):
 
305
        """Write an already-formatted message."""
 
306
        self.stdout.write(msg + '\n')
354
307
 
355
308
 
356
309
class SilentUIFactory(UIFactory):
372
325
    def get_username(self, prompt, **kwargs):
373
326
        return None
374
327
 
375
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
376
 
        return NullOutputStream(encoding)
377
 
 
378
 
    def show_error(self, msg):
379
 
        pass
380
 
 
381
 
    def show_message(self, msg):
382
 
        pass
383
 
 
384
 
    def show_warning(self, msg):
385
 
        pass
386
 
 
387
328
 
388
329
class CannedInputUIFactory(SilentUIFactory):
389
330
    """A silent UI that return canned input."""
397
338
    def get_boolean(self, prompt):
398
339
        return self.responses.pop(0)
399
340
 
400
 
    def get_integer(self, prompt):
401
 
        return self.responses.pop(0)
402
 
 
403
341
    def get_password(self, prompt='', **kwargs):
404
342
        return self.responses.pop(0)
405
343
 
406
344
    def get_username(self, prompt, **kwargs):
407
345
        return self.responses.pop(0)
408
 
 
 
346
    
409
347
    def assert_all_input_consumed(self):
410
348
        if self.responses:
411
349
            raise AssertionError("expected all input in %r to be consumed"
412
350
                % (self,))
413
351
 
414
352
 
 
353
@deprecated_function(deprecated_in((1, 18, 0)))
 
354
def clear_decorator(func, *args, **kwargs):
 
355
    """Decorator that clears the term"""
 
356
    ui_factory.clear_term()
 
357
    func(*args, **kwargs)
 
358
 
 
359
 
415
360
ui_factory = SilentUIFactory()
416
361
# IMPORTANT: never import this symbol directly. ONLY ever access it as
417
362
# ui.ui_factory, so that you refer to the current value.
437
382
 
438
383
    def show_transport_activity(self, transport, direction, byte_count):
439
384
        pass
440
 
 
441
 
    def log_transport_activity(self, display=False):
442
 
        pass
443
 
 
444
 
 
445
 
class NullOutputStream(object):
446
 
    """Acts like a file, but discard all output."""
447
 
 
448
 
    def __init__(self, encoding):
449
 
        self.encoding = encoding
450
 
 
451
 
    def write(self, data):
452
 
        pass
453
 
 
454
 
    def writelines(self, data):
455
 
        pass
456
 
 
457
 
    def close(self):
458
 
        pass