← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

update TODO

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,
 
35
                           BzrBadParameter,
 
36
                           NoSuchFile,
 
37
                           PathNotChild,
 
38
                           )
 
39
from bzrlib.trace import mutter
 
40
 
25
41
 
26
42
def make_readonly(filename):
27
43
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
44
    mod = os.stat(filename).st_mode
30
45
    mod = mod & 0777555
31
46
    os.chmod(filename, mod)
37
52
    os.chmod(filename, mod)
38
53
 
39
54
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
55
_QUOTE_RE = None
 
56
 
 
57
 
41
58
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
 
59
    """Return a quoted filename filename
 
60
 
 
61
    This previously used backslash quoting, but that works poorly on
 
62
    Windows."""
 
63
    # TODO: I'm not really sure this is the best format either.x
 
64
    global _QUOTE_RE
 
65
    if _QUOTE_RE == None:
 
66
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
67
        
 
68
    if _QUOTE_RE.search(f):
 
69
        return '"' + f + '"'
 
70
    else:
 
71
        return f
48
72
 
49
73
 
50
74
def file_kind(f):
55
79
        return 'directory'
56
80
    elif S_ISLNK(mode):
57
81
        return 'symlink'
58
 
    else:
59
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f)) 
60
 
 
 
82
    elif S_ISCHR(mode):
 
83
        return 'chardev'
 
84
    elif S_ISBLK(mode):
 
85
        return 'block'
 
86
    elif S_ISFIFO(mode):
 
87
        return 'fifo'
 
88
    elif S_ISSOCK(mode):
 
89
        return 'socket'
 
90
    else:
 
91
        return 'unknown'
 
92
 
 
93
 
 
94
def kind_marker(kind):
 
95
    if kind == 'file':
 
96
        return ''
 
97
    elif kind == 'directory':
 
98
        return '/'
 
99
    elif kind == 'symlink':
 
100
        return '@'
 
101
    else:
 
102
        raise BzrError('invalid file kind %r' % kind)
 
103
 
 
104
def lexists(f):
 
105
    if hasattr(os.path, 'lexists'):
 
106
        return os.path.lexists(f)
 
107
    try:
 
108
        if hasattr(os, 'lstat'):
 
109
            os.lstat(f)
 
110
        else:
 
111
            os.stat(f)
 
112
        return True
 
113
    except OSError,e:
 
114
        if e.errno == errno.ENOENT:
 
115
            return False;
 
116
        else:
 
117
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
118
 
 
119
def fancy_rename(old, new, rename_func, unlink_func):
 
120
    """A fancy rename, when you don't have atomic rename.
 
121
    
 
122
    :param old: The old path, to rename from
 
123
    :param new: The new path, to rename to
 
124
    :param rename_func: The potentially non-atomic rename function
 
125
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
126
    """
 
127
 
 
128
    # sftp rename doesn't allow overwriting, so play tricks:
 
129
    import random
 
130
    base = os.path.basename(new)
 
131
    dirname = os.path.dirname(new)
 
132
    tmp_name = u'tmp.%s.%.9f.%d.%d' % (base, time.time(), os.getpid(), random.randint(0, 0x7FFFFFFF))
 
133
    tmp_name = pathjoin(dirname, tmp_name)
 
134
 
 
135
    # Rename the file out of the way, but keep track if it didn't exist
 
136
    # We don't want to grab just any exception
 
137
    # something like EACCES should prevent us from continuing
 
138
    # The downside is that the rename_func has to throw an exception
 
139
    # with an errno = ENOENT, or NoSuchFile
 
140
    file_existed = False
 
141
    try:
 
142
        rename_func(new, tmp_name)
 
143
    except (NoSuchFile,), e:
 
144
        pass
 
145
    except IOError, e:
 
146
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
147
        # function raises an IOError with errno == None when a rename fails.
 
148
        # This then gets caught here.
 
149
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
150
            raise
 
151
    except Exception, e:
 
152
        if (not hasattr(e, 'errno') 
 
153
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
154
            raise
 
155
    else:
 
156
        file_existed = True
 
157
 
 
158
    success = False
 
159
    try:
 
160
        # This may throw an exception, in which case success will
 
161
        # not be set.
 
162
        rename_func(old, new)
 
163
        success = True
 
164
    finally:
 
165
        if file_existed:
 
166
            # If the file used to exist, rename it back into place
 
167
            # otherwise just delete it from the tmp location
 
168
            if success:
 
169
                unlink_func(tmp_name)
 
170
            else:
 
171
                rename_func(tmp_name, new)
 
172
 
 
173
# Default is to just use the python builtins
 
174
abspath = os.path.abspath
 
175
realpath = os.path.realpath
 
176
pathjoin = os.path.join
 
177
normpath = os.path.normpath
 
178
getcwd = os.getcwdu
 
179
mkdtemp = tempfile.mkdtemp
 
180
rename = os.rename
 
181
dirname = os.path.dirname
 
182
basename = os.path.basename
 
183
 
 
184
if os.name == "posix":
 
185
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
186
    # choke on a Unicode string containing a relative path if
 
187
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
188
    # string.
 
189
    _fs_enc = sys.getfilesystemencoding()
 
190
    def abspath(path):
 
191
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
192
 
 
193
    def realpath(path):
 
194
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
195
 
 
196
if sys.platform == 'win32':
 
197
    # We need to use the Unicode-aware os.path.abspath and
 
198
    # os.path.realpath on Windows systems.
 
199
    def abspath(path):
 
200
        return os.path.abspath(path).replace('\\', '/')
 
201
 
 
202
    def realpath(path):
 
203
        return os.path.realpath(path).replace('\\', '/')
 
204
 
 
205
    def pathjoin(*args):
 
206
        return os.path.join(*args).replace('\\', '/')
 
207
 
 
208
    def normpath(path):
 
209
        return os.path.normpath(path).replace('\\', '/')
 
210
 
 
211
    def getcwd():
 
212
        return os.getcwdu().replace('\\', '/')
 
213
 
 
214
    def mkdtemp(*args, **kwargs):
 
215
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
216
 
 
217
    def rename(old, new):
 
218
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
219
 
 
220
 
 
221
def normalizepath(f):
 
222
    if hasattr(os.path, 'realpath'):
 
223
        F = realpath
 
224
    else:
 
225
        F = abspath
 
226
    [p,e] = os.path.split(f)
 
227
    if e == "" or e == "." or e == "..":
 
228
        return F(f)
 
229
    else:
 
230
        return pathjoin(F(p), e)
 
231
 
 
232
 
 
233
def backup_file(fn):
 
234
    """Copy a file to a backup.
 
235
 
 
236
    Backups are named in GNU-style, with a ~ suffix.
 
237
 
 
238
    If the file is already a backup, it's not copied.
 
239
    """
 
240
    if fn[-1] == '~':
 
241
        return
 
242
    bfn = fn + '~'
 
243
 
 
244
    if has_symlinks() and os.path.islink(fn):
 
245
        target = os.readlink(fn)
 
246
        os.symlink(target, bfn)
 
247
        return
 
248
    inf = file(fn, 'rb')
 
249
    try:
 
250
        content = inf.read()
 
251
    finally:
 
252
        inf.close()
 
253
    
 
254
    outf = file(bfn, 'wb')
 
255
    try:
 
256
        outf.write(content)
 
257
    finally:
 
258
        outf.close()
61
259
 
62
260
 
63
261
def isdir(f):
68
266
        return False
69
267
 
70
268
 
71
 
 
72
269
def isfile(f):
73
270
    """True if f is a regular file."""
74
271
    try:
76
273
    except OSError:
77
274
        return False
78
275
 
 
276
def islink(f):
 
277
    """True if f is a symlink."""
 
278
    try:
 
279
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
280
    except OSError:
 
281
        return False
 
282
 
 
283
def is_inside(dir, fname):
 
284
    """True if fname is inside dir.
 
285
    
 
286
    The parameters should typically be passed to osutils.normpath first, so
 
287
    that . and .. and repeated slashes are eliminated, and the separators
 
288
    are canonical for the platform.
 
289
    
 
290
    The empty string as a dir name is taken as top-of-tree and matches 
 
291
    everything.
 
292
    
 
293
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
294
    True
 
295
    >>> is_inside('src', 'srccontrol')
 
296
    False
 
297
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
298
    True
 
299
    >>> is_inside('foo.c', 'foo.c')
 
300
    True
 
301
    >>> is_inside('foo.c', '')
 
302
    False
 
303
    >>> is_inside('', 'foo.c')
 
304
    True
 
305
    """
 
306
    # XXX: Most callers of this can actually do something smarter by 
 
307
    # looking at the inventory
 
308
    if dir == fname:
 
309
        return True
 
310
    
 
311
    if dir == '':
 
312
        return True
 
313
 
 
314
    if dir[-1] != '/':
 
315
        dir += '/'
 
316
 
 
317
    return fname.startswith(dir)
 
318
 
 
319
 
 
320
def is_inside_any(dir_list, fname):
 
321
    """True if fname is inside any of given dirs."""
 
322
    for dirname in dir_list:
 
323
        if is_inside(dirname, fname):
 
324
            return True
 
325
    else:
 
326
        return False
 
327
 
79
328
 
80
329
def pumpfile(fromfile, tofile):
81
330
    """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
 
331
    BUFSIZE = 32768
 
332
    while True:
 
333
        b = fromfile.read(BUFSIZE)
 
334
        if not b:
 
335
            break
 
336
        tofile.write(b)
102
337
 
103
338
 
104
339
def sha_file(f):
105
 
    import sha
106
 
    ## TODO: Maybe read in chunks to handle big files
107
340
    if hasattr(f, 'tell'):
108
341
        assert f.tell() == 0
109
342
    s = sha.new()
110
 
    s.update(f.read())
 
343
    BUFSIZE = 128<<10
 
344
    while True:
 
345
        b = f.read(BUFSIZE)
 
346
        if not b:
 
347
            break
 
348
        s.update(b)
 
349
    return s.hexdigest()
 
350
 
 
351
 
 
352
 
 
353
def sha_strings(strings):
 
354
    """Return the sha-1 of concatenation of strings"""
 
355
    s = sha.new()
 
356
    map(s.update, strings)
111
357
    return s.hexdigest()
112
358
 
113
359
 
114
360
def sha_string(f):
115
 
    import sha
116
361
    s = sha.new()
117
362
    s.update(f)
118
363
    return s.hexdigest()
119
364
 
120
365
 
121
 
 
122
366
def fingerprint_file(f):
123
 
    import sha
124
367
    s = sha.new()
125
368
    b = f.read()
126
369
    s.update(b)
129
372
            'sha1': s.hexdigest()}
130
373
 
131
374
 
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
375
def compare_files(a, b):
236
376
    """Returns true if equal in contents"""
237
 
    # TODO: don't read the whole thing in one go.
238
377
    BUFSIZE = 4096
239
378
    while True:
240
379
        ai = a.read(BUFSIZE)
245
384
            return True
246
385
 
247
386
 
248
 
 
249
387
def local_time_offset(t=None):
250
388
    """Return offset of local zone from GMT, either at present or at time t."""
251
389
    # python2.3 localtime() can't take None
258
396
        return -time.timezone
259
397
 
260
398
    
261
 
def format_date(t, offset=0, timezone='original'):
 
399
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
400
                show_offset=True):
262
401
    ## TODO: Perhaps a global option to use either universal or local time?
263
402
    ## Or perhaps just let people set $TZ?
264
403
    assert isinstance(t, float)
274
413
        tt = time.localtime(t)
275
414
        offset = local_time_offset(t)
276
415
    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))
 
416
        raise BzrError("unsupported timezone format %r" % timezone,
 
417
                       ['options are "utc", "original", "local"'])
 
418
    if date_fmt is None:
 
419
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
420
    if show_offset:
 
421
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
422
    else:
 
423
        offset_str = ''
 
424
    return (time.strftime(date_fmt, tt) +  offset_str)
282
425
 
283
426
 
284
427
def compact_date(when):
290
433
    """Return size of given open file."""
291
434
    return os.fstat(f.fileno())[ST_SIZE]
292
435
 
293
 
 
294
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
436
# Define rand_bytes based on platform.
 
437
try:
 
438
    # Python 2.4 and later have os.urandom,
 
439
    # but it doesn't work on some arches
 
440
    os.urandom(1)
295
441
    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
 
 
 
442
except (NotImplementedError, AttributeError):
 
443
    # If python doesn't have os.urandom, or it doesn't work,
 
444
    # then try to first pull random data from /dev/urandom
 
445
    if os.path.exists("/dev/urandom"):
 
446
        rand_bytes = file('/dev/urandom', 'rb').read
 
447
    # Otherwise, use this hack as a last resort
 
448
    else:
 
449
        # not well seeded, but better than nothing
 
450
        def rand_bytes(n):
 
451
            import random
 
452
            s = ''
 
453
            while n:
 
454
                s += chr(random.randint(0, 255))
 
455
                n -= 1
 
456
            return s
301
457
 
302
458
## TODO: We could later have path objects that remember their list
303
459
## decomposition (might be too tricksy though.)
316
472
    >>> splitpath('a/../b')
317
473
    Traceback (most recent call last):
318
474
    ...
319
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
475
    BzrError: sorry, '..' not allowed in path
320
476
    """
321
477
    assert isinstance(p, types.StringTypes)
322
478
 
327
483
    rps = []
328
484
    for f in ps:
329
485
        if f == '..':
330
 
            bailout("sorry, %r not allowed in path" % f)
 
486
            raise BzrError("sorry, %r not allowed in path" % f)
331
487
        elif (f == '.') or (f == ''):
332
488
            pass
333
489
        else:
338
494
    assert isinstance(p, list)
339
495
    for f in p:
340
496
        if (f == '..') or (f == None) or (f == ''):
341
 
            bailout("sorry, %r not allowed in path" % f)
342
 
    return os.path.join(*p)
 
497
            raise BzrError("sorry, %r not allowed in path" % f)
 
498
    return pathjoin(*p)
343
499
 
344
500
 
345
501
def appendpath(p1, p2):
346
502
    if p1 == '':
347
503
        return p2
348
504
    else:
349
 
        return os.path.join(p1, p2)
 
505
        return pathjoin(p1, p2)
350
506
    
351
507
 
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
 
 
 
508
def split_lines(s):
 
509
    """Split s into lines, but without removing the newline characters."""
 
510
    return StringIO(s).readlines()
 
511
 
 
512
 
 
513
def hardlinks_good():
 
514
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
515
 
 
516
 
 
517
def link_or_copy(src, dest):
 
518
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
519
    if not hardlinks_good():
 
520
        copyfile(src, dest)
 
521
        return
 
522
    try:
 
523
        os.link(src, dest)
 
524
    except (OSError, IOError), e:
 
525
        if e.errno != errno.EXDEV:
 
526
            raise
 
527
        copyfile(src, dest)
 
528
 
 
529
 
 
530
def has_symlinks():
 
531
    if hasattr(os, 'symlink'):
 
532
        return True
 
533
    else:
 
534
        return False
 
535
        
 
536
 
 
537
def contains_whitespace(s):
 
538
    """True if there are any whitespace characters in s."""
 
539
    for ch in string.whitespace:
 
540
        if ch in s:
 
541
            return True
 
542
    else:
 
543
        return False
 
544
 
 
545
 
 
546
def contains_linebreaks(s):
 
547
    """True if there is any vertical whitespace in s."""
 
548
    for ch in '\f\n\r':
 
549
        if ch in s:
 
550
            return True
 
551
    else:
 
552
        return False
 
553
 
 
554
 
 
555
def relpath(base, path):
 
556
    """Return path relative to base, or raise exception.
 
557
 
 
558
    The path may be either an absolute path or a path relative to the
 
559
    current working directory.
 
560
 
 
561
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
562
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
563
    avoids that problem."""
 
564
    rp = abspath(path)
 
565
 
 
566
    s = []
 
567
    head = rp
 
568
    while len(head) >= len(base):
 
569
        if head == base:
 
570
            break
 
571
        head, tail = os.path.split(head)
 
572
        if tail:
 
573
            s.insert(0, tail)
 
574
    else:
 
575
        # XXX This should raise a NotChildPath exception, as its not tied
 
576
        # to branch anymore.
 
577
        raise PathNotChild(rp, base)
 
578
 
 
579
    if s:
 
580
        return pathjoin(*s)
 
581
    else:
 
582
        return ''
 
583
 
 
584
 
 
585
def safe_unicode(unicode_or_utf8_string):
 
586
    """Coerce unicode_or_utf8_string into unicode.
 
587
 
 
588
    If it is unicode, it is returned.
 
589
    Otherwise it is decoded from utf-8. If a decoding error
 
590
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
591
    as a BzrBadParameter exception.
 
592
    """
 
593
    if isinstance(unicode_or_utf8_string, unicode):
 
594
        return unicode_or_utf8_string
 
595
    try:
 
596
        return unicode_or_utf8_string.decode('utf8')
 
597
    except UnicodeDecodeError:
 
598
        raise BzrBadParameter(unicode_or_utf8_string)
 
599
 
 
600
 
 
601
def terminal_width():
 
602
    """Return estimated terminal width."""
 
603
 
 
604
    # TODO: Do something smart on Windows?
 
605
 
 
606
    # TODO: Is there anything that gets a better update when the window
 
607
    # is resized while the program is running? We could use the Python termcap
 
608
    # library.
 
609
    try:
 
610
        return int(os.environ['COLUMNS'])
 
611
    except (IndexError, KeyError, ValueError):
 
612
        return 80