~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: Aaron Bentley
  • Date: 2009-11-03 15:45:56 UTC
  • mto: (4634.97.2 2.0)
  • mto: This revision was merged to the branch mainline in revision 4798.
  • Revision ID: aaron@aaronbentley.com-20091103154556-e953dmegqbinyokq
Improve patch binary section handling.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
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.
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
121
112
 
122
113
    def get_password(self, prompt='', **kwargs):
123
114
        """Prompt the user for a password.
134
125
        """
135
126
        raise NotImplementedError(self.get_password)
136
127
 
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
 
 
168
128
    def nested_progress_bar(self):
169
129
        """Return a nested progress bar.
170
130
 
183
143
        if not self._task_stack:
184
144
            warnings.warn("%r finished but nothing is active"
185
145
                % (task,))
186
 
        if task in self._task_stack:
187
 
            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]))
188
149
        else:
189
 
            warnings.warn("%r is not in active stack %r"
190
 
                % (task, self._task_stack))
 
150
            del self._task_stack[-1]
191
151
        if not self._task_stack:
192
152
            self._progress_all_finished()
193
153
 
219
179
        """
220
180
        raise NotImplementedError(self.get_boolean)
221
181
 
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
 
 
232
182
    def make_progress_view(self):
233
183
        """Construct a new ProgressView object for this UI.
234
184
 
258
208
        """
259
209
        pass
260
210
 
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.
 
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.
276
286
        
277
 
        The message should not have an error prefix or trailing newline.  That
278
 
        will be added by the factory if appropriate.
 
287
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
288
            to allow UIs to reformat the prompt.
279
289
        """
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
 
 
 
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')
305
300
 
306
301
 
307
302
class SilentUIFactory(UIFactory):
323
318
    def get_username(self, prompt, **kwargs):
324
319
        return None
325
320
 
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
 
 
338
321
 
339
322
class CannedInputUIFactory(SilentUIFactory):
340
323
    """A silent UI that return canned input."""
348
331
    def get_boolean(self, prompt):
349
332
        return self.responses.pop(0)
350
333
 
351
 
    def get_integer(self, prompt):
352
 
        return self.responses.pop(0)
353
 
 
354
334
    def get_password(self, prompt='', **kwargs):
355
335
        return self.responses.pop(0)
356
336
 
357
337
    def get_username(self, prompt, **kwargs):
358
338
        return self.responses.pop(0)
359
 
 
 
339
    
360
340
    def assert_all_input_consumed(self):
361
341
        if self.responses:
362
342
            raise AssertionError("expected all input in %r to be consumed"
363
343
                % (self,))
364
344
 
365
345
 
 
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
 
366
353
ui_factory = SilentUIFactory()
367
354
# IMPORTANT: never import this symbol directly. ONLY ever access it as
368
355
# ui.ui_factory, so that you refer to the current value.
388
375
 
389
376
    def show_transport_activity(self, transport, direction, byte_count):
390
377
        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