/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/osutils.py

Merge register-branch plugin into default plugins directory

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, sys
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 shutil
 
28
import string
 
29
import sys
 
30
import time
 
31
import types
 
32
import tempfile
21
33
 
22
 
from bzrlib.errors import BzrError
 
34
import bzrlib
 
35
from bzrlib.errors import (BzrError,
 
36
                           BzrBadParameterNotUnicode,
 
37
                           NoSuchFile,
 
38
                           PathNotChild,
 
39
                           IllegalPath,
 
40
                           )
23
41
from bzrlib.trace import mutter
24
 
import bzrlib
 
42
 
25
43
 
26
44
def make_readonly(filename):
27
45
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
46
    mod = os.stat(filename).st_mode
30
47
    mod = mod & 0777555
31
48
    os.chmod(filename, mod)
37
54
    os.chmod(filename, mod)
38
55
 
39
56
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
57
_QUOTE_RE = None
41
58
 
42
 
_SLASH_RE = re.compile(r'[\\/]+')
43
59
 
44
60
def quotefn(f):
45
61
    """Return a quoted filename filename
47
63
    This previously used backslash quoting, but that works poorly on
48
64
    Windows."""
49
65
    # TODO: I'm not really sure this is the best format either.x
 
66
    global _QUOTE_RE
 
67
    if _QUOTE_RE == None:
 
68
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
69
        
50
70
    if _QUOTE_RE.search(f):
51
71
        return '"' + f + '"'
52
72
    else:
61
81
        return 'directory'
62
82
    elif S_ISLNK(mode):
63
83
        return 'symlink'
 
84
    elif S_ISCHR(mode):
 
85
        return 'chardev'
 
86
    elif S_ISBLK(mode):
 
87
        return 'block'
 
88
    elif S_ISFIFO(mode):
 
89
        return 'fifo'
 
90
    elif S_ISSOCK(mode):
 
91
        return 'socket'
64
92
    else:
65
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
93
        return 'unknown'
66
94
 
67
95
 
68
96
def kind_marker(kind):
75
103
    else:
76
104
        raise BzrError('invalid file kind %r' % kind)
77
105
 
 
106
def lexists(f):
 
107
    if hasattr(os.path, 'lexists'):
 
108
        return os.path.lexists(f)
 
109
    try:
 
110
        if hasattr(os, 'lstat'):
 
111
            os.lstat(f)
 
112
        else:
 
113
            os.stat(f)
 
114
        return True
 
115
    except OSError,e:
 
116
        if e.errno == errno.ENOENT:
 
117
            return False;
 
118
        else:
 
119
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
120
 
 
121
def fancy_rename(old, new, rename_func, unlink_func):
 
122
    """A fancy rename, when you don't have atomic rename.
 
123
    
 
124
    :param old: The old path, to rename from
 
125
    :param new: The new path, to rename to
 
126
    :param rename_func: The potentially non-atomic rename function
 
127
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
128
    """
 
129
 
 
130
    # sftp rename doesn't allow overwriting, so play tricks:
 
131
    import random
 
132
    base = os.path.basename(new)
 
133
    dirname = os.path.dirname(new)
 
134
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
135
    tmp_name = pathjoin(dirname, tmp_name)
 
136
 
 
137
    # Rename the file out of the way, but keep track if it didn't exist
 
138
    # We don't want to grab just any exception
 
139
    # something like EACCES should prevent us from continuing
 
140
    # The downside is that the rename_func has to throw an exception
 
141
    # with an errno = ENOENT, or NoSuchFile
 
142
    file_existed = False
 
143
    try:
 
144
        rename_func(new, tmp_name)
 
145
    except (NoSuchFile,), e:
 
146
        pass
 
147
    except IOError, e:
 
148
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
149
        # function raises an IOError with errno == None when a rename fails.
 
150
        # This then gets caught here.
 
151
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
152
            raise
 
153
    except Exception, e:
 
154
        if (not hasattr(e, 'errno') 
 
155
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
156
            raise
 
157
    else:
 
158
        file_existed = True
 
159
 
 
160
    success = False
 
161
    try:
 
162
        # This may throw an exception, in which case success will
 
163
        # not be set.
 
164
        rename_func(old, new)
 
165
        success = True
 
166
    finally:
 
167
        if file_existed:
 
168
            # If the file used to exist, rename it back into place
 
169
            # otherwise just delete it from the tmp location
 
170
            if success:
 
171
                unlink_func(tmp_name)
 
172
            else:
 
173
                rename_func(tmp_name, new)
 
174
 
 
175
# Default is to just use the python builtins, but these can be rebound on
 
176
# particular platforms.
 
177
abspath = os.path.abspath
 
178
realpath = os.path.realpath
 
179
pathjoin = os.path.join
 
180
normpath = os.path.normpath
 
181
getcwd = os.getcwdu
 
182
mkdtemp = tempfile.mkdtemp
 
183
rename = os.rename
 
184
dirname = os.path.dirname
 
185
basename = os.path.basename
 
186
rmtree = shutil.rmtree
 
187
 
 
188
MIN_ABS_PATHLENGTH = 1
 
189
 
 
190
if os.name == "posix":
 
191
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
192
    # choke on a Unicode string containing a relative path if
 
193
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
194
    # string.
 
195
    _fs_enc = sys.getfilesystemencoding()
 
196
    def abspath(path):
 
197
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
198
 
 
199
    def realpath(path):
 
200
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
201
 
 
202
if sys.platform == 'win32':
 
203
    # We need to use the Unicode-aware os.path.abspath and
 
204
    # os.path.realpath on Windows systems.
 
205
    def abspath(path):
 
206
        return os.path.abspath(path).replace('\\', '/')
 
207
 
 
208
    def realpath(path):
 
209
        return os.path.realpath(path).replace('\\', '/')
 
210
 
 
211
    def pathjoin(*args):
 
212
        return os.path.join(*args).replace('\\', '/')
 
213
 
 
214
    def normpath(path):
 
215
        return os.path.normpath(path).replace('\\', '/')
 
216
 
 
217
    def getcwd():
 
218
        return os.getcwdu().replace('\\', '/')
 
219
 
 
220
    def mkdtemp(*args, **kwargs):
 
221
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
222
 
 
223
    def rename(old, new):
 
224
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
225
 
 
226
    MIN_ABS_PATHLENGTH = 3
 
227
 
 
228
    def _win32_delete_readonly(function, path, excinfo):
 
229
        """Error handler for shutil.rmtree function [for win32]
 
230
        Helps to remove files and dirs marked as read-only.
 
231
        """
 
232
        type_, value = excinfo[:2]
 
233
        if function in (os.remove, os.rmdir) \
 
234
            and type_ == OSError \
 
235
            and value.errno == errno.EACCES:
 
236
            bzrlib.osutils.make_writable(path)
 
237
            function(path)
 
238
        else:
 
239
            raise
 
240
 
 
241
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
 
242
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
 
243
        return shutil.rmtree(path, ignore_errors, onerror)
 
244
 
 
245
 
 
246
def normalizepath(f):
 
247
    if hasattr(os.path, 'realpath'):
 
248
        F = realpath
 
249
    else:
 
250
        F = abspath
 
251
    [p,e] = os.path.split(f)
 
252
    if e == "" or e == "." or e == "..":
 
253
        return F(f)
 
254
    else:
 
255
        return pathjoin(F(p), e)
78
256
 
79
257
 
80
258
def backup_file(fn):
84
262
 
85
263
    If the file is already a backup, it's not copied.
86
264
    """
87
 
    import os
88
265
    if fn[-1] == '~':
89
266
        return
90
267
    bfn = fn + '~'
91
268
 
 
269
    if has_symlinks() and os.path.islink(fn):
 
270
        target = os.readlink(fn)
 
271
        os.symlink(target, bfn)
 
272
        return
92
273
    inf = file(fn, 'rb')
93
274
    try:
94
275
        content = inf.read()
101
282
    finally:
102
283
        outf.close()
103
284
 
104
 
def rename(path_from, path_to):
105
 
    """Basically the same as os.rename() just special for win32"""
106
 
    if sys.platform == 'win32':
107
 
        try:
108
 
            os.remove(path_to)
109
 
        except OSError, e:
110
 
            if e.errno != e.ENOENT:
111
 
                raise
112
 
    os.rename(path_from, path_to)
113
 
 
114
 
 
115
 
 
116
 
 
117
285
 
118
286
def isdir(f):
119
287
    """True if f is an accessible directory."""
123
291
        return False
124
292
 
125
293
 
126
 
 
127
294
def isfile(f):
128
295
    """True if f is a regular file."""
129
296
    try:
131
298
    except OSError:
132
299
        return False
133
300
 
 
301
def islink(f):
 
302
    """True if f is a symlink."""
 
303
    try:
 
304
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
305
    except OSError:
 
306
        return False
134
307
 
135
308
def is_inside(dir, fname):
136
309
    """True if fname is inside dir.
137
310
    
138
 
    The parameters should typically be passed to os.path.normpath first, so
 
311
    The parameters should typically be passed to osutils.normpath first, so
139
312
    that . and .. and repeated slashes are eliminated, and the separators
140
313
    are canonical for the platform.
141
314
    
142
315
    The empty string as a dir name is taken as top-of-tree and matches 
143
316
    everything.
144
317
    
145
 
    >>> is_inside('src', 'src/foo.c')
 
318
    >>> is_inside('src', pathjoin('src', 'foo.c'))
146
319
    True
147
320
    >>> is_inside('src', 'srccontrol')
148
321
    False
149
 
    >>> is_inside('src', 'src/a/a/a/foo.c')
 
322
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
150
323
    True
151
324
    >>> is_inside('foo.c', 'foo.c')
152
325
    True
162
335
    
163
336
    if dir == '':
164
337
        return True
165
 
    
166
 
    if dir[-1] != os.sep:
167
 
        dir += os.sep
168
 
    
 
338
 
 
339
    if dir[-1] != '/':
 
340
        dir += '/'
 
341
 
169
342
    return fname.startswith(dir)
170
343
 
171
344
 
180
353
 
181
354
def pumpfile(fromfile, tofile):
182
355
    """Copy contents of one file to another."""
183
 
    tofile.write(fromfile.read())
184
 
 
185
 
 
186
 
def uuid():
187
 
    """Return a new UUID"""
188
 
    try:
189
 
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
190
 
    except IOError:
191
 
        return chomp(os.popen('uuidgen').readline())
 
356
    BUFSIZE = 32768
 
357
    while True:
 
358
        b = fromfile.read(BUFSIZE)
 
359
        if not b:
 
360
            break
 
361
        tofile.write(b)
 
362
 
 
363
 
 
364
def file_iterator(input_file, readsize=32768):
 
365
    while True:
 
366
        b = input_file.read(readsize)
 
367
        if len(b) == 0:
 
368
            break
 
369
        yield b
192
370
 
193
371
 
194
372
def sha_file(f):
195
 
    import sha
196
373
    if hasattr(f, 'tell'):
197
374
        assert f.tell() == 0
198
375
    s = sha.new()
205
382
    return s.hexdigest()
206
383
 
207
384
 
 
385
 
 
386
def sha_strings(strings):
 
387
    """Return the sha-1 of concatenation of strings"""
 
388
    s = sha.new()
 
389
    map(s.update, strings)
 
390
    return s.hexdigest()
 
391
 
 
392
 
208
393
def sha_string(f):
209
 
    import sha
210
394
    s = sha.new()
211
395
    s.update(f)
212
396
    return s.hexdigest()
213
397
 
214
398
 
215
 
 
216
399
def fingerprint_file(f):
217
 
    import sha
218
400
    s = sha.new()
219
401
    b = f.read()
220
402
    s.update(b)
223
405
            'sha1': s.hexdigest()}
224
406
 
225
407
 
226
 
def config_dir():
227
 
    """Return per-user configuration directory.
228
 
 
229
 
    By default this is ~/.bzr.conf/
230
 
    
231
 
    TODO: Global option --config-dir to override this.
232
 
    """
233
 
    return os.path.expanduser("~/.bzr.conf")
234
 
 
235
 
 
236
 
def _auto_user_id():
237
 
    """Calculate automatic user identification.
238
 
 
239
 
    Returns (realname, email).
240
 
 
241
 
    Only used when none is set in the environment or the id file.
242
 
 
243
 
    This previously used the FQDN as the default domain, but that can
244
 
    be very slow on machines where DNS is broken.  So now we simply
245
 
    use the hostname.
246
 
    """
247
 
    import socket
248
 
 
249
 
    # XXX: Any good way to get real user name on win32?
250
 
 
251
 
    try:
252
 
        import pwd
253
 
        uid = os.getuid()
254
 
        w = pwd.getpwuid(uid)
255
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
256
 
        username = w.pw_name.decode(bzrlib.user_encoding)
257
 
        comma = gecos.find(',')
258
 
        if comma == -1:
259
 
            realname = gecos
260
 
        else:
261
 
            realname = gecos[:comma]
262
 
        if not realname:
263
 
            realname = username
264
 
 
265
 
    except ImportError:
266
 
        import getpass
267
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
268
 
 
269
 
    return realname, (username + '@' + socket.gethostname())
270
 
 
271
 
 
272
 
def _get_user_id():
273
 
    """Return the full user id from a file or environment variable.
274
 
 
275
 
    TODO: Allow taking this from a file in the branch directory too
276
 
    for per-branch ids."""
277
 
    v = os.environ.get('BZREMAIL')
278
 
    if v:
279
 
        return v.decode(bzrlib.user_encoding)
280
 
    
281
 
    try:
282
 
        return (open(os.path.join(config_dir(), "email"))
283
 
                .read()
284
 
                .decode(bzrlib.user_encoding)
285
 
                .rstrip("\r\n"))
286
 
    except IOError, e:
287
 
        if e.errno != errno.ENOENT:
288
 
            raise e
289
 
 
290
 
    v = os.environ.get('EMAIL')
291
 
    if v:
292
 
        return v.decode(bzrlib.user_encoding)
293
 
    else:    
294
 
        return None
295
 
 
296
 
 
297
 
def username():
298
 
    """Return email-style username.
299
 
 
300
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
301
 
 
302
 
    TODO: Check it's reasonably well-formed.
303
 
    """
304
 
    v = _get_user_id()
305
 
    if v:
306
 
        return v
307
 
    
308
 
    name, email = _auto_user_id()
309
 
    if name:
310
 
        return '%s <%s>' % (name, email)
311
 
    else:
312
 
        return email
313
 
 
314
 
 
315
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
316
 
def user_email():
317
 
    """Return just the email component of a username."""
318
 
    e = _get_user_id()
319
 
    if e:
320
 
        m = _EMAIL_RE.search(e)
321
 
        if not m:
322
 
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
323
 
        return m.group(0)
324
 
 
325
 
    return _auto_user_id()[1]
326
 
    
327
 
 
328
 
 
329
408
def compare_files(a, b):
330
409
    """Returns true if equal in contents"""
331
410
    BUFSIZE = 4096
338
417
            return True
339
418
 
340
419
 
341
 
 
342
420
def local_time_offset(t=None):
343
421
    """Return offset of local zone from GMT, either at present or at time t."""
344
422
    # python2.3 localtime() can't take None
351
429
        return -time.timezone
352
430
 
353
431
    
354
 
def format_date(t, offset=0, timezone='original'):
 
432
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
433
                show_offset=True):
355
434
    ## TODO: Perhaps a global option to use either universal or local time?
356
435
    ## Or perhaps just let people set $TZ?
357
436
    assert isinstance(t, float)
369
448
    else:
370
449
        raise BzrError("unsupported timezone format %r" % timezone,
371
450
                       ['options are "utc", "original", "local"'])
372
 
 
373
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
374
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
451
    if date_fmt is None:
 
452
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
453
    if show_offset:
 
454
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
455
    else:
 
456
        offset_str = ''
 
457
    return (time.strftime(date_fmt, tt) +  offset_str)
375
458
 
376
459
 
377
460
def compact_date(when):
384
467
    return os.fstat(f.fileno())[ST_SIZE]
385
468
 
386
469
 
387
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
470
# Define rand_bytes based on platform.
 
471
try:
 
472
    # Python 2.4 and later have os.urandom,
 
473
    # but it doesn't work on some arches
 
474
    os.urandom(1)
388
475
    rand_bytes = os.urandom
389
 
elif sys.platform == 'linux2':
390
 
    rand_bytes = file('/dev/urandom', 'rb').read
391
 
else:
392
 
    # not well seeded, but better than nothing
393
 
    def rand_bytes(n):
394
 
        import random
395
 
        s = ''
396
 
        while n:
397
 
            s += chr(random.randint(0, 255))
398
 
            n -= 1
399
 
        return s
 
476
except (NotImplementedError, AttributeError):
 
477
    # If python doesn't have os.urandom, or it doesn't work,
 
478
    # then try to first pull random data from /dev/urandom
 
479
    if os.path.exists("/dev/urandom"):
 
480
        rand_bytes = file('/dev/urandom', 'rb').read
 
481
    # Otherwise, use this hack as a last resort
 
482
    else:
 
483
        # not well seeded, but better than nothing
 
484
        def rand_bytes(n):
 
485
            import random
 
486
            s = ''
 
487
            while n:
 
488
                s += chr(random.randint(0, 255))
 
489
                n -= 1
 
490
            return s
 
491
 
 
492
 
 
493
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
494
def rand_chars(num):
 
495
    """Return a random string of num alphanumeric characters
 
496
    
 
497
    The result only contains lowercase chars because it may be used on 
 
498
    case-insensitive filesystems.
 
499
    """
 
500
    s = ''
 
501
    for raw_byte in rand_bytes(num):
 
502
        s += ALNUM[ord(raw_byte) % 36]
 
503
    return s
400
504
 
401
505
 
402
506
## TODO: We could later have path objects that remember their list
439
543
    for f in p:
440
544
        if (f == '..') or (f == None) or (f == ''):
441
545
            raise BzrError("sorry, %r not allowed in path" % f)
442
 
    return os.path.join(*p)
 
546
    return pathjoin(*p)
443
547
 
444
548
 
445
549
def appendpath(p1, p2):
446
550
    if p1 == '':
447
551
        return p2
448
552
    else:
449
 
        return os.path.join(p1, p2)
 
553
        return pathjoin(p1, p2)
450
554
    
451
555
 
452
 
def extern_command(cmd, ignore_errors = False):
453
 
    mutter('external command: %s' % `cmd`)
454
 
    if os.system(cmd):
455
 
        if not ignore_errors:
456
 
            raise BzrError('command failed')
457
 
 
458
 
 
459
 
def _read_config_value(name):
460
 
    """Read a config value from the file ~/.bzr.conf/<name>
461
 
    Return None if the file does not exist"""
462
 
    try:
463
 
        f = file(os.path.join(config_dir(), name), "r")
464
 
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
465
 
    except IOError, e:
466
 
        if e.errno == errno.ENOENT:
467
 
            return None
468
 
        raise
469
 
 
470
 
 
471
 
def _get_editor():
472
 
    """Return a sequence of possible editor binaries for the current platform"""
473
 
    e = _read_config_value("editor")
474
 
    if e is not None:
475
 
        yield e
 
556
def split_lines(s):
 
557
    """Split s into lines, but without removing the newline characters."""
 
558
    lines = s.split('\n')
 
559
    result = [line + '\n' for line in lines[:-1]]
 
560
    if lines[-1]:
 
561
        result.append(lines[-1])
 
562
    return result
 
563
 
 
564
 
 
565
def hardlinks_good():
 
566
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
567
 
 
568
 
 
569
def link_or_copy(src, dest):
 
570
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
571
    if not hardlinks_good():
 
572
        copyfile(src, dest)
 
573
        return
 
574
    try:
 
575
        os.link(src, dest)
 
576
    except (OSError, IOError), e:
 
577
        if e.errno != errno.EXDEV:
 
578
            raise
 
579
        copyfile(src, dest)
 
580
 
 
581
def delete_any(full_path):
 
582
    """Delete a file or directory."""
 
583
    try:
 
584
        os.unlink(full_path)
 
585
    except OSError, e:
 
586
    # We may be renaming a dangling inventory id
 
587
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
588
            raise
 
589
        os.rmdir(full_path)
 
590
 
 
591
 
 
592
def has_symlinks():
 
593
    if hasattr(os, 'symlink'):
 
594
        return True
 
595
    else:
 
596
        return False
476
597
        
477
 
    if os.name == "windows":
478
 
        yield "notepad.exe"
479
 
    elif os.name == "posix":
480
 
        try:
481
 
            yield os.environ["EDITOR"]
482
 
        except KeyError:
483
 
            yield "/usr/bin/vi"
484
 
 
485
 
 
486
 
def _run_editor(filename):
487
 
    """Try to execute an editor to edit the commit message. Returns True on success,
488
 
    False on failure"""
489
 
    for e in _get_editor():
490
 
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
491
 
        if x == 0:
492
 
            return True
493
 
        elif x == 127:
494
 
            continue
495
 
        else:
 
598
 
 
599
def contains_whitespace(s):
 
600
    """True if there are any whitespace characters in s."""
 
601
    for ch in string.whitespace:
 
602
        if ch in s:
 
603
            return True
 
604
    else:
 
605
        return False
 
606
 
 
607
 
 
608
def contains_linebreaks(s):
 
609
    """True if there is any vertical whitespace in s."""
 
610
    for ch in '\f\n\r':
 
611
        if ch in s:
 
612
            return True
 
613
    else:
 
614
        return False
 
615
 
 
616
 
 
617
def relpath(base, path):
 
618
    """Return path relative to base, or raise exception.
 
619
 
 
620
    The path may be either an absolute path or a path relative to the
 
621
    current working directory.
 
622
 
 
623
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
624
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
625
    avoids that problem.
 
626
    """
 
627
 
 
628
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
 
629
        ' exceed the platform minimum length (which is %d)' % 
 
630
        MIN_ABS_PATHLENGTH)
 
631
    rp = abspath(path)
 
632
 
 
633
    s = []
 
634
    head = rp
 
635
    while len(head) >= len(base):
 
636
        if head == base:
496
637
            break
497
 
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
498
 
    return False
499
 
                          
500
 
 
501
 
def get_text_message(infotext, ignoreline = "default"):
502
 
    import tempfile
503
 
    
504
 
    if ignoreline == "default":
505
 
        ignoreline = "-- This line and the following will be ignored --"
506
 
        
507
 
    try:
508
 
        tmp_fileno, msgfilename = tempfile.mkstemp()
509
 
        msgfile = os.close(tmp_fileno)
510
 
        if infotext is not None and infotext != "":
511
 
            hasinfo = True
512
 
            msgfile = file(msgfilename, "w")
513
 
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
514
 
            msgfile.close()
515
 
        else:
516
 
            hasinfo = False
517
 
 
518
 
        if not _run_editor(msgfilename):
519
 
            return None
520
 
        
521
 
        started = False
522
 
        msg = []
523
 
        lastline, nlines = 0, 0
524
 
        for line in file(msgfilename, "r"):
525
 
            stripped_line = line.strip()
526
 
            # strip empty line before the log message starts
527
 
            if not started:
528
 
                if stripped_line != "":
529
 
                    started = True
530
 
                else:
531
 
                    continue
532
 
            # check for the ignore line only if there
533
 
            # is additional information at the end
534
 
            if hasinfo and stripped_line == ignoreline:
535
 
                break
536
 
            nlines += 1
537
 
            # keep track of the last line that had some content
538
 
            if stripped_line != "":
539
 
                lastline = nlines
540
 
            msg.append(line)
541
 
            
542
 
        if len(msg) == 0:
543
 
            return None
544
 
        # delete empty lines at the end
545
 
        del msg[lastline:]
546
 
        # add a newline at the end, if needed
547
 
        if not msg[-1].endswith("\n"):
548
 
            return "%s%s" % ("".join(msg), "\n")
549
 
        else:
550
 
            return "".join(msg)
551
 
    finally:
552
 
        # delete the msg file in any case
553
 
        try: os.unlink(msgfilename)
554
 
        except IOError: pass
 
638
        head, tail = os.path.split(head)
 
639
        if tail:
 
640
            s.insert(0, tail)
 
641
    else:
 
642
        # XXX This should raise a NotChildPath exception, as its not tied
 
643
        # to branch anymore.
 
644
        raise PathNotChild(rp, base)
 
645
 
 
646
    if s:
 
647
        return pathjoin(*s)
 
648
    else:
 
649
        return ''
 
650
 
 
651
 
 
652
def safe_unicode(unicode_or_utf8_string):
 
653
    """Coerce unicode_or_utf8_string into unicode.
 
654
 
 
655
    If it is unicode, it is returned.
 
656
    Otherwise it is decoded from utf-8. If a decoding error
 
657
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
658
    as a BzrBadParameter exception.
 
659
    """
 
660
    if isinstance(unicode_or_utf8_string, unicode):
 
661
        return unicode_or_utf8_string
 
662
    try:
 
663
        return unicode_or_utf8_string.decode('utf8')
 
664
    except UnicodeDecodeError:
 
665
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
666
 
 
667
 
 
668
def terminal_width():
 
669
    """Return estimated terminal width."""
 
670
 
 
671
    # TODO: Do something smart on Windows?
 
672
 
 
673
    # TODO: Is there anything that gets a better update when the window
 
674
    # is resized while the program is running? We could use the Python termcap
 
675
    # library.
 
676
    try:
 
677
        return int(os.environ['COLUMNS'])
 
678
    except (IndexError, KeyError, ValueError):
 
679
        return 80
 
680
 
 
681
def supports_executable():
 
682
    return sys.platform != "win32"
 
683
 
 
684
 
 
685
def strip_trailing_slash(path):
 
686
    """Strip trailing slash, except for root paths.
 
687
    The definition of 'root path' is platform-dependent.
 
688
    """
 
689
    if len(path) != MIN_ABS_PATHLENGTH and path[-1] == '/':
 
690
        return path[:-1]
 
691
    else:
 
692
        return path
 
693
 
 
694
 
 
695
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
 
696
 
 
697
 
 
698
def check_legal_path(path):
 
699
    """Check whether the supplied path is legal.  
 
700
    This is only required on Windows, so we don't test on other platforms
 
701
    right now.
 
702
    """
 
703
    if sys.platform != "win32":
 
704
        return
 
705
    if _validWin32PathRE.match(path) is None:
 
706
        raise IllegalPath(path)