/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 bzrlib/ui/text.py

  • Committer: Ian Clatworthy
  • Date: 2009-07-23 00:24:30 UTC
  • mfrom: (4371.6.5 bzr.mv_after)
  • mto: This revision was merged to the branch mainline in revision 4561.
  • Revision ID: ian.clatworthy@canonical.com-20090723002430-70me272jpp3uss7i
(igc) Allow rename of items already removed from the inventory (Marius Kruger)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
 
1
# Copyright (C) 2005, 2008, 2009 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Text UI, write output to the console.
 
19
"""
 
20
 
 
21
import os
 
22
import sys
 
23
import time
 
24
import warnings
 
25
 
 
26
from bzrlib.lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
from bzrlib import (
 
29
    progress,
 
30
    osutils,
 
31
    symbol_versioning,
 
32
    )
 
33
 
 
34
""")
 
35
 
 
36
from bzrlib.ui import (
 
37
    UIFactory,
 
38
    NullProgressView,
 
39
    )
 
40
 
 
41
 
 
42
class TextUIFactory(UIFactory):
 
43
    """A UI factory for Text user interefaces."""
 
44
 
 
45
    def __init__(self,
 
46
                 stdin=None,
 
47
                 stdout=None,
 
48
                 stderr=None):
 
49
        """Create a TextUIFactory.
 
50
 
 
51
        :param bar_type: The type of progress bar to create. It defaults to
 
52
                         letting the bzrlib.progress.ProgressBar factory auto
 
53
                         select.   Deprecated.
 
54
        """
 
55
        super(TextUIFactory, self).__init__()
 
56
        # TODO: there's no good reason not to pass all three streams, maybe we
 
57
        # should deprecate the default values...
 
58
        self.stdin = stdin
 
59
        self.stdout = stdout
 
60
        self.stderr = stderr
 
61
        # paints progress, network activity, etc
 
62
        self._progress_view = self.make_progress_view()
 
63
        
 
64
    def clear_term(self):
 
65
        """Prepare the terminal for output.
 
66
 
 
67
        This will, clear any progress bars, and leave the cursor at the
 
68
        leftmost position."""
 
69
        # XXX: If this is preparing to write to stdout, but that's for example
 
70
        # directed into a file rather than to the terminal, and the progress
 
71
        # bar _is_ going to the terminal, we shouldn't need
 
72
        # to clear it.  We might need to separately check for the case of
 
73
        self._progress_view.clear()
 
74
 
 
75
    def get_boolean(self, prompt):
 
76
        while True:
 
77
            self.prompt(prompt + "? [y/n]: ")
 
78
            line = self.stdin.readline().lower()
 
79
            if line in ('y\n', 'yes\n'):
 
80
                return True
 
81
            elif line in ('n\n', 'no\n'):
 
82
                return False
 
83
            elif line in ('', None):
 
84
                # end-of-file; possibly should raise an error here instead
 
85
                return None
 
86
 
 
87
    def get_non_echoed_password(self):
 
88
        isatty = getattr(self.stdin, 'isatty', None)
 
89
        if isatty is not None and isatty():
 
90
            # getpass() ensure the password is not echoed and other
 
91
            # cross-platform niceties
 
92
            password = getpass.getpass('')
 
93
        else:
 
94
            # echo doesn't make sense without a terminal
 
95
            password = self.stdin.readline()
 
96
            if not password:
 
97
                password = None
 
98
            elif password[-1] == '\n':
 
99
                password = password[:-1]
 
100
        return password
 
101
 
 
102
    def get_password(self, prompt='', **kwargs):
 
103
        """Prompt the user for a password.
 
104
 
 
105
        :param prompt: The prompt to present the user
 
106
        :param kwargs: Arguments which will be expanded into the prompt.
 
107
                       This lets front ends display different things if
 
108
                       they so choose.
 
109
        :return: The password string, return None if the user
 
110
                 canceled the request.
 
111
        """
 
112
        prompt += ': '
 
113
        self.prompt(prompt, **kwargs)
 
114
        # There's currently no way to say 'i decline to enter a password'
 
115
        # as opposed to 'my password is empty' -- does it matter?
 
116
        return self.get_non_echoed_password()
 
117
 
 
118
    def get_username(self, prompt, **kwargs):
 
119
        """Prompt the user for a username.
 
120
 
 
121
        :param prompt: The prompt to present the user
 
122
        :param kwargs: Arguments which will be expanded into the prompt.
 
123
                       This lets front ends display different things if
 
124
                       they so choose.
 
125
        :return: The username string, return None if the user
 
126
                 canceled the request.
 
127
        """
 
128
        prompt += ': '
 
129
        self.prompt(prompt, **kwargs)
 
130
        username = self.stdin.readline()
 
131
        if not username:
 
132
            username = None
 
133
        elif username[-1] == '\n':
 
134
            username = username[:-1]
 
135
        return username
 
136
 
 
137
    def make_progress_view(self):
 
138
        """Construct and return a new ProgressView subclass for this UI.
 
139
        """
 
140
        # if the user specifically requests either text or no progress bars,
 
141
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
142
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
143
            return TextProgressView(self.stderr)
 
144
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
 
145
            return NullProgressView()
 
146
        elif progress._supports_progress(self.stderr):
 
147
            return TextProgressView(self.stderr)
 
148
        else:
 
149
            return NullProgressView()
 
150
 
 
151
    def note(self, msg):
 
152
        """Write an already-formatted message, clearing the progress bar if necessary."""
 
153
        self.clear_term()
 
154
        self.stdout.write(msg + '\n')
 
155
 
 
156
    def prompt(self, prompt, **kwargs):
 
157
        """Emit prompt on the CLI.
 
158
        
 
159
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
160
            to allow UIs to reformat the prompt.
 
161
        """
 
162
        if kwargs:
 
163
            # See <https://launchpad.net/bugs/365891>
 
164
            prompt = prompt % kwargs
 
165
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
166
        self.clear_term()
 
167
        self.stderr.write(prompt)
 
168
 
 
169
    def report_transport_activity(self, transport, byte_count, direction):
 
170
        """Called by transports as they do IO.
 
171
 
 
172
        This may update a progress bar, spinner, or similar display.
 
173
        By default it does nothing.
 
174
        """
 
175
        self._progress_view.show_transport_activity(transport,
 
176
            direction, byte_count)
 
177
 
 
178
    def _progress_updated(self, task):
 
179
        """A task has been updated and wants to be displayed.
 
180
        """
 
181
        if not self._task_stack:
 
182
            warnings.warn("%r updated but no tasks are active" %
 
183
                (task,))
 
184
        elif task != self._task_stack[-1]:
 
185
            warnings.warn("%r is not the top progress task %r" %
 
186
                (task, self._task_stack[-1]))
 
187
        self._progress_view.show_progress(task)
 
188
 
 
189
    def _progress_all_finished(self):
 
190
        self._progress_view.clear()
 
191
 
 
192
 
 
193
class TextProgressView(object):
 
194
    """Display of progress bar and other information on a tty.
 
195
 
 
196
    This shows one line of text, including possibly a network indicator, spinner,
 
197
    progress bar, message, etc.
 
198
 
 
199
    One instance of this is created and held by the UI, and fed updates when a
 
200
    task wants to be painted.
 
201
 
 
202
    Transports feed data to this through the ui_factory object.
 
203
 
 
204
    The Progress views can comprise a tree with _parent_task pointers, but
 
205
    this only prints the stack from the nominated current task up to the root.
 
206
    """
 
207
 
 
208
    def __init__(self, term_file):
 
209
        self._term_file = term_file
 
210
        # true when there's output on the screen we may need to clear
 
211
        self._have_output = False
 
212
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
213
        # https://launchpad.net/bugs/316357
 
214
        self._width = osutils.terminal_width()
 
215
        self._last_transport_msg = ''
 
216
        self._spin_pos = 0
 
217
        # time we last repainted the screen
 
218
        self._last_repaint = 0
 
219
        # time we last got information about transport activity
 
220
        self._transport_update_time = 0
 
221
        self._last_task = None
 
222
        self._total_byte_count = 0
 
223
        self._bytes_since_update = 0
 
224
 
 
225
    def _show_line(self, s):
 
226
        n = self._width - 1
 
227
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
228
 
 
229
    def clear(self):
 
230
        if self._have_output:
 
231
            self._show_line('')
 
232
        self._have_output = False
 
233
 
 
234
    def _render_bar(self):
 
235
        # return a string for the progress bar itself
 
236
        if (self._last_task is None) or self._last_task.show_bar:
 
237
            # If there's no task object, we show space for the bar anyhow.
 
238
            # That's because most invocations of bzr will end showing progress
 
239
            # at some point, though perhaps only after doing some initial IO.
 
240
            # It looks better to draw the progress bar initially rather than
 
241
            # to have what looks like an incomplete progress bar.
 
242
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
243
            self._spin_pos += 1
 
244
            cols = 20
 
245
            if self._last_task is None:
 
246
                completion_fraction = 0
 
247
            else:
 
248
                completion_fraction = \
 
249
                    self._last_task._overall_completion_fraction() or 0
 
250
            markers = int(round(float(cols) * completion_fraction)) - 1
 
251
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
 
252
            return bar_str
 
253
        elif self._last_task.show_spinner:
 
254
            # The last task wanted just a spinner, no bar
 
255
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
256
            self._spin_pos += 1
 
257
            return spin_str + ' '
 
258
        else:
 
259
            return ''
 
260
 
 
261
    def _format_task(self, task):
 
262
        if not task.show_count:
 
263
            s = ''
 
264
        elif task.current_cnt is not None and task.total_cnt is not None:
 
265
            s = ' %d/%d' % (task.current_cnt, task.total_cnt)
 
266
        elif task.current_cnt is not None:
 
267
            s = ' %d' % (task.current_cnt)
 
268
        else:
 
269
            s = ''
 
270
        # compose all the parent messages
 
271
        t = task
 
272
        m = task.msg
 
273
        while t._parent_task:
 
274
            t = t._parent_task
 
275
            if t.msg:
 
276
                m = t.msg + ':' + m
 
277
        return m + s
 
278
 
 
279
    def _render_line(self):
 
280
        bar_string = self._render_bar()
 
281
        if self._last_task:
 
282
            task_msg = self._format_task(self._last_task)
 
283
        else:
 
284
            task_msg = ''
 
285
        trans = self._last_transport_msg
 
286
        if trans:
 
287
            trans += ' | '
 
288
        return (bar_string + trans + task_msg)
 
289
 
 
290
    def _repaint(self):
 
291
        s = self._render_line()
 
292
        self._show_line(s)
 
293
        self._have_output = True
 
294
 
 
295
    def show_progress(self, task):
 
296
        """Called by the task object when it has changed.
 
297
        
 
298
        :param task: The top task object; its parents are also included 
 
299
            by following links.
 
300
        """
 
301
        must_update = task is not self._last_task
 
302
        self._last_task = task
 
303
        now = time.time()
 
304
        if (not must_update) and (now < self._last_repaint + 0.1):
 
305
            return
 
306
        if now > self._transport_update_time + 10:
 
307
            # no recent activity; expire it
 
308
            self._last_transport_msg = ''
 
309
        self._last_repaint = now
 
310
        self._repaint()
 
311
 
 
312
    def show_transport_activity(self, transport, direction, byte_count):
 
313
        """Called by transports via the ui_factory, as they do IO.
 
314
 
 
315
        This may update a progress bar, spinner, or similar display.
 
316
        By default it does nothing.
 
317
        """
 
318
        # XXX: Probably there should be a transport activity model, and that
 
319
        # too should be seen by the progress view, rather than being poked in
 
320
        # here.
 
321
        if not self._have_output:
 
322
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
323
            # show transport activity when there's already a progress bar
 
324
            # shown, which time the application code is expected to know to
 
325
            # clear off the progress bar when it's going to send some other
 
326
            # output.  Eventually it would be nice to have that automatically
 
327
            # synchronized.
 
328
            return
 
329
        self._total_byte_count += byte_count
 
330
        self._bytes_since_update += byte_count
 
331
        now = time.time()
 
332
        if self._transport_update_time is None:
 
333
            self._transport_update_time = now
 
334
        elif now >= (self._transport_update_time + 0.5):
 
335
            # guard against clock stepping backwards, and don't update too
 
336
            # often
 
337
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
338
            msg = ("%6dKB %5dKB/s" %
 
339
                    (self._total_byte_count>>10, int(rate)>>10,))
 
340
            self._transport_update_time = now
 
341
            self._last_repaint = now
 
342
            self._bytes_since_update = 0
 
343
            self._last_transport_msg = msg
 
344
            self._repaint()