~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
 
UIFactory
 
25
bzrlib.ui.UIFactory
26
26
    Semi-abstract base class
27
27
 
28
 
SilentUIFactory
 
28
bzrlib.ui.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
 
CannedInputUIFactory
 
32
bzrlib.ui.CannedInputUIFactory
33
33
    For use in testing; the input values to be returned are provided 
34
34
    at construction.
35
35
 
36
 
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.
109
109
 
110
110
    def __init__(self):
111
111
        self._task_stack = []
 
112
        self._quiet = False
 
113
 
 
114
    def be_quiet(self, state):
 
115
        """Tell the UI to be more quiet, or not.
 
116
 
 
117
        Typically this suppresses progress bars; the application may also look
 
118
        at ui_factory.is_quiet().
 
119
        """
 
120
        self._quiet = state
112
121
 
113
122
    def get_password(self, prompt='', **kwargs):
114
123
        """Prompt the user for a password.
125
134
        """
126
135
        raise NotImplementedError(self.get_password)
127
136
 
 
137
    def is_quiet(self):
 
138
        return self._quiet
 
139
 
 
140
    def make_output_stream(self, encoding=None, encoding_type=None):
 
141
        """Get a stream for sending out bulk text data.
 
142
 
 
143
        This is used for commands that produce bulk text, such as log or diff
 
144
        output, as opposed to user interaction.  This should work even for
 
145
        non-interactive user interfaces.  Typically this goes to a decorated
 
146
        version of stdout, but in a GUI it might be appropriate to send it to a 
 
147
        window displaying the text.
 
148
     
 
149
        :param encoding: Unicode encoding for output; default is the 
 
150
            terminal encoding, which may be different from the user encoding.
 
151
            (See get_terminal_encoding.)
 
152
 
 
153
        :param encoding_type: How to handle encoding errors:
 
154
            replace/strict/escape/exact.  Default is replace.
 
155
        """
 
156
        # XXX: is the caller supposed to close the resulting object?
 
157
        if encoding is None:
 
158
            encoding = osutils.get_terminal_encoding()
 
159
        if encoding_type is None:
 
160
            encoding_type = 'replace'
 
161
        out_stream = self._make_output_stream_explicit(encoding, encoding_type)
 
162
        return out_stream
 
163
 
 
164
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
165
        raise NotImplementedError("%s doesn't support make_output_stream"
 
166
            % (self.__class__.__name__))
 
167
 
128
168
    def nested_progress_bar(self):
129
169
        """Return a nested progress bar.
130
170
 
143
183
        if not self._task_stack:
144
184
            warnings.warn("%r finished but nothing is active"
145
185
                % (task,))
146
 
        elif task != self._task_stack[-1]:
147
 
            warnings.warn("%r is not the active task %r"
148
 
                % (task, self._task_stack[-1]))
 
186
        if task in self._task_stack:
 
187
            self._task_stack.remove(task)
149
188
        else:
150
 
            del self._task_stack[-1]
 
189
            warnings.warn("%r is not in active stack %r"
 
190
                % (task, self._task_stack))
151
191
        if not self._task_stack:
152
192
            self._progress_all_finished()
153
193
 
179
219
        """
180
220
        raise NotImplementedError(self.get_boolean)
181
221
 
 
222
    def get_integer(self, prompt):
 
223
        """Get an integer from the user.
 
224
 
 
225
        :param prompt: a message to prompt the user with. Could be a multi-line
 
226
            prompt but without a terminating \n.
 
227
 
 
228
        :return: A signed integer.
 
229
        """
 
230
        raise NotImplementedError(self.get_integer)
 
231
 
182
232
    def make_progress_view(self):
183
233
        """Construct a new ProgressView object for this UI.
184
234
 
208
258
        """
209
259
        pass
210
260
 
211
 
 
212
 
 
213
 
class CLIUIFactory(UIFactory):
214
 
    """Deprecated in favor of TextUIFactory."""
215
 
 
216
 
    @deprecated_method(deprecated_in((1, 18, 0)))
217
 
    def __init__(self, stdin=None, stdout=None, stderr=None):
218
 
        UIFactory.__init__(self)
219
 
        self.stdin = stdin or sys.stdin
220
 
        self.stdout = stdout or sys.stdout
221
 
        self.stderr = stderr or sys.stderr
222
 
 
223
 
    _accepted_boolean_strings = dict(y=True, n=False, yes=True, no=False)
224
 
 
225
 
    def get_boolean(self, prompt):
226
 
        while True:
227
 
            self.prompt(prompt + "? [y/n]: ")
228
 
            line = self.stdin.readline()
229
 
            line = line.rstrip('\n')
230
 
            val = bool_from_string(line, self._accepted_boolean_strings)
231
 
            if val is not None:
232
 
                return val
233
 
 
234
 
    def get_non_echoed_password(self):
235
 
        isatty = getattr(self.stdin, 'isatty', None)
236
 
        if isatty is not None and isatty():
237
 
            # getpass() ensure the password is not echoed and other
238
 
            # cross-platform niceties
239
 
            password = getpass.getpass('')
240
 
        else:
241
 
            # echo doesn't make sense without a terminal
242
 
            password = self.stdin.readline()
243
 
            if not password:
244
 
                password = None
245
 
            elif password[-1] == '\n':
246
 
                password = password[:-1]
247
 
        return password
248
 
 
249
 
    def get_password(self, prompt='', **kwargs):
250
 
        """Prompt the user for a password.
251
 
 
252
 
        :param prompt: The prompt to present the user
253
 
        :param kwargs: Arguments which will be expanded into the prompt.
254
 
                       This lets front ends display different things if
255
 
                       they so choose.
256
 
        :return: The password string, return None if the user
257
 
                 canceled the request.
258
 
        """
259
 
        prompt += ': '
260
 
        self.prompt(prompt, **kwargs)
261
 
        # There's currently no way to say 'i decline to enter a password'
262
 
        # as opposed to 'my password is empty' -- does it matter?
263
 
        return self.get_non_echoed_password()
264
 
 
265
 
    def get_username(self, prompt, **kwargs):
266
 
        """Prompt the user for a username.
267
 
 
268
 
        :param prompt: The prompt to present the user
269
 
        :param kwargs: Arguments which will be expanded into the prompt.
270
 
                       This lets front ends display different things if
271
 
                       they so choose.
272
 
        :return: The username string, return None if the user
273
 
                 canceled the request.
274
 
        """
275
 
        prompt += ': '
276
 
        self.prompt(prompt, **kwargs)
277
 
        username = self.stdin.readline()
278
 
        if not username:
279
 
            username = None
280
 
        elif username[-1] == '\n':
281
 
            username = username[:-1]
282
 
        return username
283
 
 
284
 
    def prompt(self, prompt, **kwargs):
285
 
        """Emit prompt on the CLI.
 
261
    def log_transport_activity(self, display=False):
 
262
        """Write out whatever transport activity has been measured.
 
263
 
 
264
        Implementations are allowed to do nothing, but it is useful if they can
 
265
        write a line to the log file.
 
266
 
 
267
        :param display: If False, only log to disk, if True also try to display
 
268
            a message to the user.
 
269
        :return: None
 
270
        """
 
271
        # Default implementation just does nothing
 
272
        pass
 
273
 
 
274
    def show_error(self, msg):
 
275
        """Show an error message (not an exception) to the user.
286
276
        
287
 
        :param kwargs: Dictionary of arguments to insert into the prompt,
288
 
            to allow UIs to reformat the prompt.
 
277
        The message should not have an error prefix or trailing newline.  That
 
278
        will be added by the factory if appropriate.
289
279
        """
290
 
        if kwargs:
291
 
            # See <https://launchpad.net/bugs/365891>
292
 
            prompt = prompt % kwargs
293
 
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
294
 
        self.clear_term()
295
 
        self.stderr.write(prompt)
296
 
 
297
 
    def note(self, msg):
298
 
        """Write an already-formatted message."""
299
 
        self.stdout.write(msg + '\n')
 
280
        raise NotImplementedError(self.show_error)
 
281
 
 
282
    def show_message(self, msg):
 
283
        """Show a message to the user."""
 
284
        raise NotImplementedError(self.show_message)
 
285
 
 
286
    def show_warning(self, msg):
 
287
        """Show a warning to the user."""
 
288
        raise NotImplementedError(self.show_warning)
 
289
 
 
290
    def warn_cross_format_fetch(self, from_format, to_format):
 
291
        """Warn about a potentially slow cross-format transfer"""
 
292
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
293
        trace.warning("Doing on-the-fly conversion from %s to %s.\n"
 
294
            "This may take some time. Upgrade the repositories to the "
 
295
            "same format for better performance.\n" %
 
296
            (from_format, to_format))
 
297
 
 
298
    def warn_experimental_format_fetch(self, inter):
 
299
        """Warn about fetching into experimental repository formats."""
 
300
        if inter.target._format.experimental:
 
301
            trace.warning("Fetching into experimental format %s.\n"
 
302
                "This format may be unreliable or change in the future "
 
303
                "without an upgrade path.\n" % (inter.target._format,))
 
304
 
300
305
 
301
306
 
302
307
class SilentUIFactory(UIFactory):
318
323
    def get_username(self, prompt, **kwargs):
319
324
        return None
320
325
 
 
326
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
327
        return NullOutputStream(encoding)
 
328
 
 
329
    def show_error(self, msg):
 
330
        pass
 
331
 
 
332
    def show_message(self, msg):
 
333
        pass
 
334
 
 
335
    def show_warning(self, msg):
 
336
        pass
 
337
 
321
338
 
322
339
class CannedInputUIFactory(SilentUIFactory):
323
340
    """A silent UI that return canned input."""
331
348
    def get_boolean(self, prompt):
332
349
        return self.responses.pop(0)
333
350
 
 
351
    def get_integer(self, prompt):
 
352
        return self.responses.pop(0)
 
353
 
334
354
    def get_password(self, prompt='', **kwargs):
335
355
        return self.responses.pop(0)
336
356
 
337
357
    def get_username(self, prompt, **kwargs):
338
358
        return self.responses.pop(0)
339
 
    
 
359
 
340
360
    def assert_all_input_consumed(self):
341
361
        if self.responses:
342
362
            raise AssertionError("expected all input in %r to be consumed"
343
363
                % (self,))
344
364
 
345
365
 
346
 
@deprecated_function(deprecated_in((1, 18, 0)))
347
 
def clear_decorator(func, *args, **kwargs):
348
 
    """Decorator that clears the term"""
349
 
    ui_factory.clear_term()
350
 
    func(*args, **kwargs)
351
 
 
352
 
 
353
366
ui_factory = SilentUIFactory()
354
367
# IMPORTANT: never import this symbol directly. ONLY ever access it as
355
368
# ui.ui_factory, so that you refer to the current value.
375
388
 
376
389
    def show_transport_activity(self, transport, direction, byte_count):
377
390
        pass
 
391
 
 
392
    def log_transport_activity(self, display=False):
 
393
        pass
 
394
 
 
395
 
 
396
class NullOutputStream(object):
 
397
    """Acts like a file, but discard all output."""
 
398
 
 
399
    def __init__(self, encoding):
 
400
        self.encoding = encoding
 
401
 
 
402
    def write(self, data):
 
403
        pass
 
404
 
 
405
    def writelines(self, data):
 
406
        pass
 
407
 
 
408
    def close(self):
 
409
        pass