~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-08-19 21:34:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050819213432-4fa923a97c45d845
- add schema and example for new inventory form

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
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
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
32
21
 
 
22
from bzrlib.errors import BzrError
 
23
from bzrlib.trace import mutter
33
24
import bzrlib
34
 
from bzrlib.errors import (BzrError,
35
 
                           BzrBadParameter,
36
 
                           NoSuchFile,
37
 
                           PathNotChild,
38
 
                           )
39
 
from bzrlib.trace import mutter
40
 
 
41
25
 
42
26
def make_readonly(filename):
43
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
44
29
    mod = os.stat(filename).st_mode
45
30
    mod = mod & 0777555
46
31
    os.chmod(filename, mod)
63
48
    # TODO: I'm not really sure this is the best format either.x
64
49
    global _QUOTE_RE
65
50
    if _QUOTE_RE == None:
66
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
51
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
67
52
        
68
53
    if _QUOTE_RE.search(f):
69
54
        return '"' + f + '"'
79
64
        return 'directory'
80
65
    elif S_ISLNK(mode):
81
66
        return 'symlink'
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
67
    else:
91
 
        return 'unknown'
 
68
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
92
69
 
93
70
 
94
71
def kind_marker(kind):
101
78
    else:
102
79
        raise BzrError('invalid file kind %r' % kind)
103
80
 
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
81
 
232
82
 
233
83
def backup_file(fn):
237
87
 
238
88
    If the file is already a backup, it's not copied.
239
89
    """
 
90
    import os
240
91
    if fn[-1] == '~':
241
92
        return
242
93
    bfn = fn + '~'
243
94
 
244
 
    if has_symlinks() and os.path.islink(fn):
245
 
        target = os.readlink(fn)
246
 
        os.symlink(target, bfn)
247
 
        return
248
95
    inf = file(fn, 'rb')
249
96
    try:
250
97
        content = inf.read()
257
104
    finally:
258
105
        outf.close()
259
106
 
 
107
def rename(path_from, path_to):
 
108
    """Basically the same as os.rename() just special for win32"""
 
109
    if sys.platform == 'win32':
 
110
        try:
 
111
            os.remove(path_to)
 
112
        except OSError, e:
 
113
            if e.errno != e.ENOENT:
 
114
                raise
 
115
    os.rename(path_from, path_to)
 
116
 
 
117
 
 
118
 
 
119
 
260
120
 
261
121
def isdir(f):
262
122
    """True if f is an accessible directory."""
266
126
        return False
267
127
 
268
128
 
 
129
 
269
130
def isfile(f):
270
131
    """True if f is a regular file."""
271
132
    try:
273
134
    except OSError:
274
135
        return False
275
136
 
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
137
 
283
138
def is_inside(dir, fname):
284
139
    """True if fname is inside dir.
285
140
    
286
 
    The parameters should typically be passed to osutils.normpath first, so
 
141
    The parameters should typically be passed to os.path.normpath first, so
287
142
    that . and .. and repeated slashes are eliminated, and the separators
288
143
    are canonical for the platform.
289
144
    
290
145
    The empty string as a dir name is taken as top-of-tree and matches 
291
146
    everything.
292
147
    
293
 
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
148
    >>> is_inside('src', 'src/foo.c')
294
149
    True
295
150
    >>> is_inside('src', 'srccontrol')
296
151
    False
297
 
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
152
    >>> is_inside('src', 'src/a/a/a/foo.c')
298
153
    True
299
154
    >>> is_inside('foo.c', 'foo.c')
300
155
    True
310
165
    
311
166
    if dir == '':
312
167
        return True
313
 
 
314
 
    if dir[-1] != '/':
315
 
        dir += '/'
316
 
 
 
168
    
 
169
    if dir[-1] != os.sep:
 
170
        dir += os.sep
 
171
    
317
172
    return fname.startswith(dir)
318
173
 
319
174
 
328
183
 
329
184
def pumpfile(fromfile, tofile):
330
185
    """Copy contents of one file to another."""
331
 
    BUFSIZE = 32768
332
 
    while True:
333
 
        b = fromfile.read(BUFSIZE)
334
 
        if not b:
335
 
            break
336
 
        tofile.write(b)
 
186
    tofile.write(fromfile.read())
 
187
 
 
188
 
 
189
def uuid():
 
190
    """Return a new UUID"""
 
191
    try:
 
192
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
193
    except IOError:
 
194
        return chomp(os.popen('uuidgen').readline())
337
195
 
338
196
 
339
197
def sha_file(f):
 
198
    import sha
340
199
    if hasattr(f, 'tell'):
341
200
        assert f.tell() == 0
342
201
    s = sha.new()
349
208
    return s.hexdigest()
350
209
 
351
210
 
352
 
 
353
 
def sha_strings(strings):
354
 
    """Return the sha-1 of concatenation of strings"""
355
 
    s = sha.new()
356
 
    map(s.update, strings)
357
 
    return s.hexdigest()
358
 
 
359
 
 
360
211
def sha_string(f):
 
212
    import sha
361
213
    s = sha.new()
362
214
    s.update(f)
363
215
    return s.hexdigest()
364
216
 
365
217
 
 
218
 
366
219
def fingerprint_file(f):
 
220
    import sha
367
221
    s = sha.new()
368
222
    b = f.read()
369
223
    s.update(b)
372
226
            'sha1': s.hexdigest()}
373
227
 
374
228
 
 
229
def config_dir():
 
230
    """Return per-user configuration directory.
 
231
 
 
232
    By default this is ~/.bzr.conf/
 
233
    
 
234
    TODO: Global option --config-dir to override this.
 
235
    """
 
236
    return os.path.expanduser("~/.bzr.conf")
 
237
 
 
238
 
 
239
def _auto_user_id():
 
240
    """Calculate automatic user identification.
 
241
 
 
242
    Returns (realname, email).
 
243
 
 
244
    Only used when none is set in the environment or the id file.
 
245
 
 
246
    This previously used the FQDN as the default domain, but that can
 
247
    be very slow on machines where DNS is broken.  So now we simply
 
248
    use the hostname.
 
249
    """
 
250
    import socket
 
251
 
 
252
    # XXX: Any good way to get real user name on win32?
 
253
 
 
254
    try:
 
255
        import pwd
 
256
        uid = os.getuid()
 
257
        w = pwd.getpwuid(uid)
 
258
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
259
        username = w.pw_name.decode(bzrlib.user_encoding)
 
260
        comma = gecos.find(',')
 
261
        if comma == -1:
 
262
            realname = gecos
 
263
        else:
 
264
            realname = gecos[:comma]
 
265
        if not realname:
 
266
            realname = username
 
267
 
 
268
    except ImportError:
 
269
        import getpass
 
270
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
271
 
 
272
    return realname, (username + '@' + socket.gethostname())
 
273
 
 
274
 
 
275
def _get_user_id(branch):
 
276
    """Return the full user id from a file or environment variable.
 
277
 
 
278
    e.g. "John Hacker <jhacker@foo.org>"
 
279
 
 
280
    branch
 
281
        A branch to use for a per-branch configuration, or None.
 
282
 
 
283
    The following are searched in order:
 
284
 
 
285
    1. $BZREMAIL
 
286
    2. .bzr/email for this branch.
 
287
    3. ~/.bzr.conf/email
 
288
    4. $EMAIL
 
289
    """
 
290
    v = os.environ.get('BZREMAIL')
 
291
    if v:
 
292
        return v.decode(bzrlib.user_encoding)
 
293
 
 
294
    if branch:
 
295
        try:
 
296
            return (branch.controlfile("email", "r") 
 
297
                    .read()
 
298
                    .decode(bzrlib.user_encoding)
 
299
                    .rstrip("\r\n"))
 
300
        except IOError, e:
 
301
            if e.errno != errno.ENOENT:
 
302
                raise
 
303
        except BzrError, e:
 
304
            pass
 
305
    
 
306
    try:
 
307
        return (open(os.path.join(config_dir(), "email"))
 
308
                .read()
 
309
                .decode(bzrlib.user_encoding)
 
310
                .rstrip("\r\n"))
 
311
    except IOError, e:
 
312
        if e.errno != errno.ENOENT:
 
313
            raise e
 
314
 
 
315
    v = os.environ.get('EMAIL')
 
316
    if v:
 
317
        return v.decode(bzrlib.user_encoding)
 
318
    else:    
 
319
        return None
 
320
 
 
321
 
 
322
def username(branch):
 
323
    """Return email-style username.
 
324
 
 
325
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
326
 
 
327
    TODO: Check it's reasonably well-formed.
 
328
    """
 
329
    v = _get_user_id(branch)
 
330
    if v:
 
331
        return v
 
332
    
 
333
    name, email = _auto_user_id()
 
334
    if name:
 
335
        return '%s <%s>' % (name, email)
 
336
    else:
 
337
        return email
 
338
 
 
339
 
 
340
def user_email(branch):
 
341
    """Return just the email component of a username."""
 
342
    e = _get_user_id(branch)
 
343
    if e:
 
344
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
345
        if not m:
 
346
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
347
        return m.group(0)
 
348
 
 
349
    return _auto_user_id()[1]
 
350
    
 
351
 
 
352
 
375
353
def compare_files(a, b):
376
354
    """Returns true if equal in contents"""
377
355
    BUFSIZE = 4096
384
362
            return True
385
363
 
386
364
 
 
365
 
387
366
def local_time_offset(t=None):
388
367
    """Return offset of local zone from GMT, either at present or at time t."""
389
368
    # python2.3 localtime() can't take None
396
375
        return -time.timezone
397
376
 
398
377
    
399
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
400
 
                show_offset=True):
 
378
def format_date(t, offset=0, timezone='original'):
401
379
    ## TODO: Perhaps a global option to use either universal or local time?
402
380
    ## Or perhaps just let people set $TZ?
403
381
    assert isinstance(t, float)
415
393
    else:
416
394
        raise BzrError("unsupported timezone format %r" % timezone,
417
395
                       ['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)
 
396
 
 
397
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
398
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
425
399
 
426
400
 
427
401
def compact_date(when):
433
407
    """Return size of given open file."""
434
408
    return os.fstat(f.fileno())[ST_SIZE]
435
409
 
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)
 
410
 
 
411
if hasattr(os, 'urandom'): # python 2.4 and later
441
412
    rand_bytes = os.urandom
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
 
413
elif sys.platform == 'linux2':
 
414
    rand_bytes = file('/dev/urandom', 'rb').read
 
415
else:
 
416
    # not well seeded, but better than nothing
 
417
    def rand_bytes(n):
 
418
        import random
 
419
        s = ''
 
420
        while n:
 
421
            s += chr(random.randint(0, 255))
 
422
            n -= 1
 
423
        return s
 
424
 
457
425
 
458
426
## TODO: We could later have path objects that remember their list
459
427
## decomposition (might be too tricksy though.)
495
463
    for f in p:
496
464
        if (f == '..') or (f == None) or (f == ''):
497
465
            raise BzrError("sorry, %r not allowed in path" % f)
498
 
    return pathjoin(*p)
 
466
    return os.path.join(*p)
499
467
 
500
468
 
501
469
def appendpath(p1, p2):
502
470
    if p1 == '':
503
471
        return p2
504
472
    else:
505
 
        return pathjoin(p1, p2)
 
473
        return os.path.join(p1, p2)
506
474
    
507
475
 
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
 
476
def extern_command(cmd, ignore_errors = False):
 
477
    mutter('external command: %s' % `cmd`)
 
478
    if os.system(cmd):
 
479
        if not ignore_errors:
 
480
            raise BzrError('command failed')
 
481
 
 
482
 
 
483
def _read_config_value(name):
 
484
    """Read a config value from the file ~/.bzr.conf/<name>
 
485
    Return None if the file does not exist"""
522
486
    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
 
487
        f = file(os.path.join(config_dir(), name), "r")
 
488
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
489
    except IOError, e:
 
490
        if e.errno == errno.ENOENT:
 
491
            return None
 
492
        raise
 
493
 
 
494
 
 
495
def _get_editor():
 
496
    """Return a sequence of possible editor binaries for the current platform"""
 
497
    e = _read_config_value("editor")
 
498
    if e is not None:
 
499
        yield e
535
500
        
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:
 
501
    if os.name == "windows":
 
502
        yield "notepad.exe"
 
503
    elif os.name == "posix":
 
504
        try:
 
505
            yield os.environ["EDITOR"]
 
506
        except KeyError:
 
507
            yield "/usr/bin/vi"
 
508
 
 
509
 
 
510
def _run_editor(filename):
 
511
    """Try to execute an editor to edit the commit message. Returns True on success,
 
512
    False on failure"""
 
513
    for e in _get_editor():
 
514
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
 
515
        if x == 0:
 
516
            return True
 
517
        elif x == 127:
 
518
            continue
 
519
        else:
570
520
            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
 
521
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
 
522
    return False
 
523
                          
 
524
 
 
525
def get_text_message(infotext, ignoreline = "default"):
 
526
    import tempfile
 
527
    
 
528
    if ignoreline == "default":
 
529
        ignoreline = "-- This line and the following will be ignored --"
 
530
        
 
531
    try:
 
532
        tmp_fileno, msgfilename = tempfile.mkstemp()
 
533
        msgfile = os.close(tmp_fileno)
 
534
        if infotext is not None and infotext != "":
 
535
            hasinfo = True
 
536
            msgfile = file(msgfilename, "w")
 
537
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
 
538
            msgfile.close()
 
539
        else:
 
540
            hasinfo = False
 
541
 
 
542
        if not _run_editor(msgfilename):
 
543
            return None
 
544
        
 
545
        started = False
 
546
        msg = []
 
547
        lastline, nlines = 0, 0
 
548
        for line in file(msgfilename, "r"):
 
549
            stripped_line = line.strip()
 
550
            # strip empty line before the log message starts
 
551
            if not started:
 
552
                if stripped_line != "":
 
553
                    started = True
 
554
                else:
 
555
                    continue
 
556
            # check for the ignore line only if there
 
557
            # is additional information at the end
 
558
            if hasinfo and stripped_line == ignoreline:
 
559
                break
 
560
            nlines += 1
 
561
            # keep track of the last line that had some content
 
562
            if stripped_line != "":
 
563
                lastline = nlines
 
564
            msg.append(line)
 
565
            
 
566
        if len(msg) == 0:
 
567
            return None
 
568
        # delete empty lines at the end
 
569
        del msg[lastline:]
 
570
        # add a newline at the end, if needed
 
571
        if not msg[-1].endswith("\n"):
 
572
            return "%s%s" % ("".join(msg), "\n")
 
573
        else:
 
574
            return "".join(msg)
 
575
    finally:
 
576
        # delete the msg file in any case
 
577
        try: os.unlink(msgfilename)
 
578
        except IOError: pass