← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/__init__.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-06 18:59:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4522.
  • Revision ID: john@arbash-meinel.com-20090706185924-qlhn1j607117lgdj
Start implementing an Annotator.add_special_text functionality.

The Python implementation supports it. Basically, it is meant to allow things
like WT and PreviewTree to insert the 'current' content into the graph, so that
we can get local modifications into the annotations.
There is also some work here to get support for texts that are already cached
in the annotator. So that we avoid extracting them, and can shortcut the
history.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/__init__.py
1
 
# Copyright (C) 2005 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""UI abstraction.
20
18
 
28
26
displays no output.
29
27
"""
30
28
 
 
29
import os
31
30
import sys
32
 
 
33
 
import bzrlib.progress
34
 
from bzrlib.symbol_versioning import (deprecated_method, zero_eight)
 
31
import warnings
 
32
 
 
33
from bzrlib.lazy_import import lazy_import
 
34
lazy_import(globals(), """
 
35
import getpass
 
36
 
 
37
from bzrlib import (
 
38
    errors,
 
39
    osutils,
 
40
    progress,
 
41
    trace,
 
42
    )
 
43
""")
35
44
 
36
45
 
37
46
class UIFactory(object):
42
51
    """
43
52
 
44
53
    def __init__(self):
45
 
        super(UIFactory, self).__init__()
46
 
        self._progress_bar_stack = None
47
 
 
48
 
    @deprecated_method(zero_eight)
49
 
    def progress_bar(self):
50
 
        """See UIFactory.nested_progress_bar()."""
51
 
        raise NotImplementedError(self.progress_bar)
 
54
        self._task_stack = []
52
55
 
53
56
    def get_password(self, prompt='', **kwargs):
54
57
        """Prompt the user for a password.
57
60
        :param kwargs: Arguments which will be expanded into the prompt.
58
61
                       This lets front ends display different things if
59
62
                       they so choose.
60
 
        :return: The password string, return None if the user 
61
 
                 canceled the request.
 
63
 
 
64
        :return: The password string, return None if the user canceled the
 
65
                 request. Note that we do not touch the encoding, users may
 
66
                 have whatever they see fit and the password should be
 
67
                 transported as is.
62
68
        """
63
69
        raise NotImplementedError(self.get_password)
64
 
        
 
70
 
65
71
    def nested_progress_bar(self):
66
72
        """Return a nested progress bar.
67
73
 
68
 
        When the bar has been finished with, it should be released bu calling
 
74
        When the bar has been finished with, it should be released by calling
69
75
        bar.finished().
70
76
        """
71
 
        raise NotImplementedError(self.nested_progress_bar)
 
77
        if self._task_stack:
 
78
            t = progress.ProgressTask(self._task_stack[-1], self)
 
79
        else:
 
80
            t = progress.ProgressTask(None, self)
 
81
        self._task_stack.append(t)
 
82
        return t
 
83
 
 
84
    def _progress_finished(self, task):
 
85
        """Called by the ProgressTask when it finishes"""
 
86
        if not self._task_stack:
 
87
            warnings.warn("%r finished but nothing is active"
 
88
                % (task,))
 
89
        elif task != self._task_stack[-1]:
 
90
            warnings.warn("%r is not the active task %r"
 
91
                % (task, self._task_stack[-1]))
 
92
        else:
 
93
            del self._task_stack[-1]
 
94
        if not self._task_stack:
 
95
            self._progress_all_finished()
 
96
 
 
97
    def _progress_all_finished(self):
 
98
        """Called when the top-level progress task finished"""
 
99
        pass
 
100
 
 
101
    def _progress_updated(self, task):
 
102
        """Called by the ProgressTask when it changes.
 
103
 
 
104
        Should be specialized to draw the progress.
 
105
        """
 
106
        pass
72
107
 
73
108
    def clear_term(self):
74
109
        """Prepare the terminal for output.
75
110
 
76
111
        This will, for example, clear text progress bars, and leave the
77
 
        cursor at the leftmost position."""
78
 
        raise NotImplementedError(self.clear_term)
 
112
        cursor at the leftmost position.
 
113
        """
 
114
        pass
79
115
 
80
116
    def get_boolean(self, prompt):
81
 
        """Get a boolean question answered from the user. 
 
117
        """Get a boolean question answered from the user.
82
118
 
83
119
        :param prompt: a message to prompt the user with. Should be a single
84
120
        line without terminating \n.
86
122
        """
87
123
        raise NotImplementedError(self.get_boolean)
88
124
 
 
125
    def recommend_upgrade(self,
 
126
        current_format_name,
 
127
        basedir):
 
128
        # this should perhaps be in the TextUIFactory and the default can do
 
129
        # nothing
 
130
        trace.warning("%s is deprecated "
 
131
            "and a better format is available.\n"
 
132
            "It is recommended that you upgrade by "
 
133
            "running the command\n"
 
134
            "  bzr upgrade %s",
 
135
            current_format_name,
 
136
            basedir)
 
137
 
 
138
    def report_transport_activity(self, transport, byte_count, direction):
 
139
        """Called by transports as they do IO.
 
140
 
 
141
        This may update a progress bar, spinner, or similar display.
 
142
        By default it does nothing.
 
143
        """
 
144
        pass
 
145
 
 
146
 
89
147
 
90
148
class CLIUIFactory(UIFactory):
91
 
    """Common behaviour for command line UI factories."""
92
 
 
93
 
    def __init__(self):
94
 
        super(CLIUIFactory, self).__init__()
95
 
        self.stdin = sys.stdin
 
149
    """Common behaviour for command line UI factories.
 
150
 
 
151
    This is suitable for dumb terminals that can't repaint existing text."""
 
152
 
 
153
    def __init__(self, stdin=None, stdout=None, stderr=None):
 
154
        UIFactory.__init__(self)
 
155
        self.stdin = stdin or sys.stdin
 
156
        self.stdout = stdout or sys.stdout
 
157
        self.stderr = stderr or sys.stderr
96
158
 
97
159
    def get_boolean(self, prompt):
98
 
        self.clear_term()
99
 
        # FIXME: make a regexp and handle case variations as well.
100
160
        while True:
101
 
            self.prompt(prompt)
 
161
            self.prompt(prompt + "? [y/n]: ")
102
162
            line = self.stdin.readline()
 
163
            line = line.lower()
103
164
            if line in ('y\n', 'yes\n'):
104
165
                return True
105
166
            if line in ('n\n', 'no\n'):
106
167
                return False
107
168
 
108
 
    def prompt(self, prompt):
109
 
        """Emit prompt on the CLI."""
 
169
    def get_non_echoed_password(self):
 
170
        isatty = getattr(self.stdin, 'isatty', None)
 
171
        if isatty is not None and isatty():
 
172
            # getpass() ensure the password is not echoed and other
 
173
            # cross-platform niceties
 
174
            password = getpass.getpass('')
 
175
        else:
 
176
            # echo doesn't make sense without a terminal
 
177
            password = self.stdin.readline()
 
178
            if not password:
 
179
                password = None
 
180
            elif password[-1] == '\n':
 
181
                password = password[:-1]
 
182
        return password
 
183
 
 
184
    def get_password(self, prompt='', **kwargs):
 
185
        """Prompt the user for a password.
 
186
 
 
187
        :param prompt: The prompt to present the user
 
188
        :param kwargs: Arguments which will be expanded into the prompt.
 
189
                       This lets front ends display different things if
 
190
                       they so choose.
 
191
        :return: The password string, return None if the user
 
192
                 canceled the request.
 
193
        """
 
194
        prompt += ': '
 
195
        self.prompt(prompt, **kwargs)
 
196
        # There's currently no way to say 'i decline to enter a password'
 
197
        # as opposed to 'my password is empty' -- does it matter?
 
198
        return self.get_non_echoed_password()
 
199
 
 
200
    def get_username(self, prompt, **kwargs):
 
201
        """Prompt the user for a username.
 
202
 
 
203
        :param prompt: The prompt to present the user
 
204
        :param kwargs: Arguments which will be expanded into the prompt.
 
205
                       This lets front ends display different things if
 
206
                       they so choose.
 
207
        :return: The username string, return None if the user
 
208
                 canceled the request.
 
209
        """
 
210
        prompt += ': '
 
211
        self.prompt(prompt, **kwargs)
 
212
        username = self.stdin.readline()
 
213
        if not username:
 
214
            username = None
 
215
        elif username[-1] == '\n':
 
216
            username = username[:-1]
 
217
        return username
 
218
 
 
219
    def prompt(self, prompt, **kwargs):
 
220
        """Emit prompt on the CLI.
 
221
        
 
222
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
223
            to allow UIs to reformat the prompt.
 
224
        """
 
225
        if kwargs:
 
226
            # See <https://launchpad.net/bugs/365891>
 
227
            prompt = prompt % kwargs
 
228
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
229
        self.clear_term()
 
230
        self.stderr.write(prompt)
 
231
 
 
232
    def note(self, msg):
 
233
        """Write an already-formatted message."""
 
234
        self.stdout.write(msg + '\n')
110
235
 
111
236
 
112
237
class SilentUIFactory(CLIUIFactory):
115
240
    This is the default UI, if another one is never registered.
116
241
    """
117
242
 
118
 
    @deprecated_method(zero_eight)
119
 
    def progress_bar(self):
120
 
        """See UIFactory.nested_progress_bar()."""
121
 
        return bzrlib.progress.DummyProgress()
 
243
    def __init__(self):
 
244
        CLIUIFactory.__init__(self)
122
245
 
123
246
    def get_password(self, prompt='', **kwargs):
124
247
        return None
125
248
 
126
 
    def nested_progress_bar(self):
127
 
        if self._progress_bar_stack is None:
128
 
            self._progress_bar_stack = bzrlib.progress.ProgressBarStack(
129
 
                klass=bzrlib.progress.DummyProgress)
130
 
        return self._progress_bar_stack.get_nested()
131
 
 
132
 
    def clear_term(self):
 
249
    def get_username(self, prompt='', **kwargs):
 
250
        return None
 
251
 
 
252
    def prompt(self, prompt, **kwargs):
 
253
        pass
 
254
 
 
255
    def note(self, msg):
133
256
        pass
134
257
 
135
258
 
140
263
 
141
264
 
142
265
ui_factory = SilentUIFactory()
143
 
"""IMPORTANT: never import this symbol directly. ONLY ever access it as 
 
266
"""IMPORTANT: never import this symbol directly. ONLY ever access it as
144
267
ui.ui_factory."""
 
268
 
 
269
 
 
270
def make_ui_for_terminal(stdin, stdout, stderr):
 
271
    """Construct and return a suitable UIFactory for a text mode program.
 
272
 
 
273
    If stdout is a smart terminal, this gets a smart UIFactory with
 
274
    progress indicators, etc.  If it's a dumb terminal, just plain text output.
 
275
    """
 
276
    cls = None
 
277
    isatty = getattr(stdin, 'isatty', None)
 
278
    if isatty is None:
 
279
        cls = CLIUIFactory
 
280
    elif not isatty():
 
281
        cls = CLIUIFactory
 
282
    elif os.environ.get('TERM') in ('dumb', ''):
 
283
        # e.g. emacs compile window
 
284
        cls = CLIUIFactory
 
285
    # User may know better, otherwise default to TextUIFactory
 
286
    if (   os.environ.get('BZR_USE_TEXT_UI', None) is not None
 
287
        or cls is None):
 
288
        from bzrlib.ui.text import TextUIFactory
 
289
        cls = TextUIFactory
 
290
    return cls(stdin=stdin, stdout=stdout, stderr=stderr)