~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-07-22 19:32:52 UTC
  • Revision ID: mbp@sourcefrog.net-20050722193252-d3cdd1bd566c9f6a
doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Bazaar -- distributed version control
2
 
#
 
1
# Bazaar-NG -- distributed version control
 
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 cStringIO import StringIO
20
 
import errno
21
 
from ntpath import (abspath as _nt_abspath,
22
 
                    join as _nt_join,
23
 
                    normpath as _nt_normpath,
24
 
                    realpath as _nt_realpath,
25
 
                    splitdrive as _nt_splitdrive,
26
 
                    )
27
 
import os
28
 
from os import listdir
29
 
import posixpath
30
 
import re
31
 
import sha
32
 
import shutil
33
 
from shutil import copyfile
34
 
import stat
35
 
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
36
 
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
37
 
import string
38
 
import sys
39
 
import time
40
 
import types
41
 
import tempfile
42
 
import unicodedata
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
43
21
 
 
22
from bzrlib.errors import BzrError
 
23
from bzrlib.trace import mutter
44
24
import bzrlib
45
 
from bzrlib.errors import (BzrError,
46
 
                           BzrBadParameterNotUnicode,
47
 
                           NoSuchFile,
48
 
                           PathNotChild,
49
 
                           IllegalPath,
50
 
                           )
51
 
from bzrlib.symbol_versioning import (deprecated_function, 
52
 
        zero_nine)
53
 
from bzrlib.trace import mutter
54
 
 
55
 
 
56
 
# On win32, O_BINARY is used to indicate the file should
57
 
# be opened in binary mode, rather than text mode.
58
 
# On other platforms, O_BINARY doesn't exist, because
59
 
# they always open in binary mode, so it is okay to
60
 
# OR with 0 on those platforms
61
 
O_BINARY = getattr(os, 'O_BINARY', 0)
62
 
 
63
25
 
64
26
def make_readonly(filename):
65
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
66
29
    mod = os.stat(filename).st_mode
67
30
    mod = mod & 0777555
68
31
    os.chmod(filename, mod)
74
37
    os.chmod(filename, mod)
75
38
 
76
39
 
77
 
_QUOTE_RE = None
78
 
 
79
 
 
 
40
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
80
41
def quotefn(f):
81
42
    """Return a quoted filename filename
82
43
 
83
44
    This previously used backslash quoting, but that works poorly on
84
45
    Windows."""
85
46
    # TODO: I'm not really sure this is the best format either.x
86
 
    global _QUOTE_RE
87
 
    if _QUOTE_RE == None:
88
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
89
 
        
90
47
    if _QUOTE_RE.search(f):
91
48
        return '"' + f + '"'
92
49
    else:
93
50
        return f
94
51
 
95
52
 
96
 
_directory_kind = 'directory'
97
 
 
98
 
_formats = {
99
 
    stat.S_IFDIR:_directory_kind,
100
 
    stat.S_IFCHR:'chardev',
101
 
    stat.S_IFBLK:'block',
102
 
    stat.S_IFREG:'file',
103
 
    stat.S_IFIFO:'fifo',
104
 
    stat.S_IFLNK:'symlink',
105
 
    stat.S_IFSOCK:'socket',
106
 
}
107
 
 
108
 
 
109
 
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
110
 
    """Generate a file kind from a stat mode. This is used in walkdirs.
111
 
 
112
 
    Its performance is critical: Do not mutate without careful benchmarking.
113
 
    """
114
 
    try:
115
 
        return _formats[stat_mode & 0170000]
116
 
    except KeyError:
117
 
        return _unknown
118
 
 
119
 
 
120
 
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
121
 
    try:
122
 
        return _mapper(_lstat(f).st_mode)
123
 
    except OSError, e:
124
 
        if getattr(e, 'errno', None) == errno.ENOENT:
125
 
            raise bzrlib.errors.NoSuchFile(f)
126
 
        raise
127
 
 
128
 
 
129
 
def get_umask():
130
 
    """Return the current umask"""
131
 
    # Assume that people aren't messing with the umask while running
132
 
    # XXX: This is not thread safe, but there is no way to get the
133
 
    #      umask without setting it
134
 
    umask = os.umask(0)
135
 
    os.umask(umask)
136
 
    return umask
 
53
def file_kind(f):
 
54
    mode = os.lstat(f)[ST_MODE]
 
55
    if S_ISREG(mode):
 
56
        return 'file'
 
57
    elif S_ISDIR(mode):
 
58
        return 'directory'
 
59
    elif S_ISLNK(mode):
 
60
        return 'symlink'
 
61
    else:
 
62
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
137
63
 
138
64
 
139
65
def kind_marker(kind):
140
66
    if kind == 'file':
141
67
        return ''
142
 
    elif kind == _directory_kind:
 
68
    elif kind == 'directory':
143
69
        return '/'
144
70
    elif kind == 'symlink':
145
71
        return '@'
146
72
    else:
147
73
        raise BzrError('invalid file kind %r' % kind)
148
74
 
149
 
lexists = getattr(os.path, 'lexists', None)
150
 
if lexists is None:
151
 
    def lexists(f):
152
 
        try:
153
 
            if hasattr(os, 'lstat'):
154
 
                os.lstat(f)
155
 
            else:
156
 
                os.stat(f)
157
 
            return True
158
 
        except OSError,e:
159
 
            if e.errno == errno.ENOENT:
160
 
                return False;
161
 
            else:
162
 
                raise BzrError("lstat/stat of (%r): %r" % (f, e))
163
 
 
164
 
 
165
 
def fancy_rename(old, new, rename_func, unlink_func):
166
 
    """A fancy rename, when you don't have atomic rename.
167
 
    
168
 
    :param old: The old path, to rename from
169
 
    :param new: The new path, to rename to
170
 
    :param rename_func: The potentially non-atomic rename function
171
 
    :param unlink_func: A way to delete the target file if the full rename succeeds
172
 
    """
173
 
 
174
 
    # sftp rename doesn't allow overwriting, so play tricks:
175
 
    import random
176
 
    base = os.path.basename(new)
177
 
    dirname = os.path.dirname(new)
178
 
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
179
 
    tmp_name = pathjoin(dirname, tmp_name)
180
 
 
181
 
    # Rename the file out of the way, but keep track if it didn't exist
182
 
    # We don't want to grab just any exception
183
 
    # something like EACCES should prevent us from continuing
184
 
    # The downside is that the rename_func has to throw an exception
185
 
    # with an errno = ENOENT, or NoSuchFile
186
 
    file_existed = False
187
 
    try:
188
 
        rename_func(new, tmp_name)
189
 
    except (NoSuchFile,), e:
190
 
        pass
191
 
    except IOError, e:
192
 
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
193
 
        # function raises an IOError with errno == None when a rename fails.
194
 
        # This then gets caught here.
195
 
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
196
 
            raise
197
 
    except Exception, e:
198
 
        if (not hasattr(e, 'errno') 
199
 
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
200
 
            raise
201
 
    else:
202
 
        file_existed = True
203
 
 
204
 
    success = False
205
 
    try:
206
 
        # This may throw an exception, in which case success will
207
 
        # not be set.
208
 
        rename_func(old, new)
209
 
        success = True
210
 
    finally:
211
 
        if file_existed:
212
 
            # If the file used to exist, rename it back into place
213
 
            # otherwise just delete it from the tmp location
214
 
            if success:
215
 
                unlink_func(tmp_name)
216
 
            else:
217
 
                rename_func(tmp_name, new)
218
 
 
219
 
 
220
 
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
221
 
# choke on a Unicode string containing a relative path if
222
 
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
223
 
# string.
224
 
_fs_enc = sys.getfilesystemencoding()
225
 
def _posix_abspath(path):
226
 
    # jam 20060426 rather than encoding to fsencoding
227
 
    # copy posixpath.abspath, but use os.getcwdu instead
228
 
    if not posixpath.isabs(path):
229
 
        path = posixpath.join(getcwd(), path)
230
 
    return posixpath.normpath(path)
231
 
 
232
 
 
233
 
def _posix_realpath(path):
234
 
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
235
 
 
236
 
 
237
 
def _win32_fixdrive(path):
238
 
    """Force drive letters to be consistent.
239
 
 
240
 
    win32 is inconsistent whether it returns lower or upper case
241
 
    and even if it was consistent the user might type the other
242
 
    so we force it to uppercase
243
 
    running python.exe under cmd.exe return capital C:\\
244
 
    running win32 python inside a cygwin shell returns lowercase c:\\
245
 
    """
246
 
    drive, path = _nt_splitdrive(path)
247
 
    return drive.upper() + path
248
 
 
249
 
 
250
 
def _win32_abspath(path):
251
 
    # Real _nt_abspath doesn't have a problem with a unicode cwd
252
 
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
253
 
 
254
 
 
255
 
def _win32_realpath(path):
256
 
    # Real _nt_realpath doesn't have a problem with a unicode cwd
257
 
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
258
 
 
259
 
 
260
 
def _win32_pathjoin(*args):
261
 
    return _nt_join(*args).replace('\\', '/')
262
 
 
263
 
 
264
 
def _win32_normpath(path):
265
 
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
266
 
 
267
 
 
268
 
def _win32_getcwd():
269
 
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
270
 
 
271
 
 
272
 
def _win32_mkdtemp(*args, **kwargs):
273
 
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
274
 
 
275
 
 
276
 
def _win32_rename(old, new):
277
 
    """We expect to be able to atomically replace 'new' with old.
278
 
 
279
 
    On win32, if new exists, it must be moved out of the way first,
280
 
    and then deleted. 
281
 
    """
282
 
    try:
283
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
284
 
    except OSError, e:
285
 
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
286
 
            # If we try to rename a non-existant file onto cwd, we get 
287
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
288
 
            # if the old path doesn't exist, sometimes we get EACCES
289
 
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
290
 
            os.lstat(old)
291
 
        raise
292
 
 
293
 
 
294
 
def _mac_getcwd():
295
 
    return unicodedata.normalize('NFKC', os.getcwdu())
296
 
 
297
 
 
298
 
# Default is to just use the python builtins, but these can be rebound on
299
 
# particular platforms.
300
 
abspath = _posix_abspath
301
 
realpath = _posix_realpath
302
 
pathjoin = os.path.join
303
 
normpath = os.path.normpath
304
 
getcwd = os.getcwdu
305
 
mkdtemp = tempfile.mkdtemp
306
 
rename = os.rename
307
 
dirname = os.path.dirname
308
 
basename = os.path.basename
309
 
rmtree = shutil.rmtree
310
 
 
311
 
MIN_ABS_PATHLENGTH = 1
312
 
 
313
 
 
314
 
if sys.platform == 'win32':
315
 
    abspath = _win32_abspath
316
 
    realpath = _win32_realpath
317
 
    pathjoin = _win32_pathjoin
318
 
    normpath = _win32_normpath
319
 
    getcwd = _win32_getcwd
320
 
    mkdtemp = _win32_mkdtemp
321
 
    rename = _win32_rename
322
 
 
323
 
    MIN_ABS_PATHLENGTH = 3
324
 
 
325
 
    def _win32_delete_readonly(function, path, excinfo):
326
 
        """Error handler for shutil.rmtree function [for win32]
327
 
        Helps to remove files and dirs marked as read-only.
328
 
        """
329
 
        type_, value = excinfo[:2]
330
 
        if function in (os.remove, os.rmdir) \
331
 
            and type_ == OSError \
332
 
            and value.errno == errno.EACCES:
333
 
            bzrlib.osutils.make_writable(path)
334
 
            function(path)
335
 
        else:
336
 
            raise
337
 
 
338
 
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
339
 
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
340
 
        return shutil.rmtree(path, ignore_errors, onerror)
341
 
elif sys.platform == 'darwin':
342
 
    getcwd = _mac_getcwd
343
 
 
344
 
 
345
 
def get_terminal_encoding():
346
 
    """Find the best encoding for printing to the screen.
347
 
 
348
 
    This attempts to check both sys.stdout and sys.stdin to see
349
 
    what encoding they are in, and if that fails it falls back to
350
 
    bzrlib.user_encoding.
351
 
    The problem is that on Windows, locale.getpreferredencoding()
352
 
    is not the same encoding as that used by the console:
353
 
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
354
 
 
355
 
    On my standard US Windows XP, the preferred encoding is
356
 
    cp1252, but the console is cp437
357
 
    """
358
 
    output_encoding = getattr(sys.stdout, 'encoding', None)
359
 
    if not output_encoding:
360
 
        input_encoding = getattr(sys.stdin, 'encoding', None)
361
 
        if not input_encoding:
362
 
            output_encoding = bzrlib.user_encoding
363
 
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
364
 
        else:
365
 
            output_encoding = input_encoding
366
 
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
367
 
    else:
368
 
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
369
 
    return output_encoding
370
 
 
371
 
 
372
 
def normalizepath(f):
373
 
    if hasattr(os.path, 'realpath'):
374
 
        F = realpath
375
 
    else:
376
 
        F = abspath
377
 
    [p,e] = os.path.split(f)
378
 
    if e == "" or e == "." or e == "..":
379
 
        return F(f)
380
 
    else:
381
 
        return pathjoin(F(p), e)
382
75
 
383
76
 
384
77
def backup_file(fn):
388
81
 
389
82
    If the file is already a backup, it's not copied.
390
83
    """
 
84
    import os
391
85
    if fn[-1] == '~':
392
86
        return
393
87
    bfn = fn + '~'
394
88
 
395
 
    if has_symlinks() and os.path.islink(fn):
396
 
        target = os.readlink(fn)
397
 
        os.symlink(target, bfn)
398
 
        return
399
89
    inf = file(fn, 'rb')
400
90
    try:
401
91
        content = inf.read()
408
98
    finally:
409
99
        outf.close()
410
100
 
 
101
def rename(path_from, path_to):
 
102
    """Basically the same as os.rename() just special for win32"""
 
103
    if sys.platform == 'win32':
 
104
        try:
 
105
            os.remove(path_to)
 
106
        except OSError, e:
 
107
            if e.errno != e.ENOENT:
 
108
                raise
 
109
    os.rename(path_from, path_to)
 
110
 
 
111
 
 
112
 
 
113
 
411
114
 
412
115
def isdir(f):
413
116
    """True if f is an accessible directory."""
417
120
        return False
418
121
 
419
122
 
 
123
 
420
124
def isfile(f):
421
125
    """True if f is a regular file."""
422
126
    try:
424
128
    except OSError:
425
129
        return False
426
130
 
427
 
def islink(f):
428
 
    """True if f is a symlink."""
429
 
    try:
430
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
431
 
    except OSError:
432
 
        return False
433
131
 
434
132
def is_inside(dir, fname):
435
133
    """True if fname is inside dir.
436
 
    
437
 
    The parameters should typically be passed to osutils.normpath first, so
438
 
    that . and .. and repeated slashes are eliminated, and the separators
439
 
    are canonical for the platform.
440
 
    
441
 
    The empty string as a dir name is taken as top-of-tree and matches 
442
 
    everything.
443
 
    
444
 
    >>> is_inside('src', pathjoin('src', 'foo.c'))
445
 
    True
446
 
    >>> is_inside('src', 'srccontrol')
447
 
    False
448
 
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
449
 
    True
450
 
    >>> is_inside('foo.c', 'foo.c')
451
 
    True
452
 
    >>> is_inside('foo.c', '')
453
 
    False
454
 
    >>> is_inside('', 'foo.c')
455
 
    True
456
134
    """
457
 
    # XXX: Most callers of this can actually do something smarter by 
458
 
    # looking at the inventory
459
 
    if dir == fname:
460
 
        return True
461
 
    
462
 
    if dir == '':
463
 
        return True
464
 
 
465
 
    if dir[-1] != '/':
466
 
        dir += '/'
467
 
 
468
 
    return fname.startswith(dir)
 
135
    return os.path.commonprefix([dir, fname]) == dir
469
136
 
470
137
 
471
138
def is_inside_any(dir_list, fname):
472
139
    """True if fname is inside any of given dirs."""
 
140
    # quick scan for perfect match
 
141
    if fname in dir_list:
 
142
        return True
 
143
    
473
144
    for dirname in dir_list:
474
145
        if is_inside(dirname, fname):
475
146
            return True
477
148
        return False
478
149
 
479
150
 
480
 
def is_inside_or_parent_of_any(dir_list, fname):
481
 
    """True if fname is a child or a parent of any of the given files."""
482
 
    for dirname in dir_list:
483
 
        if is_inside(dirname, fname) or is_inside(fname, dirname):
484
 
            return True
485
 
    else:
486
 
        return False
487
 
 
488
 
 
489
151
def pumpfile(fromfile, tofile):
490
152
    """Copy contents of one file to another."""
491
 
    BUFSIZE = 32768
492
 
    while True:
493
 
        b = fromfile.read(BUFSIZE)
494
 
        if not b:
495
 
            break
496
 
        tofile.write(b)
497
 
 
498
 
 
499
 
def file_iterator(input_file, readsize=32768):
500
 
    while True:
501
 
        b = input_file.read(readsize)
502
 
        if len(b) == 0:
503
 
            break
504
 
        yield b
 
153
    tofile.write(fromfile.read())
 
154
 
 
155
 
 
156
def uuid():
 
157
    """Return a new UUID"""
 
158
    try:
 
159
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
160
    except IOError:
 
161
        return chomp(os.popen('uuidgen').readline())
505
162
 
506
163
 
507
164
def sha_file(f):
 
165
    import sha
508
166
    if hasattr(f, 'tell'):
509
167
        assert f.tell() == 0
510
168
    s = sha.new()
517
175
    return s.hexdigest()
518
176
 
519
177
 
520
 
 
521
 
def sha_strings(strings):
522
 
    """Return the sha-1 of concatenation of strings"""
523
 
    s = sha.new()
524
 
    map(s.update, strings)
525
 
    return s.hexdigest()
526
 
 
527
 
 
528
178
def sha_string(f):
 
179
    import sha
529
180
    s = sha.new()
530
181
    s.update(f)
531
182
    return s.hexdigest()
532
183
 
533
184
 
 
185
 
534
186
def fingerprint_file(f):
 
187
    import sha
535
188
    s = sha.new()
536
189
    b = f.read()
537
190
    s.update(b)
540
193
            'sha1': s.hexdigest()}
541
194
 
542
195
 
 
196
def config_dir():
 
197
    """Return per-user configuration directory.
 
198
 
 
199
    By default this is ~/.bzr.conf/
 
200
    
 
201
    TODO: Global option --config-dir to override this.
 
202
    """
 
203
    return os.path.expanduser("~/.bzr.conf")
 
204
 
 
205
 
 
206
def _auto_user_id():
 
207
    """Calculate automatic user identification.
 
208
 
 
209
    Returns (realname, email).
 
210
 
 
211
    Only used when none is set in the environment or the id file.
 
212
 
 
213
    This previously used the FQDN as the default domain, but that can
 
214
    be very slow on machines where DNS is broken.  So now we simply
 
215
    use the hostname.
 
216
    """
 
217
    import socket
 
218
 
 
219
    # XXX: Any good way to get real user name on win32?
 
220
 
 
221
    try:
 
222
        import pwd
 
223
        uid = os.getuid()
 
224
        w = pwd.getpwuid(uid)
 
225
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
226
        username = w.pw_name.decode(bzrlib.user_encoding)
 
227
        comma = gecos.find(',')
 
228
        if comma == -1:
 
229
            realname = gecos
 
230
        else:
 
231
            realname = gecos[:comma]
 
232
        if not realname:
 
233
            realname = username
 
234
 
 
235
    except ImportError:
 
236
        import getpass
 
237
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
238
 
 
239
    return realname, (username + '@' + socket.gethostname())
 
240
 
 
241
 
 
242
def _get_user_id():
 
243
    """Return the full user id from a file or environment variable.
 
244
 
 
245
    TODO: Allow taking this from a file in the branch directory too
 
246
    for per-branch ids."""
 
247
    v = os.environ.get('BZREMAIL')
 
248
    if v:
 
249
        return v.decode(bzrlib.user_encoding)
 
250
    
 
251
    try:
 
252
        return (open(os.path.join(config_dir(), "email"))
 
253
                .read()
 
254
                .decode(bzrlib.user_encoding)
 
255
                .rstrip("\r\n"))
 
256
    except IOError, e:
 
257
        if e.errno != errno.ENOENT:
 
258
            raise e
 
259
 
 
260
    v = os.environ.get('EMAIL')
 
261
    if v:
 
262
        return v.decode(bzrlib.user_encoding)
 
263
    else:    
 
264
        return None
 
265
 
 
266
 
 
267
def username():
 
268
    """Return email-style username.
 
269
 
 
270
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
271
 
 
272
    TODO: Check it's reasonably well-formed.
 
273
    """
 
274
    v = _get_user_id()
 
275
    if v:
 
276
        return v
 
277
    
 
278
    name, email = _auto_user_id()
 
279
    if name:
 
280
        return '%s <%s>' % (name, email)
 
281
    else:
 
282
        return email
 
283
 
 
284
 
 
285
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
 
286
def user_email():
 
287
    """Return just the email component of a username."""
 
288
    e = _get_user_id()
 
289
    if e:
 
290
        m = _EMAIL_RE.search(e)
 
291
        if not m:
 
292
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
293
        return m.group(0)
 
294
 
 
295
    return _auto_user_id()[1]
 
296
    
 
297
 
 
298
 
543
299
def compare_files(a, b):
544
300
    """Returns true if equal in contents"""
545
301
    BUFSIZE = 4096
552
308
            return True
553
309
 
554
310
 
 
311
 
555
312
def local_time_offset(t=None):
556
313
    """Return offset of local zone from GMT, either at present or at time t."""
557
314
    # python2.3 localtime() can't take None
564
321
        return -time.timezone
565
322
 
566
323
    
567
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
568
 
                show_offset=True):
 
324
def format_date(t, offset=0, timezone='original'):
569
325
    ## TODO: Perhaps a global option to use either universal or local time?
570
326
    ## Or perhaps just let people set $TZ?
571
327
    assert isinstance(t, float)
581
337
        tt = time.localtime(t)
582
338
        offset = local_time_offset(t)
583
339
    else:
584
 
        raise BzrError("unsupported timezone format %r" % timezone,
585
 
                       ['options are "utc", "original", "local"'])
586
 
    if date_fmt is None:
587
 
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
588
 
    if show_offset:
589
 
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
590
 
    else:
591
 
        offset_str = ''
592
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
340
        raise BzrError("unsupported timezone format %r",
 
341
                ['options are "utc", "original", "local"'])
 
342
 
 
343
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
344
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
593
345
 
594
346
 
595
347
def compact_date(when):
602
354
    return os.fstat(f.fileno())[ST_SIZE]
603
355
 
604
356
 
605
 
# Define rand_bytes based on platform.
606
 
try:
607
 
    # Python 2.4 and later have os.urandom,
608
 
    # but it doesn't work on some arches
609
 
    os.urandom(1)
 
357
if hasattr(os, 'urandom'): # python 2.4 and later
610
358
    rand_bytes = os.urandom
611
 
except (NotImplementedError, AttributeError):
612
 
    # If python doesn't have os.urandom, or it doesn't work,
613
 
    # then try to first pull random data from /dev/urandom
614
 
    if os.path.exists("/dev/urandom"):
615
 
        rand_bytes = file('/dev/urandom', 'rb').read
616
 
    # Otherwise, use this hack as a last resort
617
 
    else:
618
 
        # not well seeded, but better than nothing
619
 
        def rand_bytes(n):
620
 
            import random
621
 
            s = ''
622
 
            while n:
623
 
                s += chr(random.randint(0, 255))
624
 
                n -= 1
625
 
            return s
626
 
 
627
 
 
628
 
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
629
 
def rand_chars(num):
630
 
    """Return a random string of num alphanumeric characters
631
 
    
632
 
    The result only contains lowercase chars because it may be used on 
633
 
    case-insensitive filesystems.
634
 
    """
635
 
    s = ''
636
 
    for raw_byte in rand_bytes(num):
637
 
        s += ALNUM[ord(raw_byte) % 36]
638
 
    return s
 
359
elif sys.platform == 'linux2':
 
360
    rand_bytes = file('/dev/urandom', 'rb').read
 
361
else:
 
362
    # not well seeded, but better than nothing
 
363
    def rand_bytes(n):
 
364
        import random
 
365
        s = ''
 
366
        while n:
 
367
            s += chr(random.randint(0, 255))
 
368
            n -= 1
 
369
        return s
639
370
 
640
371
 
641
372
## TODO: We could later have path objects that remember their list
678
409
    for f in p:
679
410
        if (f == '..') or (f == None) or (f == ''):
680
411
            raise BzrError("sorry, %r not allowed in path" % f)
681
 
    return pathjoin(*p)
682
 
 
683
 
 
684
 
@deprecated_function(zero_nine)
 
412
    return os.path.join(*p)
 
413
 
 
414
 
685
415
def appendpath(p1, p2):
686
416
    if p1 == '':
687
417
        return p2
688
418
    else:
689
 
        return pathjoin(p1, p2)
 
419
        return os.path.join(p1, p2)
690
420
    
691
421
 
692
 
def split_lines(s):
693
 
    """Split s into lines, but without removing the newline characters."""
694
 
    lines = s.split('\n')
695
 
    result = [line + '\n' for line in lines[:-1]]
696
 
    if lines[-1]:
697
 
        result.append(lines[-1])
698
 
    return result
699
 
 
700
 
 
701
 
def hardlinks_good():
702
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
703
 
 
704
 
 
705
 
def link_or_copy(src, dest):
706
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
707
 
    if not hardlinks_good():
708
 
        copyfile(src, dest)
709
 
        return
710
 
    try:
711
 
        os.link(src, dest)
712
 
    except (OSError, IOError), e:
713
 
        if e.errno != errno.EXDEV:
714
 
            raise
715
 
        copyfile(src, dest)
716
 
 
717
 
def delete_any(full_path):
718
 
    """Delete a file or directory."""
719
 
    try:
720
 
        os.unlink(full_path)
721
 
    except OSError, e:
722
 
    # We may be renaming a dangling inventory id
723
 
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
724
 
            raise
725
 
        os.rmdir(full_path)
726
 
 
727
 
 
728
 
def has_symlinks():
729
 
    if hasattr(os, 'symlink'):
730
 
        return True
731
 
    else:
732
 
        return False
 
422
def extern_command(cmd, ignore_errors = False):
 
423
    mutter('external command: %s' % `cmd`)
 
424
    if os.system(cmd):
 
425
        if not ignore_errors:
 
426
            raise BzrError('command failed')
 
427
 
 
428
 
 
429
def _read_config_value(name):
 
430
    """Read a config value from the file ~/.bzr.conf/<name>
 
431
    Return None if the file does not exist"""
 
432
    try:
 
433
        f = file(os.path.join(config_dir(), name), "r")
 
434
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
435
    except IOError, e:
 
436
        if e.errno == errno.ENOENT:
 
437
            return None
 
438
        raise
 
439
 
 
440
 
 
441
def _get_editor():
 
442
    """Return a sequence of possible editor binaries for the current platform"""
 
443
    e = _read_config_value("editor")
 
444
    if e is not None:
 
445
        yield e
733
446
        
734
 
 
735
 
def contains_whitespace(s):
736
 
    """True if there are any whitespace characters in s."""
737
 
    for ch in string.whitespace:
738
 
        if ch in s:
739
 
            return True
740
 
    else:
741
 
        return False
742
 
 
743
 
 
744
 
def contains_linebreaks(s):
745
 
    """True if there is any vertical whitespace in s."""
746
 
    for ch in '\f\n\r':
747
 
        if ch in s:
748
 
            return True
749
 
    else:
750
 
        return False
751
 
 
752
 
 
753
 
def relpath(base, path):
754
 
    """Return path relative to base, or raise exception.
755
 
 
756
 
    The path may be either an absolute path or a path relative to the
757
 
    current working directory.
758
 
 
759
 
    os.path.commonprefix (python2.4) has a bad bug that it works just
760
 
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
761
 
    avoids that problem.
762
 
    """
763
 
 
764
 
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
765
 
        ' exceed the platform minimum length (which is %d)' % 
766
 
        MIN_ABS_PATHLENGTH)
767
 
 
768
 
    rp = abspath(path)
769
 
 
770
 
    s = []
771
 
    head = rp
772
 
    while len(head) >= len(base):
773
 
        if head == base:
 
447
    if os.name == "windows":
 
448
        yield "notepad.exe"
 
449
    elif os.name == "posix":
 
450
        try:
 
451
            yield os.environ["EDITOR"]
 
452
        except KeyError:
 
453
            yield "/usr/bin/vi"
 
454
 
 
455
 
 
456
def _run_editor(filename):
 
457
    """Try to execute an editor to edit the commit message. Returns True on success,
 
458
    False on failure"""
 
459
    for e in _get_editor():
 
460
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
 
461
        if x == 0:
 
462
            return True
 
463
        elif x == 127:
 
464
            continue
 
465
        else:
774
466
            break
775
 
        head, tail = os.path.split(head)
776
 
        if tail:
777
 
            s.insert(0, tail)
778
 
    else:
779
 
        raise PathNotChild(rp, base)
780
 
 
781
 
    if s:
782
 
        return pathjoin(*s)
783
 
    else:
784
 
        return ''
785
 
 
786
 
 
787
 
def safe_unicode(unicode_or_utf8_string):
788
 
    """Coerce unicode_or_utf8_string into unicode.
789
 
 
790
 
    If it is unicode, it is returned.
791
 
    Otherwise it is decoded from utf-8. If a decoding error
792
 
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
793
 
    as a BzrBadParameter exception.
794
 
    """
795
 
    if isinstance(unicode_or_utf8_string, unicode):
796
 
        return unicode_or_utf8_string
797
 
    try:
798
 
        return unicode_or_utf8_string.decode('utf8')
799
 
    except UnicodeDecodeError:
800
 
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
801
 
 
802
 
 
803
 
_platform_normalizes_filenames = False
804
 
if sys.platform == 'darwin':
805
 
    _platform_normalizes_filenames = True
806
 
 
807
 
 
808
 
def normalizes_filenames():
809
 
    """Return True if this platform normalizes unicode filenames.
810
 
 
811
 
    Mac OSX does, Windows/Linux do not.
812
 
    """
813
 
    return _platform_normalizes_filenames
814
 
 
815
 
 
816
 
def _accessible_normalized_filename(path):
817
 
    """Get the unicode normalized path, and if you can access the file.
818
 
 
819
 
    On platforms where the system normalizes filenames (Mac OSX),
820
 
    you can access a file by any path which will normalize correctly.
821
 
    On platforms where the system does not normalize filenames 
822
 
    (Windows, Linux), you have to access a file by its exact path.
823
 
 
824
 
    Internally, bzr only supports NFC/NFKC normalization, since that is 
825
 
    the standard for XML documents.
826
 
 
827
 
    So return the normalized path, and a flag indicating if the file
828
 
    can be accessed by that path.
829
 
    """
830
 
 
831
 
    return unicodedata.normalize('NFKC', unicode(path)), True
832
 
 
833
 
 
834
 
def _inaccessible_normalized_filename(path):
835
 
    __doc__ = _accessible_normalized_filename.__doc__
836
 
 
837
 
    normalized = unicodedata.normalize('NFKC', unicode(path))
838
 
    return normalized, normalized == path
839
 
 
840
 
 
841
 
if _platform_normalizes_filenames:
842
 
    normalized_filename = _accessible_normalized_filename
843
 
else:
844
 
    normalized_filename = _inaccessible_normalized_filename
845
 
 
846
 
 
847
 
def terminal_width():
848
 
    """Return estimated terminal width."""
849
 
    if sys.platform == 'win32':
850
 
        import bzrlib.win32console
851
 
        return bzrlib.win32console.get_console_size()[0]
852
 
    width = 0
853
 
    try:
854
 
        import struct, fcntl, termios
855
 
        s = struct.pack('HHHH', 0, 0, 0, 0)
856
 
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
857
 
        width = struct.unpack('HHHH', x)[1]
858
 
    except IOError:
859
 
        pass
860
 
    if width <= 0:
861
 
        try:
862
 
            width = int(os.environ['COLUMNS'])
863
 
        except:
864
 
            pass
865
 
    if width <= 0:
866
 
        width = 80
867
 
 
868
 
    return width
869
 
 
870
 
def supports_executable():
871
 
    return sys.platform != "win32"
872
 
 
873
 
 
874
 
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
875
 
 
876
 
 
877
 
def check_legal_path(path):
878
 
    """Check whether the supplied path is legal.  
879
 
    This is only required on Windows, so we don't test on other platforms
880
 
    right now.
881
 
    """
882
 
    if sys.platform != "win32":
883
 
        return
884
 
    if _validWin32PathRE.match(path) is None:
885
 
        raise IllegalPath(path)
886
 
 
887
 
 
888
 
def walkdirs(top, prefix=""):
889
 
    """Yield data about all the directories in a tree.
890
 
    
891
 
    This yields all the data about the contents of a directory at a time.
892
 
    After each directory has been yielded, if the caller has mutated the list
893
 
    to exclude some directories, they are then not descended into.
894
 
    
895
 
    The data yielded is of the form:
896
 
    ((directory-relpath, directory-path-from-top),
897
 
    [(relpath, basename, kind, lstat), ...]),
898
 
     - directory-relpath is the relative path of the directory being returned
899
 
       with respect to top. prefix is prepended to this.
900
 
     - directory-path-from-root is the path including top for this directory. 
901
 
       It is suitable for use with os functions.
902
 
     - relpath is the relative path within the subtree being walked.
903
 
     - basename is the basename of the path
904
 
     - kind is the kind of the file now. If unknown then the file is not
905
 
       present within the tree - but it may be recorded as versioned. See
906
 
       versioned_kind.
907
 
     - lstat is the stat data *if* the file was statted.
908
 
     - planned, not implemented: 
909
 
       path_from_tree_root is the path from the root of the tree.
910
 
 
911
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
912
 
        allows one to walk a subtree but get paths that are relative to a tree
913
 
        rooted higher up.
914
 
    :return: an iterator over the dirs.
915
 
    """
916
 
    #TODO there is a bit of a smell where the results of the directory-
917
 
    # summary in this, and the path from the root, may not agree 
918
 
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
919
 
    # potentially confusing output. We should make this more robust - but
920
 
    # not at a speed cost. RBC 20060731
921
 
    lstat = os.lstat
922
 
    pending = []
923
 
    _directory = _directory_kind
924
 
    _listdir = listdir
925
 
    pending = [(prefix, "", _directory, None, top)]
926
 
    while pending:
927
 
        dirblock = []
928
 
        currentdir = pending.pop()
929
 
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
930
 
        top = currentdir[4]
931
 
        if currentdir[0]:
932
 
            relroot = currentdir[0] + '/'
933
 
        else:
934
 
            relroot = ""
935
 
        for name in sorted(_listdir(top)):
936
 
            abspath = top + '/' + name
937
 
            statvalue = lstat(abspath)
938
 
            dirblock.append((relroot + name, name,
939
 
                file_kind_from_stat_mode(statvalue.st_mode),
940
 
                statvalue, abspath))
941
 
        yield (currentdir[0], top), dirblock
942
 
        # push the user specified dirs from dirblock
943
 
        for dir in reversed(dirblock):
944
 
            if dir[2] == _directory:
945
 
                pending.append(dir)
946
 
 
947
 
 
948
 
def path_prefix_key(path):
949
 
    """Generate a prefix-order path key for path.
950
 
 
951
 
    This can be used to sort paths in the same way that walkdirs does.
952
 
    """
953
 
    return (dirname(path) , path)
954
 
 
955
 
 
956
 
def compare_paths_prefix_order(path_a, path_b):
957
 
    """Compare path_a and path_b to generate the same order walkdirs uses."""
958
 
    key_a = path_prefix_key(path_a)
959
 
    key_b = path_prefix_key(path_b)
960
 
    return cmp(key_a, key_b)
 
467
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
 
468
    return False
 
469
                          
 
470
 
 
471
def get_text_message(infotext, ignoreline = "default"):
 
472
    import tempfile
 
473
    
 
474
    if ignoreline == "default":
 
475
        ignoreline = "-- This line and the following will be ignored --"
 
476
        
 
477
    try:
 
478
        tmp_fileno, msgfilename = tempfile.mkstemp()
 
479
        msgfile = os.close(tmp_fileno)
 
480
        if infotext is not None and infotext != "":
 
481
            hasinfo = True
 
482
            msgfile = file(msgfilename, "w")
 
483
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
 
484
            msgfile.close()
 
485
        else:
 
486
            hasinfo = False
 
487
 
 
488
        if not _run_editor(msgfilename):
 
489
            return None
 
490
        
 
491
        started = False
 
492
        msg = []
 
493
        lastline, nlines = 0, 0
 
494
        for line in file(msgfilename, "r"):
 
495
            stripped_line = line.strip()
 
496
            # strip empty line before the log message starts
 
497
            if not started:
 
498
                if stripped_line != "":
 
499
                    started = True
 
500
                else:
 
501
                    continue
 
502
            # check for the ignore line only if there
 
503
            # is additional information at the end
 
504
            if hasinfo and stripped_line == ignoreline:
 
505
                break
 
506
            nlines += 1
 
507
            # keep track of the last line that had some content
 
508
            if stripped_line != "":
 
509
                lastline = nlines
 
510
            msg.append(line)
 
511
            
 
512
        if len(msg) == 0:
 
513
            return None
 
514
        # delete empty lines at the end
 
515
        del msg[lastline:]
 
516
        # add a newline at the end, if needed
 
517
        if not msg[-1].endswith("\n"):
 
518
            return "%s%s" % ("".join(msg), "\n")
 
519
        else:
 
520
            return "".join(msg)
 
521
    finally:
 
522
        # delete the msg file in any case
 
523
        try: os.unlink(msgfilename)
 
524
        except IOError: pass