← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Merge from jam-storage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
1
# Bazaar-NG -- distributed version control
2
 
 
 
2
#
3
3
# Copyright (C) 2005 by Canonical Ltd
4
 
 
 
4
#
5
5
# This program is free software; you can redistribute it and/or modify
6
6
# it under the terms of the GNU General Public License as published by
7
7
# the Free Software Foundation; either version 2 of the License, or
8
8
# (at your option) any later version.
9
 
 
 
9
#
10
10
# This program is distributed in the hope that it will be useful,
11
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
13
# GNU General Public License for more details.
14
 
 
 
14
#
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
 
import os, types, re, time, errno
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
19
from shutil import copyfile
 
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
22
from cStringIO import StringIO
 
23
import errno
 
24
import os
 
25
import re
 
26
import sha
 
27
import string
 
28
import sys
 
29
import time
 
30
import types
 
31
import tempfile
21
32
 
22
 
from errors import bailout, BzrError
23
 
from trace import mutter
24
33
import bzrlib
 
34
from bzrlib.errors import BzrError, PathNotChild, NoSuchFile
 
35
from bzrlib.trace import mutter
 
36
 
25
37
 
26
38
def make_readonly(filename):
27
39
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
40
    mod = os.stat(filename).st_mode
30
41
    mod = mod & 0777555
31
42
    os.chmod(filename, mod)
37
48
    os.chmod(filename, mod)
38
49
 
39
50
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
51
_QUOTE_RE = None
 
52
 
 
53
 
41
54
def quotefn(f):
42
 
    """Return shell-quoted filename"""
43
 
    ## We could be a bit more terse by using double-quotes etc
44
 
    f = _QUOTE_RE.sub(r'\\\1', f)
45
 
    if f[0] == '~':
46
 
        f[0:1] = r'\~' 
47
 
    return f
 
55
    """Return a quoted filename filename
 
56
 
 
57
    This previously used backslash quoting, but that works poorly on
 
58
    Windows."""
 
59
    # TODO: I'm not really sure this is the best format either.x
 
60
    global _QUOTE_RE
 
61
    if _QUOTE_RE == None:
 
62
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
63
        
 
64
    if _QUOTE_RE.search(f):
 
65
        return '"' + f + '"'
 
66
    else:
 
67
        return f
48
68
 
49
69
 
50
70
def file_kind(f):
55
75
        return 'directory'
56
76
    elif S_ISLNK(mode):
57
77
        return 'symlink'
58
 
    else:
59
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f)) 
60
 
 
 
78
    elif S_ISCHR(mode):
 
79
        return 'chardev'
 
80
    elif S_ISBLK(mode):
 
81
        return 'block'
 
82
    elif S_ISFIFO(mode):
 
83
        return 'fifo'
 
84
    elif S_ISSOCK(mode):
 
85
        return 'socket'
 
86
    else:
 
87
        return 'unknown'
 
88
 
 
89
 
 
90
def kind_marker(kind):
 
91
    if kind == 'file':
 
92
        return ''
 
93
    elif kind == 'directory':
 
94
        return '/'
 
95
    elif kind == 'symlink':
 
96
        return '@'
 
97
    else:
 
98
        raise BzrError('invalid file kind %r' % kind)
 
99
 
 
100
def lexists(f):
 
101
    if hasattr(os.path, 'lexists'):
 
102
        return os.path.lexists(f)
 
103
    try:
 
104
        if hasattr(os, 'lstat'):
 
105
            os.lstat(f)
 
106
        else:
 
107
            os.stat(f)
 
108
        return True
 
109
    except OSError,e:
 
110
        if e.errno == errno.ENOENT:
 
111
            return False;
 
112
        else:
 
113
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
114
 
 
115
def fancy_rename(old, new, rename_func, unlink_func):
 
116
    """A fancy rename, when you don't have atomic rename.
 
117
    
 
118
    :param old: The old path, to rename from
 
119
    :param new: The new path, to rename to
 
120
    :param rename_func: The potentially non-atomic rename function
 
121
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
122
    """
 
123
 
 
124
    # sftp rename doesn't allow overwriting, so play tricks:
 
125
    import random
 
126
    base = os.path.basename(new)
 
127
    dirname = os.path.dirname(new)
 
128
    tmp_name = u'tmp.%s.%.9f.%d.%d' % (base, time.time(), os.getpid(), random.randint(0, 0x7FFFFFFF))
 
129
    tmp_name = pathjoin(dirname, tmp_name)
 
130
 
 
131
    # Rename the file out of the way, but keep track if it didn't exist
 
132
    # We don't want to grab just any exception
 
133
    # something like EACCES should prevent us from continuing
 
134
    # The downside is that the rename_func has to throw an exception
 
135
    # with an errno = ENOENT, or NoSuchFile
 
136
    file_existed = False
 
137
    try:
 
138
        rename_func(new, tmp_name)
 
139
    except (NoSuchFile,), e:
 
140
        pass
 
141
    except IOError, e:
 
142
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
143
        # function raises an IOError with errno == None when a rename fails.
 
144
        # This then gets caught here.
 
145
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
146
            raise
 
147
    except Exception, e:
 
148
        if (not hasattr(e, 'errno') 
 
149
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
150
            raise
 
151
    else:
 
152
        file_existed = True
 
153
 
 
154
    success = False
 
155
    try:
 
156
        # This may throw an exception, in which case success will
 
157
        # not be set.
 
158
        rename_func(old, new)
 
159
        success = True
 
160
    finally:
 
161
        if file_existed:
 
162
            # If the file used to exist, rename it back into place
 
163
            # otherwise just delete it from the tmp location
 
164
            if success:
 
165
                unlink_func(tmp_name)
 
166
            else:
 
167
                rename_func(tmp_name, new)
 
168
 
 
169
# Default is to just use the python builtins
 
170
abspath = os.path.abspath
 
171
realpath = os.path.realpath
 
172
pathjoin = os.path.join
 
173
normpath = os.path.normpath
 
174
getcwd = os.getcwdu
 
175
mkdtemp = tempfile.mkdtemp
 
176
rename = os.rename
 
177
dirname = os.path.dirname
 
178
basename = os.path.basename
 
179
 
 
180
if os.name == "posix":
 
181
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
182
    # choke on a Unicode string containing a relative path if
 
183
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
184
    # string.
 
185
    _fs_enc = sys.getfilesystemencoding()
 
186
    def abspath(path):
 
187
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
188
 
 
189
    def realpath(path):
 
190
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
191
 
 
192
if sys.platform == 'win32':
 
193
    # We need to use the Unicode-aware os.path.abspath and
 
194
    # os.path.realpath on Windows systems.
 
195
    def abspath(path):
 
196
        return os.path.abspath(path).replace('\\', '/')
 
197
 
 
198
    def realpath(path):
 
199
        return os.path.realpath(path).replace('\\', '/')
 
200
 
 
201
    def pathjoin(*args):
 
202
        return os.path.join(*args).replace('\\', '/')
 
203
 
 
204
    def normpath(path):
 
205
        return os.path.normpath(path).replace('\\', '/')
 
206
 
 
207
    def getcwd():
 
208
        return os.getcwdu().replace('\\', '/')
 
209
 
 
210
    def mkdtemp(*args, **kwargs):
 
211
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
212
 
 
213
    def rename(old, new):
 
214
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
215
 
 
216
 
 
217
def normalizepath(f):
 
218
    if hasattr(os.path, 'realpath'):
 
219
        F = realpath
 
220
    else:
 
221
        F = abspath
 
222
    [p,e] = os.path.split(f)
 
223
    if e == "" or e == "." or e == "..":
 
224
        return F(f)
 
225
    else:
 
226
        return pathjoin(F(p), e)
 
227
 
 
228
 
 
229
def backup_file(fn):
 
230
    """Copy a file to a backup.
 
231
 
 
232
    Backups are named in GNU-style, with a ~ suffix.
 
233
 
 
234
    If the file is already a backup, it's not copied.
 
235
    """
 
236
    if fn[-1] == '~':
 
237
        return
 
238
    bfn = fn + '~'
 
239
 
 
240
    if has_symlinks() and os.path.islink(fn):
 
241
        target = os.readlink(fn)
 
242
        os.symlink(target, bfn)
 
243
        return
 
244
    inf = file(fn, 'rb')
 
245
    try:
 
246
        content = inf.read()
 
247
    finally:
 
248
        inf.close()
 
249
    
 
250
    outf = file(bfn, 'wb')
 
251
    try:
 
252
        outf.write(content)
 
253
    finally:
 
254
        outf.close()
61
255
 
62
256
 
63
257
def isdir(f):
68
262
        return False
69
263
 
70
264
 
71
 
 
72
265
def isfile(f):
73
266
    """True if f is a regular file."""
74
267
    try:
76
269
    except OSError:
77
270
        return False
78
271
 
 
272
def islink(f):
 
273
    """True if f is a symlink."""
 
274
    try:
 
275
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
276
    except OSError:
 
277
        return False
 
278
 
 
279
def is_inside(dir, fname):
 
280
    """True if fname is inside dir.
 
281
    
 
282
    The parameters should typically be passed to osutils.normpath first, so
 
283
    that . and .. and repeated slashes are eliminated, and the separators
 
284
    are canonical for the platform.
 
285
    
 
286
    The empty string as a dir name is taken as top-of-tree and matches 
 
287
    everything.
 
288
    
 
289
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
290
    True
 
291
    >>> is_inside('src', 'srccontrol')
 
292
    False
 
293
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
294
    True
 
295
    >>> is_inside('foo.c', 'foo.c')
 
296
    True
 
297
    >>> is_inside('foo.c', '')
 
298
    False
 
299
    >>> is_inside('', 'foo.c')
 
300
    True
 
301
    """
 
302
    # XXX: Most callers of this can actually do something smarter by 
 
303
    # looking at the inventory
 
304
    if dir == fname:
 
305
        return True
 
306
    
 
307
    if dir == '':
 
308
        return True
 
309
 
 
310
    if dir[-1] != '/':
 
311
        dir += '/'
 
312
 
 
313
    return fname.startswith(dir)
 
314
 
 
315
 
 
316
def is_inside_any(dir_list, fname):
 
317
    """True if fname is inside any of given dirs."""
 
318
    for dirname in dir_list:
 
319
        if is_inside(dirname, fname):
 
320
            return True
 
321
    else:
 
322
        return False
 
323
 
79
324
 
80
325
def pumpfile(fromfile, tofile):
81
326
    """Copy contents of one file to another."""
82
 
    tofile.write(fromfile.read())
83
 
 
84
 
 
85
 
def uuid():
86
 
    """Return a new UUID"""
87
 
    
88
 
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
89
 
    ## Linux, but we need something portable for other systems;
90
 
    ## preferably an implementation in Python.
91
 
    try:
92
 
        return chomp(file('/proc/sys/kernel/random/uuid').readline())
93
 
    except IOError:
94
 
        return chomp(os.popen('uuidgen').readline())
95
 
 
96
 
 
97
 
def chomp(s):
98
 
    if s and (s[-1] == '\n'):
99
 
        return s[:-1]
100
 
    else:
101
 
        return s
 
327
    BUFSIZE = 32768
 
328
    while True:
 
329
        b = fromfile.read(BUFSIZE)
 
330
        if not b:
 
331
            break
 
332
        tofile.write(b)
 
333
 
 
334
 
 
335
def file_iterator(input_file, readsize=32768):
 
336
    while True:
 
337
        b = input_file.read(readsize)
 
338
        if len(b) == 0:
 
339
            break
 
340
        yield b
102
341
 
103
342
 
104
343
def sha_file(f):
105
 
    import sha
106
 
    ## TODO: Maybe read in chunks to handle big files
107
344
    if hasattr(f, 'tell'):
108
345
        assert f.tell() == 0
109
346
    s = sha.new()
110
 
    s.update(f.read())
 
347
    BUFSIZE = 128<<10
 
348
    while True:
 
349
        b = f.read(BUFSIZE)
 
350
        if not b:
 
351
            break
 
352
        s.update(b)
 
353
    return s.hexdigest()
 
354
 
 
355
 
 
356
 
 
357
def sha_strings(strings):
 
358
    """Return the sha-1 of concatenation of strings"""
 
359
    s = sha.new()
 
360
    map(s.update, strings)
111
361
    return s.hexdigest()
112
362
 
113
363
 
114
364
def sha_string(f):
115
 
    import sha
116
365
    s = sha.new()
117
366
    s.update(f)
118
367
    return s.hexdigest()
119
368
 
120
369
 
121
 
 
122
370
def fingerprint_file(f):
123
 
    import sha
124
371
    s = sha.new()
125
372
    b = f.read()
126
373
    s.update(b)
129
376
            'sha1': s.hexdigest()}
130
377
 
131
378
 
132
 
def config_dir():
133
 
    """Return per-user configuration directory.
134
 
 
135
 
    By default this is ~/.bzr.conf/
136
 
    
137
 
    TODO: Global option --config-dir to override this.
138
 
    """
139
 
    return os.path.expanduser("~/.bzr.conf")
140
 
 
141
 
 
142
 
def _auto_user_id():
143
 
    """Calculate automatic user identification.
144
 
 
145
 
    Returns (realname, email).
146
 
 
147
 
    Only used when none is set in the environment or the id file.
148
 
 
149
 
    This previously used the FQDN as the default domain, but that can
150
 
    be very slow on machines where DNS is broken.  So now we simply
151
 
    use the hostname.
152
 
    """
153
 
    import socket
154
 
 
155
 
    # XXX: Any good way to get real user name on win32?
156
 
 
157
 
    try:
158
 
        import pwd
159
 
        uid = os.getuid()
160
 
        w = pwd.getpwuid(uid)
161
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
162
 
        username = w.pw_name.decode(bzrlib.user_encoding)
163
 
        comma = gecos.find(',')
164
 
        if comma == -1:
165
 
            realname = gecos
166
 
        else:
167
 
            realname = gecos[:comma]
168
 
        if not realname:
169
 
            realname = username
170
 
 
171
 
    except ImportError:
172
 
        import getpass
173
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
174
 
 
175
 
    return realname, (username + '@' + socket.gethostname())
176
 
 
177
 
 
178
 
def _get_user_id():
179
 
    """Return the full user id from a file or environment variable.
180
 
 
181
 
    TODO: Allow taking this from a file in the branch directory too
182
 
    for per-branch ids."""
183
 
    v = os.environ.get('BZREMAIL')
184
 
    if v:
185
 
        return v.decode(bzrlib.user_encoding)
186
 
    
187
 
    try:
188
 
        return (open(os.path.join(config_dir(), "email"))
189
 
                .read()
190
 
                .decode(bzrlib.user_encoding)
191
 
                .rstrip("\r\n"))
192
 
    except IOError, e:
193
 
        if e.errno != errno.ENOENT:
194
 
            raise e
195
 
 
196
 
    v = os.environ.get('EMAIL')
197
 
    if v:
198
 
        return v.decode(bzrlib.user_encoding)
199
 
    else:    
200
 
        return None
201
 
 
202
 
 
203
 
def username():
204
 
    """Return email-style username.
205
 
 
206
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
207
 
 
208
 
    TODO: Check it's reasonably well-formed.
209
 
    """
210
 
    v = _get_user_id()
211
 
    if v:
212
 
        return v
213
 
    
214
 
    name, email = _auto_user_id()
215
 
    if name:
216
 
        return '%s <%s>' % (name, email)
217
 
    else:
218
 
        return email
219
 
 
220
 
 
221
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
222
 
def user_email():
223
 
    """Return just the email component of a username."""
224
 
    e = _get_user_id()
225
 
    if e:
226
 
        m = _EMAIL_RE.search(e)
227
 
        if not m:
228
 
            bailout("%r doesn't seem to contain a reasonable email address" % e)
229
 
        return m.group(0)
230
 
 
231
 
    return _auto_user_id()[1]
232
 
    
233
 
 
234
 
 
235
379
def compare_files(a, b):
236
380
    """Returns true if equal in contents"""
237
 
    # TODO: don't read the whole thing in one go.
238
381
    BUFSIZE = 4096
239
382
    while True:
240
383
        ai = a.read(BUFSIZE)
245
388
            return True
246
389
 
247
390
 
248
 
 
249
391
def local_time_offset(t=None):
250
392
    """Return offset of local zone from GMT, either at present or at time t."""
251
393
    # python2.3 localtime() can't take None
258
400
        return -time.timezone
259
401
 
260
402
    
261
 
def format_date(t, offset=0, timezone='original'):
 
403
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
404
                show_offset=True):
262
405
    ## TODO: Perhaps a global option to use either universal or local time?
263
406
    ## Or perhaps just let people set $TZ?
264
407
    assert isinstance(t, float)
274
417
        tt = time.localtime(t)
275
418
        offset = local_time_offset(t)
276
419
    else:
277
 
        bailout("unsupported timezone format %r",
278
 
                ['options are "utc", "original", "local"'])
279
 
 
280
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
281
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
420
        raise BzrError("unsupported timezone format %r" % timezone,
 
421
                       ['options are "utc", "original", "local"'])
 
422
    if date_fmt is None:
 
423
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
424
    if show_offset:
 
425
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
426
    else:
 
427
        offset_str = ''
 
428
    return (time.strftime(date_fmt, tt) +  offset_str)
282
429
 
283
430
 
284
431
def compact_date(when):
290
437
    """Return size of given open file."""
291
438
    return os.fstat(f.fileno())[ST_SIZE]
292
439
 
293
 
 
294
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
440
# Define rand_bytes based on platform.
 
441
try:
 
442
    # Python 2.4 and later have os.urandom,
 
443
    # but it doesn't work on some arches
 
444
    os.urandom(1)
295
445
    rand_bytes = os.urandom
296
 
else:
297
 
    # FIXME: No good on non-Linux
298
 
    _rand_file = file('/dev/urandom', 'rb')
299
 
    rand_bytes = _rand_file.read
300
 
 
 
446
except (NotImplementedError, AttributeError):
 
447
    # If python doesn't have os.urandom, or it doesn't work,
 
448
    # then try to first pull random data from /dev/urandom
 
449
    if os.path.exists("/dev/urandom"):
 
450
        rand_bytes = file('/dev/urandom', 'rb').read
 
451
    # Otherwise, use this hack as a last resort
 
452
    else:
 
453
        # not well seeded, but better than nothing
 
454
        def rand_bytes(n):
 
455
            import random
 
456
            s = ''
 
457
            while n:
 
458
                s += chr(random.randint(0, 255))
 
459
                n -= 1
 
460
            return s
301
461
 
302
462
## TODO: We could later have path objects that remember their list
303
463
## decomposition (might be too tricksy though.)
316
476
    >>> splitpath('a/../b')
317
477
    Traceback (most recent call last):
318
478
    ...
319
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
479
    BzrError: sorry, '..' not allowed in path
320
480
    """
321
481
    assert isinstance(p, types.StringTypes)
322
482
 
327
487
    rps = []
328
488
    for f in ps:
329
489
        if f == '..':
330
 
            bailout("sorry, %r not allowed in path" % f)
 
490
            raise BzrError("sorry, %r not allowed in path" % f)
331
491
        elif (f == '.') or (f == ''):
332
492
            pass
333
493
        else:
338
498
    assert isinstance(p, list)
339
499
    for f in p:
340
500
        if (f == '..') or (f == None) or (f == ''):
341
 
            bailout("sorry, %r not allowed in path" % f)
342
 
    return os.path.join(*p)
 
501
            raise BzrError("sorry, %r not allowed in path" % f)
 
502
    return pathjoin(*p)
343
503
 
344
504
 
345
505
def appendpath(p1, p2):
346
506
    if p1 == '':
347
507
        return p2
348
508
    else:
349
 
        return os.path.join(p1, p2)
 
509
        return pathjoin(p1, p2)
350
510
    
351
511
 
352
 
def extern_command(cmd, ignore_errors = False):
353
 
    mutter('external command: %s' % `cmd`)
354
 
    if os.system(cmd):
355
 
        if not ignore_errors:
356
 
            bailout('command failed')
357
 
 
 
512
def split_lines(s):
 
513
    """Split s into lines, but without removing the newline characters."""
 
514
    return StringIO(s).readlines()
 
515
 
 
516
 
 
517
def hardlinks_good():
 
518
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
519
 
 
520
 
 
521
def link_or_copy(src, dest):
 
522
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
523
    if not hardlinks_good():
 
524
        copyfile(src, dest)
 
525
        return
 
526
    try:
 
527
        os.link(src, dest)
 
528
    except (OSError, IOError), e:
 
529
        if e.errno != errno.EXDEV:
 
530
            raise
 
531
        copyfile(src, dest)
 
532
 
 
533
 
 
534
def has_symlinks():
 
535
    if hasattr(os, 'symlink'):
 
536
        return True
 
537
    else:
 
538
        return False
 
539
        
 
540
 
 
541
def contains_whitespace(s):
 
542
    """True if there are any whitespace characters in s."""
 
543
    for ch in string.whitespace:
 
544
        if ch in s:
 
545
            return True
 
546
    else:
 
547
        return False
 
548
 
 
549
 
 
550
def contains_linebreaks(s):
 
551
    """True if there is any vertical whitespace in s."""
 
552
    for ch in '\f\n\r':
 
553
        if ch in s:
 
554
            return True
 
555
    else:
 
556
        return False
 
557
 
 
558
 
 
559
def relpath(base, path):
 
560
    """Return path relative to base, or raise exception.
 
561
 
 
562
    The path may be either an absolute path or a path relative to the
 
563
    current working directory.
 
564
 
 
565
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
566
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
567
    avoids that problem."""
 
568
    rp = abspath(path)
 
569
 
 
570
    s = []
 
571
    head = rp
 
572
    while len(head) >= len(base):
 
573
        if head == base:
 
574
            break
 
575
        head, tail = os.path.split(head)
 
576
        if tail:
 
577
            s.insert(0, tail)
 
578
    else:
 
579
        # XXX This should raise a NotChildPath exception, as its not tied
 
580
        # to branch anymore.
 
581
        raise PathNotChild(rp, base)
 
582
 
 
583
    if s:
 
584
        return pathjoin(*s)
 
585
    else:
 
586
        return ''
 
587
 
 
588
 
 
589
def terminal_width():
 
590
    """Return estimated terminal width."""
 
591
 
 
592
    # TODO: Do something smart on Windows?
 
593
 
 
594
    # TODO: Is there anything that gets a better update when the window
 
595
    # is resized while the program is running? We could use the Python termcap
 
596
    # library.
 
597
    try:
 
598
        return int(os.environ['COLUMNS'])
 
599
    except (IndexError, KeyError, ValueError):
 
600
        return 80