← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2006-04-18 04:38:44 UTC
  • mto: This revision was merged to the branch mainline in revision 1670.
  • Revision ID: mbp@sourcefrog.net-20060418043844-dbaac5bdecaed3d1
Clear out BRANCH.TODO - most of them are done now

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, types
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
 
 
22
 
from errors import bailout
 
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
 
32
 
 
33
import bzrlib
 
34
from bzrlib.errors import (BzrError,
 
35
                           BzrBadParameterNotUnicode,
 
36
                           NoSuchFile,
 
37
                           PathNotChild,
 
38
                           )
 
39
from bzrlib.trace import mutter
 
40
 
23
41
 
24
42
def make_readonly(filename):
25
43
    """Make a filename read-only."""
26
 
    # TODO: probably needs to be fixed for windows
27
44
    mod = os.stat(filename).st_mode
28
45
    mod = mod & 0777555
29
46
    os.chmod(filename, mod)
35
52
    os.chmod(filename, mod)
36
53
 
37
54
 
38
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
55
_QUOTE_RE = None
 
56
 
 
57
 
39
58
def quotefn(f):
40
 
    """Return shell-quoted filename"""
41
 
    ## We could be a bit more terse by using double-quotes etc
42
 
    f = _QUOTE_RE.sub(r'\\\1', f)
43
 
    if f[0] == '~':
44
 
        f[0:1] = r'\~' 
45
 
    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
46
72
 
47
73
 
48
74
def file_kind(f):
53
79
        return 'directory'
54
80
    elif S_ISLNK(mode):
55
81
        return 'symlink'
56
 
    else:
57
 
        bailout("can't handle file kind with mode %o of %r" % (mode, f)) 
58
 
 
 
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.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
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()
59
259
 
60
260
 
61
261
def isdir(f):
66
266
        return False
67
267
 
68
268
 
69
 
 
70
269
def isfile(f):
71
270
    """True if f is a regular file."""
72
271
    try:
74
273
    except OSError:
75
274
        return False
76
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
 
77
328
 
78
329
def pumpfile(fromfile, tofile):
79
330
    """Copy contents of one file to another."""
80
 
    tofile.write(fromfile.read())
81
 
 
82
 
 
83
 
def uuid():
84
 
    """Return a new UUID"""
85
 
    
86
 
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
87
 
    ## Linux, but we need something portable for other systems;
88
 
    ## preferably an implementation in Python.
89
 
    bailout('uuids not allowed!')
90
 
    return chomp(os.popen('uuidgen').readline())
91
 
 
92
 
def chomp(s):
93
 
    if s and (s[-1] == '\n'):
94
 
        return s[:-1]
95
 
    else:
96
 
        return s
 
331
    BUFSIZE = 32768
 
332
    while True:
 
333
        b = fromfile.read(BUFSIZE)
 
334
        if not b:
 
335
            break
 
336
        tofile.write(b)
 
337
 
 
338
 
 
339
def file_iterator(input_file, readsize=32768):
 
340
    while True:
 
341
        b = input_file.read(readsize)
 
342
        if len(b) == 0:
 
343
            break
 
344
        yield b
97
345
 
98
346
 
99
347
def sha_file(f):
100
 
    import sha
101
 
    ## TODO: Maybe read in chunks to handle big files
102
348
    if hasattr(f, 'tell'):
103
349
        assert f.tell() == 0
104
350
    s = sha.new()
105
 
    s.update(f.read())
 
351
    BUFSIZE = 128<<10
 
352
    while True:
 
353
        b = f.read(BUFSIZE)
 
354
        if not b:
 
355
            break
 
356
        s.update(b)
 
357
    return s.hexdigest()
 
358
 
 
359
 
 
360
 
 
361
def sha_strings(strings):
 
362
    """Return the sha-1 of concatenation of strings"""
 
363
    s = sha.new()
 
364
    map(s.update, strings)
106
365
    return s.hexdigest()
107
366
 
108
367
 
109
368
def sha_string(f):
110
 
    import sha
111
369
    s = sha.new()
112
370
    s.update(f)
113
371
    return s.hexdigest()
114
372
 
115
373
 
116
 
 
117
 
def username():
118
 
    """Return email-style username.
119
 
 
120
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
121
 
 
122
 
    :todo: Check it's reasonably well-formed.
123
 
 
124
 
    :todo: Allow taking it from a dotfile to help people on windows
125
 
           who can't easily set variables.
126
 
 
127
 
    :todo: Cope without pwd module, which is only on unix. 
128
 
    """
129
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
130
 
    if e: return e
131
 
 
132
 
    import socket
133
 
    
134
 
    try:
135
 
        import pwd
136
 
        uid = os.getuid()
137
 
        w = pwd.getpwuid(uid)
138
 
        gecos = w.pw_gecos
139
 
        comma = gecos.find(',')
140
 
        if comma == -1:
141
 
            realname = gecos
142
 
        else:
143
 
            realname = gecos[:comma]
144
 
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
145
 
    except ImportError:
146
 
        pass
147
 
 
148
 
    import getpass, socket
149
 
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
150
 
 
151
 
 
152
 
def user_email():
153
 
    """Return just the email component of a username."""
154
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
155
 
    if e:
156
 
        import re
157
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
158
 
        if not m:
159
 
            bailout('%r is not a reasonable email address' % e)
160
 
        return m.group(0)
161
 
 
162
 
 
163
 
    import getpass, socket
164
 
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
165
 
 
166
 
    
 
374
def fingerprint_file(f):
 
375
    s = sha.new()
 
376
    b = f.read()
 
377
    s.update(b)
 
378
    size = len(b)
 
379
    return {'size': size,
 
380
            'sha1': s.hexdigest()}
167
381
 
168
382
 
169
383
def compare_files(a, b):
170
384
    """Returns true if equal in contents"""
171
 
    # TODO: don't read the whole thing in one go.
172
 
    result = a.read() == b.read()
173
 
    return result
174
 
 
175
 
 
176
 
 
177
 
def local_time_offset():
178
 
    if time.daylight:
 
385
    BUFSIZE = 4096
 
386
    while True:
 
387
        ai = a.read(BUFSIZE)
 
388
        bi = b.read(BUFSIZE)
 
389
        if ai != bi:
 
390
            return False
 
391
        if ai == '':
 
392
            return True
 
393
 
 
394
 
 
395
def local_time_offset(t=None):
 
396
    """Return offset of local zone from GMT, either at present or at time t."""
 
397
    # python2.3 localtime() can't take None
 
398
    if t == None:
 
399
        t = time.time()
 
400
        
 
401
    if time.localtime(t).tm_isdst and time.daylight:
179
402
        return -time.altzone
180
403
    else:
181
404
        return -time.timezone
182
405
 
183
406
    
184
 
def format_date(t, offset=0, timezone='original'):
 
407
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
408
                show_offset=True):
185
409
    ## TODO: Perhaps a global option to use either universal or local time?
186
410
    ## Or perhaps just let people set $TZ?
187
 
    import time
188
 
    
189
411
    assert isinstance(t, float)
190
412
    
191
413
    if timezone == 'utc':
197
419
        tt = time.gmtime(t + offset)
198
420
    elif timezone == 'local':
199
421
        tt = time.localtime(t)
200
 
        offset = local_time_offset()
201
 
    else:
202
 
        bailout("unsupported timezone format %r",
203
 
                ['options are "utc", "original", "local"'])
204
 
 
205
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
206
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
422
        offset = local_time_offset(t)
 
423
    else:
 
424
        raise BzrError("unsupported timezone format %r" % timezone,
 
425
                       ['options are "utc", "original", "local"'])
 
426
    if date_fmt is None:
 
427
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
428
    if show_offset:
 
429
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
430
    else:
 
431
        offset_str = ''
 
432
    return (time.strftime(date_fmt, tt) +  offset_str)
207
433
 
208
434
 
209
435
def compact_date(when):
216
442
    return os.fstat(f.fileno())[ST_SIZE]
217
443
 
218
444
 
219
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
445
# Define rand_bytes based on platform.
 
446
try:
 
447
    # Python 2.4 and later have os.urandom,
 
448
    # but it doesn't work on some arches
 
449
    os.urandom(1)
220
450
    rand_bytes = os.urandom
221
 
else:
222
 
    # FIXME: No good on non-Linux
223
 
    _rand_file = file('/dev/urandom', 'rb')
224
 
    rand_bytes = _rand_file.read
 
451
except (NotImplementedError, AttributeError):
 
452
    # If python doesn't have os.urandom, or it doesn't work,
 
453
    # then try to first pull random data from /dev/urandom
 
454
    if os.path.exists("/dev/urandom"):
 
455
        rand_bytes = file('/dev/urandom', 'rb').read
 
456
    # Otherwise, use this hack as a last resort
 
457
    else:
 
458
        # not well seeded, but better than nothing
 
459
        def rand_bytes(n):
 
460
            import random
 
461
            s = ''
 
462
            while n:
 
463
                s += chr(random.randint(0, 255))
 
464
                n -= 1
 
465
            return s
 
466
 
 
467
 
 
468
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
469
def rand_chars(num):
 
470
    """Return a random string of num alphanumeric characters
 
471
    
 
472
    The result only contains lowercase chars because it may be used on 
 
473
    case-insensitive filesystems.
 
474
    """
 
475
    s = ''
 
476
    for raw_byte in rand_bytes(num):
 
477
        s += ALNUM[ord(raw_byte) % 36]
 
478
    return s
225
479
 
226
480
 
227
481
## TODO: We could later have path objects that remember their list
241
495
    >>> splitpath('a/../b')
242
496
    Traceback (most recent call last):
243
497
    ...
244
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
498
    BzrError: sorry, '..' not allowed in path
245
499
    """
246
500
    assert isinstance(p, types.StringTypes)
247
 
    ps = [f for f in p.split('/') if f != '.']
 
501
 
 
502
    # split on either delimiter because people might use either on
 
503
    # Windows
 
504
    ps = re.split(r'[\\/]', p)
 
505
 
 
506
    rps = []
248
507
    for f in ps:
249
508
        if f == '..':
250
 
            bailout("sorry, %r not allowed in path" % f)
251
 
    return ps
 
509
            raise BzrError("sorry, %r not allowed in path" % f)
 
510
        elif (f == '.') or (f == ''):
 
511
            pass
 
512
        else:
 
513
            rps.append(f)
 
514
    return rps
252
515
 
253
516
def joinpath(p):
254
517
    assert isinstance(p, list)
255
518
    for f in p:
256
 
        if (f == '..') or (f is None) or (f == ''):
257
 
            bailout("sorry, %r not allowed in path" % f)
258
 
    return '/'.join(p)
 
519
        if (f == '..') or (f == None) or (f == ''):
 
520
            raise BzrError("sorry, %r not allowed in path" % f)
 
521
    return pathjoin(*p)
259
522
 
260
523
 
261
524
def appendpath(p1, p2):
262
525
    if p1 == '':
263
526
        return p2
264
527
    else:
265
 
        return p1 + '/' + p2
 
528
        return pathjoin(p1, p2)
266
529
    
267
530
 
268
 
def extern_command(cmd, ignore_errors = False):
269
 
    mutter('external command: %s' % `cmd`)
270
 
    if os.system(cmd):
271
 
        if not ignore_errors:
272
 
            bailout('command failed')
273
 
 
 
531
def split_lines(s):
 
532
    """Split s into lines, but without removing the newline characters."""
 
533
    return StringIO(s).readlines()
 
534
 
 
535
 
 
536
def hardlinks_good():
 
537
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
538
 
 
539
 
 
540
def link_or_copy(src, dest):
 
541
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
542
    if not hardlinks_good():
 
543
        copyfile(src, dest)
 
544
        return
 
545
    try:
 
546
        os.link(src, dest)
 
547
    except (OSError, IOError), e:
 
548
        if e.errno != errno.EXDEV:
 
549
            raise
 
550
        copyfile(src, dest)
 
551
 
 
552
def delete_any(full_path):
 
553
    """Delete a file or directory."""
 
554
    try:
 
555
        os.unlink(full_path)
 
556
    except OSError, e:
 
557
    # We may be renaming a dangling inventory id
 
558
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
559
            raise
 
560
        os.rmdir(full_path)
 
561
 
 
562
 
 
563
def has_symlinks():
 
564
    if hasattr(os, 'symlink'):
 
565
        return True
 
566
    else:
 
567
        return False
 
568
        
 
569
 
 
570
def contains_whitespace(s):
 
571
    """True if there are any whitespace characters in s."""
 
572
    for ch in string.whitespace:
 
573
        if ch in s:
 
574
            return True
 
575
    else:
 
576
        return False
 
577
 
 
578
 
 
579
def contains_linebreaks(s):
 
580
    """True if there is any vertical whitespace in s."""
 
581
    for ch in '\f\n\r':
 
582
        if ch in s:
 
583
            return True
 
584
    else:
 
585
        return False
 
586
 
 
587
 
 
588
def relpath(base, path):
 
589
    """Return path relative to base, or raise exception.
 
590
 
 
591
    The path may be either an absolute path or a path relative to the
 
592
    current working directory.
 
593
 
 
594
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
595
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
596
    avoids that problem.
 
597
    """
 
598
    if sys.platform != "win32":
 
599
        minlength = 1
 
600
    else:
 
601
        minlength = 3
 
602
    assert len(base) >= minlength, ('Length of base must be equal or exceed the'
 
603
        ' platform minimum length (which is %d)' % minlength)
 
604
    rp = abspath(path)
 
605
 
 
606
    s = []
 
607
    head = rp
 
608
    while len(head) >= len(base):
 
609
        if head == base:
 
610
            break
 
611
        head, tail = os.path.split(head)
 
612
        if tail:
 
613
            s.insert(0, tail)
 
614
    else:
 
615
        # XXX This should raise a NotChildPath exception, as its not tied
 
616
        # to branch anymore.
 
617
        raise PathNotChild(rp, base)
 
618
 
 
619
    if s:
 
620
        return pathjoin(*s)
 
621
    else:
 
622
        return ''
 
623
 
 
624
 
 
625
def safe_unicode(unicode_or_utf8_string):
 
626
    """Coerce unicode_or_utf8_string into unicode.
 
627
 
 
628
    If it is unicode, it is returned.
 
629
    Otherwise it is decoded from utf-8. If a decoding error
 
630
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
631
    as a BzrBadParameter exception.
 
632
    """
 
633
    if isinstance(unicode_or_utf8_string, unicode):
 
634
        return unicode_or_utf8_string
 
635
    try:
 
636
        return unicode_or_utf8_string.decode('utf8')
 
637
    except UnicodeDecodeError:
 
638
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
639
 
 
640
 
 
641
def terminal_width():
 
642
    """Return estimated terminal width."""
 
643
 
 
644
    # TODO: Do something smart on Windows?
 
645
 
 
646
    # TODO: Is there anything that gets a better update when the window
 
647
    # is resized while the program is running? We could use the Python termcap
 
648
    # library.
 
649
    try:
 
650
        return int(os.environ['COLUMNS'])
 
651
    except (IndexError, KeyError, ValueError):
 
652
        return 80
 
653
 
 
654
def supports_executable():
 
655
    return sys.platform != "win32"