← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-09-20 02:40:52 UTC
  • mfrom: (2835.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070920024052-y2l7r5o00zrpnr73
No longer propagate index differences automatically (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Bazaar-NG -- distributed version control
2
 
#
3
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
16
14
# along with this program; if not, write to the Free Software
17
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
 
from shutil import copyfile
 
17
from cStringIO import StringIO
 
18
import os
 
19
import re
 
20
import stat
20
21
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
22
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
22
 
from cStringIO import StringIO
 
23
import sys
 
24
import time
 
25
 
 
26
from bzrlib.lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
import codecs
 
29
from datetime import datetime
23
30
import errno
24
 
import os
25
 
import re
 
31
from ntpath import (abspath as _nt_abspath,
 
32
                    join as _nt_join,
 
33
                    normpath as _nt_normpath,
 
34
                    realpath as _nt_realpath,
 
35
                    splitdrive as _nt_splitdrive,
 
36
                    )
 
37
import posixpath
26
38
import sha
27
39
import shutil
28
 
import string
29
 
import sys
30
 
import time
31
 
import types
 
40
from shutil import (
 
41
    rmtree,
 
42
    )
32
43
import tempfile
 
44
from tempfile import (
 
45
    mkdtemp,
 
46
    )
 
47
import unicodedata
 
48
 
 
49
from bzrlib import (
 
50
    cache_utf8,
 
51
    errors,
 
52
    win32utils,
 
53
    )
 
54
""")
33
55
 
34
56
import bzrlib
35
 
from bzrlib.errors import (BzrError,
36
 
                           BzrBadParameterNotUnicode,
37
 
                           NoSuchFile,
38
 
                           PathNotChild,
39
 
                           IllegalPath,
40
 
                           )
 
57
from bzrlib import symbol_versioning
 
58
from bzrlib.symbol_versioning import (
 
59
    deprecated_function,
 
60
    )
41
61
from bzrlib.trace import mutter
42
 
import bzrlib.win32console
43
 
 
 
62
 
 
63
 
 
64
# On win32, O_BINARY is used to indicate the file should
 
65
# be opened in binary mode, rather than text mode.
 
66
# On other platforms, O_BINARY doesn't exist, because
 
67
# they always open in binary mode, so it is okay to
 
68
# OR with 0 on those platforms
 
69
O_BINARY = getattr(os, 'O_BINARY', 0)
 
70
 
 
71
# On posix, use lstat instead of stat so that we can
 
72
# operate on broken symlinks. On Windows revert to stat.
 
73
lstat = getattr(os, 'lstat', os.stat)
44
74
 
45
75
def make_readonly(filename):
46
76
    """Make a filename read-only."""
47
 
    mod = os.stat(filename).st_mode
48
 
    mod = mod & 0777555
49
 
    os.chmod(filename, mod)
 
77
    mod = lstat(filename).st_mode
 
78
    if not stat.S_ISLNK(mod):
 
79
        mod = mod & 0777555
 
80
        os.chmod(filename, mod)
50
81
 
51
82
 
52
83
def make_writable(filename):
53
 
    mod = os.stat(filename).st_mode
54
 
    mod = mod | 0200
55
 
    os.chmod(filename, mod)
 
84
    mod = lstat(filename).st_mode
 
85
    if not stat.S_ISLNK(mod):
 
86
        mod = mod | 0200
 
87
        os.chmod(filename, mod)
56
88
 
57
89
 
58
90
_QUOTE_RE = None
65
97
    Windows."""
66
98
    # TODO: I'm not really sure this is the best format either.x
67
99
    global _QUOTE_RE
68
 
    if _QUOTE_RE == None:
 
100
    if _QUOTE_RE is None:
69
101
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
70
102
        
71
103
    if _QUOTE_RE.search(f):
74
106
        return f
75
107
 
76
108
 
77
 
def file_kind(f):
78
 
    mode = os.lstat(f)[ST_MODE]
79
 
    if S_ISREG(mode):
80
 
        return 'file'
81
 
    elif S_ISDIR(mode):
82
 
        return 'directory'
83
 
    elif S_ISLNK(mode):
84
 
        return 'symlink'
85
 
    elif S_ISCHR(mode):
86
 
        return 'chardev'
87
 
    elif S_ISBLK(mode):
88
 
        return 'block'
89
 
    elif S_ISFIFO(mode):
90
 
        return 'fifo'
91
 
    elif S_ISSOCK(mode):
92
 
        return 'socket'
93
 
    else:
94
 
        return 'unknown'
 
109
_directory_kind = 'directory'
 
110
 
 
111
_formats = {
 
112
    stat.S_IFDIR:_directory_kind,
 
113
    stat.S_IFCHR:'chardev',
 
114
    stat.S_IFBLK:'block',
 
115
    stat.S_IFREG:'file',
 
116
    stat.S_IFIFO:'fifo',
 
117
    stat.S_IFLNK:'symlink',
 
118
    stat.S_IFSOCK:'socket',
 
119
}
 
120
 
 
121
 
 
122
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
 
123
    """Generate a file kind from a stat mode. This is used in walkdirs.
 
124
 
 
125
    Its performance is critical: Do not mutate without careful benchmarking.
 
126
    """
 
127
    try:
 
128
        return _formats[stat_mode & 0170000]
 
129
    except KeyError:
 
130
        return _unknown
 
131
 
 
132
 
 
133
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
 
134
    try:
 
135
        return _mapper(_lstat(f).st_mode)
 
136
    except OSError, e:
 
137
        if getattr(e, 'errno', None) == errno.ENOENT:
 
138
            raise errors.NoSuchFile(f)
 
139
        raise
 
140
 
 
141
 
 
142
def get_umask():
 
143
    """Return the current umask"""
 
144
    # Assume that people aren't messing with the umask while running
 
145
    # XXX: This is not thread safe, but there is no way to get the
 
146
    #      umask without setting it
 
147
    umask = os.umask(0)
 
148
    os.umask(umask)
 
149
    return umask
 
150
 
 
151
 
 
152
_kind_marker_map = {
 
153
    "file": "",
 
154
    _directory_kind: "/",
 
155
    "symlink": "@",
 
156
    'tree-reference': '+',
 
157
}
95
158
 
96
159
 
97
160
def kind_marker(kind):
98
 
    if kind == 'file':
99
 
        return ''
100
 
    elif kind == 'directory':
101
 
        return '/'
102
 
    elif kind == 'symlink':
103
 
        return '@'
104
 
    else:
105
 
        raise BzrError('invalid file kind %r' % kind)
106
 
 
107
 
def lexists(f):
108
 
    if hasattr(os.path, 'lexists'):
109
 
        return os.path.lexists(f)
110
161
    try:
111
 
        if hasattr(os, 'lstat'):
112
 
            os.lstat(f)
113
 
        else:
114
 
            os.stat(f)
115
 
        return True
116
 
    except OSError,e:
117
 
        if e.errno == errno.ENOENT:
118
 
            return False;
119
 
        else:
120
 
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
162
        return _kind_marker_map[kind]
 
163
    except KeyError:
 
164
        raise errors.BzrError('invalid file kind %r' % kind)
 
165
 
 
166
 
 
167
lexists = getattr(os.path, 'lexists', None)
 
168
if lexists is None:
 
169
    def lexists(f):
 
170
        try:
 
171
            stat = getattr(os, 'lstat', os.stat)
 
172
            stat(f)
 
173
            return True
 
174
        except OSError, e:
 
175
            if e.errno == errno.ENOENT:
 
176
                return False;
 
177
            else:
 
178
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
 
179
 
121
180
 
122
181
def fancy_rename(old, new, rename_func, unlink_func):
123
182
    """A fancy rename, when you don't have atomic rename.
143
202
    file_existed = False
144
203
    try:
145
204
        rename_func(new, tmp_name)
146
 
    except (NoSuchFile,), e:
 
205
    except (errors.NoSuchFile,), e:
147
206
        pass
148
207
    except IOError, e:
149
208
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
150
 
        # function raises an IOError with errno == None when a rename fails.
 
209
        # function raises an IOError with errno is None when a rename fails.
151
210
        # This then gets caught here.
152
211
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
153
212
            raise
154
213
    except Exception, e:
155
 
        if (not hasattr(e, 'errno') 
 
214
        if (getattr(e, 'errno', None) is None
156
215
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
157
216
            raise
158
217
    else:
173
232
            else:
174
233
                rename_func(tmp_name, new)
175
234
 
 
235
 
 
236
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
237
# choke on a Unicode string containing a relative path if
 
238
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
239
# string.
 
240
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
 
241
def _posix_abspath(path):
 
242
    # jam 20060426 rather than encoding to fsencoding
 
243
    # copy posixpath.abspath, but use os.getcwdu instead
 
244
    if not posixpath.isabs(path):
 
245
        path = posixpath.join(getcwd(), path)
 
246
    return posixpath.normpath(path)
 
247
 
 
248
 
 
249
def _posix_realpath(path):
 
250
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
251
 
 
252
 
 
253
def _win32_fixdrive(path):
 
254
    """Force drive letters to be consistent.
 
255
 
 
256
    win32 is inconsistent whether it returns lower or upper case
 
257
    and even if it was consistent the user might type the other
 
258
    so we force it to uppercase
 
259
    running python.exe under cmd.exe return capital C:\\
 
260
    running win32 python inside a cygwin shell returns lowercase c:\\
 
261
    """
 
262
    drive, path = _nt_splitdrive(path)
 
263
    return drive.upper() + path
 
264
 
 
265
 
 
266
def _win32_abspath(path):
 
267
    # Real _nt_abspath doesn't have a problem with a unicode cwd
 
268
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
 
269
 
 
270
 
 
271
def _win98_abspath(path):
 
272
    """Return the absolute version of a path.
 
273
    Windows 98 safe implementation (python reimplementation
 
274
    of Win32 API function GetFullPathNameW)
 
275
    """
 
276
    # Corner cases:
 
277
    #   C:\path     => C:/path
 
278
    #   C:/path     => C:/path
 
279
    #   \\HOST\path => //HOST/path
 
280
    #   //HOST/path => //HOST/path
 
281
    #   path        => C:/cwd/path
 
282
    #   /path       => C:/path
 
283
    path = unicode(path)
 
284
    # check for absolute path
 
285
    drive = _nt_splitdrive(path)[0]
 
286
    if drive == '' and path[:2] not in('//','\\\\'):
 
287
        cwd = os.getcwdu()
 
288
        # we cannot simply os.path.join cwd and path
 
289
        # because os.path.join('C:','/path') produce '/path'
 
290
        # and this is incorrect
 
291
        if path[:1] in ('/','\\'):
 
292
            cwd = _nt_splitdrive(cwd)[0]
 
293
            path = path[1:]
 
294
        path = cwd + '\\' + path
 
295
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
 
296
 
 
297
if win32utils.winver == 'Windows 98':
 
298
    _win32_abspath = _win98_abspath
 
299
 
 
300
 
 
301
def _win32_realpath(path):
 
302
    # Real _nt_realpath doesn't have a problem with a unicode cwd
 
303
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
 
304
 
 
305
 
 
306
def _win32_pathjoin(*args):
 
307
    return _nt_join(*args).replace('\\', '/')
 
308
 
 
309
 
 
310
def _win32_normpath(path):
 
311
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
312
 
 
313
 
 
314
def _win32_getcwd():
 
315
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
 
316
 
 
317
 
 
318
def _win32_mkdtemp(*args, **kwargs):
 
319
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
 
320
 
 
321
 
 
322
def _win32_rename(old, new):
 
323
    """We expect to be able to atomically replace 'new' with old.
 
324
 
 
325
    On win32, if new exists, it must be moved out of the way first,
 
326
    and then deleted. 
 
327
    """
 
328
    try:
 
329
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
330
    except OSError, e:
 
331
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
 
332
            # If we try to rename a non-existant file onto cwd, we get 
 
333
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
 
334
            # if the old path doesn't exist, sometimes we get EACCES
 
335
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
 
336
            os.lstat(old)
 
337
        raise
 
338
 
 
339
 
 
340
def _mac_getcwd():
 
341
    return unicodedata.normalize('NFKC', os.getcwdu())
 
342
 
 
343
 
176
344
# Default is to just use the python builtins, but these can be rebound on
177
345
# particular platforms.
178
 
abspath = os.path.abspath
179
 
realpath = os.path.realpath
 
346
abspath = _posix_abspath
 
347
realpath = _posix_realpath
180
348
pathjoin = os.path.join
181
349
normpath = os.path.normpath
182
350
getcwd = os.getcwdu
183
 
mkdtemp = tempfile.mkdtemp
184
351
rename = os.rename
185
352
dirname = os.path.dirname
186
353
basename = os.path.basename
187
 
rmtree = shutil.rmtree
 
354
split = os.path.split
 
355
splitext = os.path.splitext
 
356
# These were already imported into local scope
 
357
# mkdtemp = tempfile.mkdtemp
 
358
# rmtree = shutil.rmtree
188
359
 
189
360
MIN_ABS_PATHLENGTH = 1
190
361
 
191
 
if os.name == "posix":
192
 
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
193
 
    # choke on a Unicode string containing a relative path if
194
 
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
195
 
    # string.
196
 
    _fs_enc = sys.getfilesystemencoding()
197
 
    def abspath(path):
198
 
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
199
 
 
200
 
    def realpath(path):
201
 
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
202
362
 
203
363
if sys.platform == 'win32':
204
 
    # We need to use the Unicode-aware os.path.abspath and
205
 
    # os.path.realpath on Windows systems.
206
 
    def abspath(path):
207
 
        return os.path.abspath(path).replace('\\', '/')
208
 
 
209
 
    def realpath(path):
210
 
        return os.path.realpath(path).replace('\\', '/')
211
 
 
212
 
    def pathjoin(*args):
213
 
        return os.path.join(*args).replace('\\', '/')
214
 
 
215
 
    def normpath(path):
216
 
        return os.path.normpath(path).replace('\\', '/')
217
 
 
218
 
    def getcwd():
219
 
        return os.getcwdu().replace('\\', '/')
220
 
 
221
 
    def mkdtemp(*args, **kwargs):
222
 
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
223
 
 
224
 
    def rename(old, new):
225
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
364
    abspath = _win32_abspath
 
365
    realpath = _win32_realpath
 
366
    pathjoin = _win32_pathjoin
 
367
    normpath = _win32_normpath
 
368
    getcwd = _win32_getcwd
 
369
    mkdtemp = _win32_mkdtemp
 
370
    rename = _win32_rename
226
371
 
227
372
    MIN_ABS_PATHLENGTH = 3
228
373
 
230
375
        """Error handler for shutil.rmtree function [for win32]
231
376
        Helps to remove files and dirs marked as read-only.
232
377
        """
233
 
        type_, value = excinfo[:2]
 
378
        exception = excinfo[1]
234
379
        if function in (os.remove, os.rmdir) \
235
 
            and type_ == OSError \
236
 
            and value.errno == errno.EACCES:
237
 
            bzrlib.osutils.make_writable(path)
 
380
            and isinstance(exception, OSError) \
 
381
            and exception.errno == errno.EACCES:
 
382
            make_writable(path)
238
383
            function(path)
239
384
        else:
240
385
            raise
242
387
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
243
388
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
244
389
        return shutil.rmtree(path, ignore_errors, onerror)
 
390
elif sys.platform == 'darwin':
 
391
    getcwd = _mac_getcwd
 
392
 
 
393
 
 
394
def get_terminal_encoding():
 
395
    """Find the best encoding for printing to the screen.
 
396
 
 
397
    This attempts to check both sys.stdout and sys.stdin to see
 
398
    what encoding they are in, and if that fails it falls back to
 
399
    bzrlib.user_encoding.
 
400
    The problem is that on Windows, locale.getpreferredencoding()
 
401
    is not the same encoding as that used by the console:
 
402
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
 
403
 
 
404
    On my standard US Windows XP, the preferred encoding is
 
405
    cp1252, but the console is cp437
 
406
    """
 
407
    output_encoding = getattr(sys.stdout, 'encoding', None)
 
408
    if not output_encoding:
 
409
        input_encoding = getattr(sys.stdin, 'encoding', None)
 
410
        if not input_encoding:
 
411
            output_encoding = bzrlib.user_encoding
 
412
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
413
        else:
 
414
            output_encoding = input_encoding
 
415
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
416
    else:
 
417
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
418
    if output_encoding == 'cp0':
 
419
        # invalid encoding (cp0 means 'no codepage' on Windows)
 
420
        output_encoding = bzrlib.user_encoding
 
421
        mutter('cp0 is invalid encoding.'
 
422
               ' encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
423
    # check encoding
 
424
    try:
 
425
        codecs.lookup(output_encoding)
 
426
    except LookupError:
 
427
        sys.stderr.write('bzr: warning:'
 
428
                         ' unknown terminal encoding %s.\n'
 
429
                         '  Using encoding %s instead.\n'
 
430
                         % (output_encoding, bzrlib.user_encoding)
 
431
                        )
 
432
        output_encoding = bzrlib.user_encoding
 
433
 
 
434
    return output_encoding
245
435
 
246
436
 
247
437
def normalizepath(f):
248
 
    if hasattr(os.path, 'realpath'):
 
438
    if getattr(os.path, 'realpath', None) is not None:
249
439
        F = realpath
250
440
    else:
251
441
        F = abspath
315
505
    
316
506
    The empty string as a dir name is taken as top-of-tree and matches 
317
507
    everything.
318
 
    
319
 
    >>> is_inside('src', pathjoin('src', 'foo.c'))
320
 
    True
321
 
    >>> is_inside('src', 'srccontrol')
322
 
    False
323
 
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
324
 
    True
325
 
    >>> is_inside('foo.c', 'foo.c')
326
 
    True
327
 
    >>> is_inside('foo.c', '')
328
 
    False
329
 
    >>> is_inside('', 'foo.c')
330
 
    True
331
508
    """
332
509
    # XXX: Most callers of this can actually do something smarter by 
333
510
    # looking at the inventory
348
525
    for dirname in dir_list:
349
526
        if is_inside(dirname, fname):
350
527
            return True
351
 
    else:
352
 
        return False
 
528
    return False
 
529
 
 
530
 
 
531
def is_inside_or_parent_of_any(dir_list, fname):
 
532
    """True if fname is a child or a parent of any of the given files."""
 
533
    for dirname in dir_list:
 
534
        if is_inside(dirname, fname) or is_inside(fname, dirname):
 
535
            return True
 
536
    return False
353
537
 
354
538
 
355
539
def pumpfile(fromfile, tofile):
371
555
 
372
556
 
373
557
def sha_file(f):
374
 
    if hasattr(f, 'tell'):
 
558
    if getattr(f, 'tell', None) is not None:
375
559
        assert f.tell() == 0
376
560
    s = sha.new()
377
561
    BUFSIZE = 128<<10
383
567
    return s.hexdigest()
384
568
 
385
569
 
386
 
 
387
 
def sha_strings(strings):
 
570
def sha_strings(strings, _factory=sha.new):
388
571
    """Return the sha-1 of concatenation of strings"""
389
 
    s = sha.new()
 
572
    s = _factory()
390
573
    map(s.update, strings)
391
574
    return s.hexdigest()
392
575
 
393
576
 
394
 
def sha_string(f):
395
 
    s = sha.new()
396
 
    s.update(f)
397
 
    return s.hexdigest()
 
577
def sha_string(f, _factory=sha.new):
 
578
    return _factory(f).hexdigest()
398
579
 
399
580
 
400
581
def fingerprint_file(f):
401
 
    s = sha.new()
402
582
    b = f.read()
403
 
    s.update(b)
404
 
    size = len(b)
405
 
    return {'size': size,
406
 
            'sha1': s.hexdigest()}
 
583
    return {'size': len(b),
 
584
            'sha1': sha.new(b).hexdigest()}
407
585
 
408
586
 
409
587
def compare_files(a, b):
420
598
 
421
599
def local_time_offset(t=None):
422
600
    """Return offset of local zone from GMT, either at present or at time t."""
423
 
    # python2.3 localtime() can't take None
424
 
    if t == None:
 
601
    if t is None:
425
602
        t = time.time()
426
 
        
427
 
    if time.localtime(t).tm_isdst and time.daylight:
428
 
        return -time.altzone
429
 
    else:
430
 
        return -time.timezone
 
603
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
 
604
    return offset.days * 86400 + offset.seconds
431
605
 
432
606
    
433
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
607
def format_date(t, offset=0, timezone='original', date_fmt=None,
434
608
                show_offset=True):
435
 
    ## TODO: Perhaps a global option to use either universal or local time?
436
 
    ## Or perhaps just let people set $TZ?
437
 
    assert isinstance(t, float)
438
 
    
 
609
    """Return a formatted date string.
 
610
 
 
611
    :param t: Seconds since the epoch.
 
612
    :param offset: Timezone offset in seconds east of utc.
 
613
    :param timezone: How to display the time: 'utc', 'original' for the
 
614
         timezone specified by offset, or 'local' for the process's current
 
615
         timezone.
 
616
    :param show_offset: Whether to append the timezone.
 
617
    :param date_fmt: strftime format.
 
618
    """
439
619
    if timezone == 'utc':
440
620
        tt = time.gmtime(t)
441
621
        offset = 0
442
622
    elif timezone == 'original':
443
 
        if offset == None:
 
623
        if offset is None:
444
624
            offset = 0
445
625
        tt = time.gmtime(t + offset)
446
626
    elif timezone == 'local':
447
627
        tt = time.localtime(t)
448
628
        offset = local_time_offset(t)
449
629
    else:
450
 
        raise BzrError("unsupported timezone format %r" % timezone,
451
 
                       ['options are "utc", "original", "local"'])
 
630
        raise errors.BzrError("unsupported timezone format %r" % timezone,
 
631
                              ['options are "utc", "original", "local"'])
452
632
    if date_fmt is None:
453
633
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
454
634
    if show_offset:
462
642
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
463
643
    
464
644
 
 
645
def format_delta(delta):
 
646
    """Get a nice looking string for a time delta.
 
647
 
 
648
    :param delta: The time difference in seconds, can be positive or negative.
 
649
        positive indicates time in the past, negative indicates time in the
 
650
        future. (usually time.time() - stored_time)
 
651
    :return: String formatted to show approximate resolution
 
652
    """
 
653
    delta = int(delta)
 
654
    if delta >= 0:
 
655
        direction = 'ago'
 
656
    else:
 
657
        direction = 'in the future'
 
658
        delta = -delta
 
659
 
 
660
    seconds = delta
 
661
    if seconds < 90: # print seconds up to 90 seconds
 
662
        if seconds == 1:
 
663
            return '%d second %s' % (seconds, direction,)
 
664
        else:
 
665
            return '%d seconds %s' % (seconds, direction)
 
666
 
 
667
    minutes = int(seconds / 60)
 
668
    seconds -= 60 * minutes
 
669
    if seconds == 1:
 
670
        plural_seconds = ''
 
671
    else:
 
672
        plural_seconds = 's'
 
673
    if minutes < 90: # print minutes, seconds up to 90 minutes
 
674
        if minutes == 1:
 
675
            return '%d minute, %d second%s %s' % (
 
676
                    minutes, seconds, plural_seconds, direction)
 
677
        else:
 
678
            return '%d minutes, %d second%s %s' % (
 
679
                    minutes, seconds, plural_seconds, direction)
 
680
 
 
681
    hours = int(minutes / 60)
 
682
    minutes -= 60 * hours
 
683
    if minutes == 1:
 
684
        plural_minutes = ''
 
685
    else:
 
686
        plural_minutes = 's'
 
687
 
 
688
    if hours == 1:
 
689
        return '%d hour, %d minute%s %s' % (hours, minutes,
 
690
                                            plural_minutes, direction)
 
691
    return '%d hours, %d minute%s %s' % (hours, minutes,
 
692
                                         plural_minutes, direction)
465
693
 
466
694
def filesize(f):
467
695
    """Return size of given open file."""
477
705
except (NotImplementedError, AttributeError):
478
706
    # If python doesn't have os.urandom, or it doesn't work,
479
707
    # then try to first pull random data from /dev/urandom
480
 
    if os.path.exists("/dev/urandom"):
 
708
    try:
481
709
        rand_bytes = file('/dev/urandom', 'rb').read
482
710
    # Otherwise, use this hack as a last resort
483
 
    else:
 
711
    except (IOError, OSError):
484
712
        # not well seeded, but better than nothing
485
713
        def rand_bytes(n):
486
714
            import random
508
736
## decomposition (might be too tricksy though.)
509
737
 
510
738
def splitpath(p):
511
 
    """Turn string into list of parts.
512
 
 
513
 
    >>> splitpath('a')
514
 
    ['a']
515
 
    >>> splitpath('a/b')
516
 
    ['a', 'b']
517
 
    >>> splitpath('a/./b')
518
 
    ['a', 'b']
519
 
    >>> splitpath('a/.b')
520
 
    ['a', '.b']
521
 
    >>> splitpath('a/../b')
522
 
    Traceback (most recent call last):
523
 
    ...
524
 
    BzrError: sorry, '..' not allowed in path
525
 
    """
526
 
    assert isinstance(p, types.StringTypes)
 
739
    """Turn string into list of parts."""
 
740
    assert isinstance(p, basestring)
527
741
 
528
742
    # split on either delimiter because people might use either on
529
743
    # Windows
532
746
    rps = []
533
747
    for f in ps:
534
748
        if f == '..':
535
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
749
            raise errors.BzrError("sorry, %r not allowed in path" % f)
536
750
        elif (f == '.') or (f == ''):
537
751
            pass
538
752
        else:
540
754
    return rps
541
755
 
542
756
def joinpath(p):
543
 
    assert isinstance(p, list)
 
757
    assert isinstance(p, (list, tuple))
544
758
    for f in p:
545
 
        if (f == '..') or (f == None) or (f == ''):
546
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
759
        if (f == '..') or (f is None) or (f == ''):
 
760
            raise errors.BzrError("sorry, %r not allowed in path" % f)
547
761
    return pathjoin(*p)
548
762
 
549
763
 
550
 
def appendpath(p1, p2):
551
 
    if p1 == '':
552
 
        return p2
553
 
    else:
554
 
        return pathjoin(p1, p2)
555
 
    
556
 
 
557
764
def split_lines(s):
558
765
    """Split s into lines, but without removing the newline characters."""
559
766
    lines = s.split('\n')
570
777
def link_or_copy(src, dest):
571
778
    """Hardlink a file, or copy it if it can't be hardlinked."""
572
779
    if not hardlinks_good():
573
 
        copyfile(src, dest)
 
780
        shutil.copyfile(src, dest)
574
781
        return
575
782
    try:
576
783
        os.link(src, dest)
577
784
    except (OSError, IOError), e:
578
785
        if e.errno != errno.EXDEV:
579
786
            raise
580
 
        copyfile(src, dest)
 
787
        shutil.copyfile(src, dest)
581
788
 
582
789
def delete_any(full_path):
583
790
    """Delete a file or directory."""
591
798
 
592
799
 
593
800
def has_symlinks():
594
 
    if hasattr(os, 'symlink'):
 
801
    if getattr(os, 'symlink', None) is not None:
595
802
        return True
596
803
    else:
597
804
        return False
599
806
 
600
807
def contains_whitespace(s):
601
808
    """True if there are any whitespace characters in s."""
602
 
    for ch in string.whitespace:
 
809
    # string.whitespace can include '\xa0' in certain locales, because it is
 
810
    # considered "non-breaking-space" as part of ISO-8859-1. But it
 
811
    # 1) Isn't a breaking whitespace
 
812
    # 2) Isn't one of ' \t\r\n' which are characters we sometimes use as
 
813
    #    separators
 
814
    # 3) '\xa0' isn't unicode safe since it is >128.
 
815
 
 
816
    # This should *not* be a unicode set of characters in case the source
 
817
    # string is not a Unicode string. We can auto-up-cast the characters since
 
818
    # they are ascii, but we don't want to auto-up-cast the string in case it
 
819
    # is utf-8
 
820
    for ch in ' \t\n\r\v\f':
603
821
        if ch in s:
604
822
            return True
605
823
    else:
629
847
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
630
848
        ' exceed the platform minimum length (which is %d)' % 
631
849
        MIN_ABS_PATHLENGTH)
 
850
 
632
851
    rp = abspath(path)
633
852
 
634
853
    s = []
640
859
        if tail:
641
860
            s.insert(0, tail)
642
861
    else:
643
 
        # XXX This should raise a NotChildPath exception, as its not tied
644
 
        # to branch anymore.
645
 
        raise PathNotChild(rp, base)
 
862
        raise errors.PathNotChild(rp, base)
646
863
 
647
864
    if s:
648
865
        return pathjoin(*s)
663
880
    try:
664
881
        return unicode_or_utf8_string.decode('utf8')
665
882
    except UnicodeDecodeError:
666
 
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
883
        raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
884
 
 
885
 
 
886
def safe_utf8(unicode_or_utf8_string):
 
887
    """Coerce unicode_or_utf8_string to a utf8 string.
 
888
 
 
889
    If it is a str, it is returned.
 
890
    If it is Unicode, it is encoded into a utf-8 string.
 
891
    """
 
892
    if isinstance(unicode_or_utf8_string, str):
 
893
        # TODO: jam 20070209 This is overkill, and probably has an impact on
 
894
        #       performance if we are dealing with lots of apis that want a
 
895
        #       utf-8 revision id
 
896
        try:
 
897
            # Make sure it is a valid utf-8 string
 
898
            unicode_or_utf8_string.decode('utf-8')
 
899
        except UnicodeDecodeError:
 
900
            raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
901
        return unicode_or_utf8_string
 
902
    return unicode_or_utf8_string.encode('utf-8')
 
903
 
 
904
 
 
905
_revision_id_warning = ('Unicode revision ids were deprecated in bzr 0.15.'
 
906
                        ' Revision id generators should be creating utf8'
 
907
                        ' revision ids.')
 
908
 
 
909
 
 
910
def safe_revision_id(unicode_or_utf8_string, warn=True):
 
911
    """Revision ids should now be utf8, but at one point they were unicode.
 
912
 
 
913
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
 
914
        utf8 or None).
 
915
    :param warn: Functions that are sanitizing user data can set warn=False
 
916
    :return: None or a utf8 revision id.
 
917
    """
 
918
    if (unicode_or_utf8_string is None
 
919
        or unicode_or_utf8_string.__class__ == str):
 
920
        return unicode_or_utf8_string
 
921
    if warn:
 
922
        symbol_versioning.warn(_revision_id_warning, DeprecationWarning,
 
923
                               stacklevel=2)
 
924
    return cache_utf8.encode(unicode_or_utf8_string)
 
925
 
 
926
 
 
927
_file_id_warning = ('Unicode file ids were deprecated in bzr 0.15. File id'
 
928
                    ' generators should be creating utf8 file ids.')
 
929
 
 
930
 
 
931
def safe_file_id(unicode_or_utf8_string, warn=True):
 
932
    """File ids should now be utf8, but at one point they were unicode.
 
933
 
 
934
    This is the same as safe_utf8, except it uses the cached encode functions
 
935
    to save a little bit of performance.
 
936
 
 
937
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
 
938
        utf8 or None).
 
939
    :param warn: Functions that are sanitizing user data can set warn=False
 
940
    :return: None or a utf8 file id.
 
941
    """
 
942
    if (unicode_or_utf8_string is None
 
943
        or unicode_or_utf8_string.__class__ == str):
 
944
        return unicode_or_utf8_string
 
945
    if warn:
 
946
        symbol_versioning.warn(_file_id_warning, DeprecationWarning,
 
947
                               stacklevel=2)
 
948
    return cache_utf8.encode(unicode_or_utf8_string)
 
949
 
 
950
 
 
951
_platform_normalizes_filenames = False
 
952
if sys.platform == 'darwin':
 
953
    _platform_normalizes_filenames = True
 
954
 
 
955
 
 
956
def normalizes_filenames():
 
957
    """Return True if this platform normalizes unicode filenames.
 
958
 
 
959
    Mac OSX does, Windows/Linux do not.
 
960
    """
 
961
    return _platform_normalizes_filenames
 
962
 
 
963
 
 
964
def _accessible_normalized_filename(path):
 
965
    """Get the unicode normalized path, and if you can access the file.
 
966
 
 
967
    On platforms where the system normalizes filenames (Mac OSX),
 
968
    you can access a file by any path which will normalize correctly.
 
969
    On platforms where the system does not normalize filenames 
 
970
    (Windows, Linux), you have to access a file by its exact path.
 
971
 
 
972
    Internally, bzr only supports NFC/NFKC normalization, since that is 
 
973
    the standard for XML documents.
 
974
 
 
975
    So return the normalized path, and a flag indicating if the file
 
976
    can be accessed by that path.
 
977
    """
 
978
 
 
979
    return unicodedata.normalize('NFKC', unicode(path)), True
 
980
 
 
981
 
 
982
def _inaccessible_normalized_filename(path):
 
983
    __doc__ = _accessible_normalized_filename.__doc__
 
984
 
 
985
    normalized = unicodedata.normalize('NFKC', unicode(path))
 
986
    return normalized, normalized == path
 
987
 
 
988
 
 
989
if _platform_normalizes_filenames:
 
990
    normalized_filename = _accessible_normalized_filename
 
991
else:
 
992
    normalized_filename = _inaccessible_normalized_filename
667
993
 
668
994
 
669
995
def terminal_width():
670
996
    """Return estimated terminal width."""
671
997
    if sys.platform == 'win32':
672
 
        import bzrlib.win32console
673
 
        return bzrlib.win32console.get_console_size()[0]
 
998
        return win32utils.get_console_size()[0]
674
999
    width = 0
675
1000
    try:
676
1001
        import struct, fcntl, termios
689
1014
 
690
1015
    return width
691
1016
 
 
1017
 
692
1018
def supports_executable():
693
1019
    return sys.platform != "win32"
694
1020
 
695
1021
 
696
 
def strip_trailing_slash(path):
697
 
    """Strip trailing slash, except for root paths.
698
 
    The definition of 'root path' is platform-dependent.
699
 
    """
700
 
    if len(path) != MIN_ABS_PATHLENGTH and path[-1] == '/':
701
 
        return path[:-1]
 
1022
def supports_posix_readonly():
 
1023
    """Return True if 'readonly' has POSIX semantics, False otherwise.
 
1024
 
 
1025
    Notably, a win32 readonly file cannot be deleted, unlike POSIX where the
 
1026
    directory controls creation/deletion, etc.
 
1027
 
 
1028
    And under win32, readonly means that the directory itself cannot be
 
1029
    deleted.  The contents of a readonly directory can be changed, unlike POSIX
 
1030
    where files in readonly directories cannot be added, deleted or renamed.
 
1031
    """
 
1032
    return sys.platform != "win32"
 
1033
 
 
1034
 
 
1035
def set_or_unset_env(env_variable, value):
 
1036
    """Modify the environment, setting or removing the env_variable.
 
1037
 
 
1038
    :param env_variable: The environment variable in question
 
1039
    :param value: The value to set the environment to. If None, then
 
1040
        the variable will be removed.
 
1041
    :return: The original value of the environment variable.
 
1042
    """
 
1043
    orig_val = os.environ.get(env_variable)
 
1044
    if value is None:
 
1045
        if orig_val is not None:
 
1046
            del os.environ[env_variable]
702
1047
    else:
703
 
        return path
 
1048
        if isinstance(value, unicode):
 
1049
            value = value.encode(bzrlib.user_encoding)
 
1050
        os.environ[env_variable] = value
 
1051
    return orig_val
704
1052
 
705
1053
 
706
1054
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
714
1062
    if sys.platform != "win32":
715
1063
        return
716
1064
    if _validWin32PathRE.match(path) is None:
717
 
        raise IllegalPath(path)
 
1065
        raise errors.IllegalPath(path)
 
1066
 
 
1067
 
 
1068
def walkdirs(top, prefix=""):
 
1069
    """Yield data about all the directories in a tree.
 
1070
    
 
1071
    This yields all the data about the contents of a directory at a time.
 
1072
    After each directory has been yielded, if the caller has mutated the list
 
1073
    to exclude some directories, they are then not descended into.
 
1074
    
 
1075
    The data yielded is of the form:
 
1076
    ((directory-relpath, directory-path-from-top),
 
1077
    [(relpath, basename, kind, lstat, path-from-top), ...]),
 
1078
     - directory-relpath is the relative path of the directory being returned
 
1079
       with respect to top. prefix is prepended to this.
 
1080
     - directory-path-from-root is the path including top for this directory. 
 
1081
       It is suitable for use with os functions.
 
1082
     - relpath is the relative path within the subtree being walked.
 
1083
     - basename is the basename of the path
 
1084
     - kind is the kind of the file now. If unknown then the file is not
 
1085
       present within the tree - but it may be recorded as versioned. See
 
1086
       versioned_kind.
 
1087
     - lstat is the stat data *if* the file was statted.
 
1088
     - planned, not implemented: 
 
1089
       path_from_tree_root is the path from the root of the tree.
 
1090
 
 
1091
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
 
1092
        allows one to walk a subtree but get paths that are relative to a tree
 
1093
        rooted higher up.
 
1094
    :return: an iterator over the dirs.
 
1095
    """
 
1096
    #TODO there is a bit of a smell where the results of the directory-
 
1097
    # summary in this, and the path from the root, may not agree 
 
1098
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
 
1099
    # potentially confusing output. We should make this more robust - but
 
1100
    # not at a speed cost. RBC 20060731
 
1101
    _lstat = os.lstat
 
1102
    _directory = _directory_kind
 
1103
    _listdir = os.listdir
 
1104
    _kind_from_mode = _formats.get
 
1105
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
 
1106
    while pending:
 
1107
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
1108
        relroot, _, _, _, top = pending.pop()
 
1109
        if relroot:
 
1110
            relprefix = relroot + u'/'
 
1111
        else:
 
1112
            relprefix = ''
 
1113
        top_slash = top + u'/'
 
1114
 
 
1115
        dirblock = []
 
1116
        append = dirblock.append
 
1117
        for name in sorted(_listdir(top)):
 
1118
            abspath = top_slash + name
 
1119
            statvalue = _lstat(abspath)
 
1120
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1121
            append((relprefix + name, name, kind, statvalue, abspath))
 
1122
        yield (relroot, top), dirblock
 
1123
 
 
1124
        # push the user specified dirs from dirblock
 
1125
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1126
 
 
1127
 
 
1128
def _walkdirs_utf8(top, prefix=""):
 
1129
    """Yield data about all the directories in a tree.
 
1130
 
 
1131
    This yields the same information as walkdirs() only each entry is yielded
 
1132
    in utf-8. On platforms which have a filesystem encoding of utf8 the paths
 
1133
    are returned as exact byte-strings.
 
1134
 
 
1135
    :return: yields a tuple of (dir_info, [file_info])
 
1136
        dir_info is (utf8_relpath, path-from-top)
 
1137
        file_info is (utf8_relpath, utf8_name, kind, lstat, path-from-top)
 
1138
        if top is an absolute path, path-from-top is also an absolute path.
 
1139
        path-from-top might be unicode or utf8, but it is the correct path to
 
1140
        pass to os functions to affect the file in question. (such as os.lstat)
 
1141
    """
 
1142
    fs_encoding = _fs_enc.upper()
 
1143
    if (sys.platform == 'win32' or
 
1144
        fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968')): # ascii
 
1145
        return _walkdirs_unicode_to_utf8(top, prefix=prefix)
 
1146
    else:
 
1147
        return _walkdirs_fs_utf8(top, prefix=prefix)
 
1148
 
 
1149
 
 
1150
def _walkdirs_fs_utf8(top, prefix=""):
 
1151
    """See _walkdirs_utf8.
 
1152
 
 
1153
    This sub-function is called when we know the filesystem is already in utf8
 
1154
    encoding. So we don't need to transcode filenames.
 
1155
    """
 
1156
    _lstat = os.lstat
 
1157
    _directory = _directory_kind
 
1158
    _listdir = os.listdir
 
1159
    _kind_from_mode = _formats.get
 
1160
 
 
1161
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
1162
    # But we don't actually uses 1-3 in pending, so set them to None
 
1163
    pending = [(safe_utf8(prefix), None, None, None, safe_utf8(top))]
 
1164
    while pending:
 
1165
        relroot, _, _, _, top = pending.pop()
 
1166
        if relroot:
 
1167
            relprefix = relroot + '/'
 
1168
        else:
 
1169
            relprefix = ''
 
1170
        top_slash = top + '/'
 
1171
 
 
1172
        dirblock = []
 
1173
        append = dirblock.append
 
1174
        for name in sorted(_listdir(top)):
 
1175
            abspath = top_slash + name
 
1176
            statvalue = _lstat(abspath)
 
1177
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1178
            append((relprefix + name, name, kind, statvalue, abspath))
 
1179
        yield (relroot, top), dirblock
 
1180
 
 
1181
        # push the user specified dirs from dirblock
 
1182
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1183
 
 
1184
 
 
1185
def _walkdirs_unicode_to_utf8(top, prefix=""):
 
1186
    """See _walkdirs_utf8
 
1187
 
 
1188
    Because Win32 has a Unicode api, all of the 'path-from-top' entries will be
 
1189
    Unicode paths.
 
1190
    This is currently the fallback code path when the filesystem encoding is
 
1191
    not UTF-8. It may be better to implement an alternative so that we can
 
1192
    safely handle paths that are not properly decodable in the current
 
1193
    encoding.
 
1194
    """
 
1195
    _utf8_encode = codecs.getencoder('utf8')
 
1196
    _lstat = os.lstat
 
1197
    _directory = _directory_kind
 
1198
    _listdir = os.listdir
 
1199
    _kind_from_mode = _formats.get
 
1200
 
 
1201
    pending = [(safe_utf8(prefix), None, None, None, safe_unicode(top))]
 
1202
    while pending:
 
1203
        relroot, _, _, _, top = pending.pop()
 
1204
        if relroot:
 
1205
            relprefix = relroot + '/'
 
1206
        else:
 
1207
            relprefix = ''
 
1208
        top_slash = top + u'/'
 
1209
 
 
1210
        dirblock = []
 
1211
        append = dirblock.append
 
1212
        for name in sorted(_listdir(top)):
 
1213
            name_utf8 = _utf8_encode(name)[0]
 
1214
            abspath = top_slash + name
 
1215
            statvalue = _lstat(abspath)
 
1216
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1217
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
 
1218
        yield (relroot, top), dirblock
 
1219
 
 
1220
        # push the user specified dirs from dirblock
 
1221
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1222
 
 
1223
 
 
1224
def copy_tree(from_path, to_path, handlers={}):
 
1225
    """Copy all of the entries in from_path into to_path.
 
1226
 
 
1227
    :param from_path: The base directory to copy. 
 
1228
    :param to_path: The target directory. If it does not exist, it will
 
1229
        be created.
 
1230
    :param handlers: A dictionary of functions, which takes a source and
 
1231
        destinations for files, directories, etc.
 
1232
        It is keyed on the file kind, such as 'directory', 'symlink', or 'file'
 
1233
        'file', 'directory', and 'symlink' should always exist.
 
1234
        If they are missing, they will be replaced with 'os.mkdir()',
 
1235
        'os.readlink() + os.symlink()', and 'shutil.copy2()', respectively.
 
1236
    """
 
1237
    # Now, just copy the existing cached tree to the new location
 
1238
    # We use a cheap trick here.
 
1239
    # Absolute paths are prefixed with the first parameter
 
1240
    # relative paths are prefixed with the second.
 
1241
    # So we can get both the source and target returned
 
1242
    # without any extra work.
 
1243
 
 
1244
    def copy_dir(source, dest):
 
1245
        os.mkdir(dest)
 
1246
 
 
1247
    def copy_link(source, dest):
 
1248
        """Copy the contents of a symlink"""
 
1249
        link_to = os.readlink(source)
 
1250
        os.symlink(link_to, dest)
 
1251
 
 
1252
    real_handlers = {'file':shutil.copy2,
 
1253
                     'symlink':copy_link,
 
1254
                     'directory':copy_dir,
 
1255
                    }
 
1256
    real_handlers.update(handlers)
 
1257
 
 
1258
    if not os.path.exists(to_path):
 
1259
        real_handlers['directory'](from_path, to_path)
 
1260
 
 
1261
    for dir_info, entries in walkdirs(from_path, prefix=to_path):
 
1262
        for relpath, name, kind, st, abspath in entries:
 
1263
            real_handlers[kind](abspath, relpath)
 
1264
 
 
1265
 
 
1266
def path_prefix_key(path):
 
1267
    """Generate a prefix-order path key for path.
 
1268
 
 
1269
    This can be used to sort paths in the same way that walkdirs does.
 
1270
    """
 
1271
    return (dirname(path) , path)
 
1272
 
 
1273
 
 
1274
def compare_paths_prefix_order(path_a, path_b):
 
1275
    """Compare path_a and path_b to generate the same order walkdirs uses."""
 
1276
    key_a = path_prefix_key(path_a)
 
1277
    key_b = path_prefix_key(path_b)
 
1278
    return cmp(key_a, key_b)
 
1279
 
 
1280
 
 
1281
_cached_user_encoding = None
 
1282
 
 
1283
 
 
1284
def get_user_encoding(use_cache=True):
 
1285
    """Find out what the preferred user encoding is.
 
1286
 
 
1287
    This is generally the encoding that is used for command line parameters
 
1288
    and file contents. This may be different from the terminal encoding
 
1289
    or the filesystem encoding.
 
1290
 
 
1291
    :param  use_cache:  Enable cache for detected encoding.
 
1292
                        (This parameter is turned on by default,
 
1293
                        and required only for selftesting)
 
1294
 
 
1295
    :return: A string defining the preferred user encoding
 
1296
    """
 
1297
    global _cached_user_encoding
 
1298
    if _cached_user_encoding is not None and use_cache:
 
1299
        return _cached_user_encoding
 
1300
 
 
1301
    if sys.platform == 'darwin':
 
1302
        # work around egregious python 2.4 bug
 
1303
        sys.platform = 'posix'
 
1304
        try:
 
1305
            import locale
 
1306
        finally:
 
1307
            sys.platform = 'darwin'
 
1308
    else:
 
1309
        import locale
 
1310
 
 
1311
    try:
 
1312
        user_encoding = locale.getpreferredencoding()
 
1313
    except locale.Error, e:
 
1314
        sys.stderr.write('bzr: warning: %s\n'
 
1315
                         '  Could not determine what text encoding to use.\n'
 
1316
                         '  This error usually means your Python interpreter\n'
 
1317
                         '  doesn\'t support the locale set by $LANG (%s)\n'
 
1318
                         "  Continuing with ascii encoding.\n"
 
1319
                         % (e, os.environ.get('LANG')))
 
1320
        user_encoding = 'ascii'
 
1321
 
 
1322
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
 
1323
    # treat that as ASCII, and not support printing unicode characters to the
 
1324
    # console.
 
1325
    if user_encoding in (None, 'cp0'):
 
1326
        user_encoding = 'ascii'
 
1327
    else:
 
1328
        # check encoding
 
1329
        try:
 
1330
            codecs.lookup(user_encoding)
 
1331
        except LookupError:
 
1332
            sys.stderr.write('bzr: warning:'
 
1333
                             ' unknown encoding %s.'
 
1334
                             ' Continuing with ascii encoding.\n'
 
1335
                             % user_encoding
 
1336
                            )
 
1337
            user_encoding = 'ascii'
 
1338
 
 
1339
    if use_cache:
 
1340
        _cached_user_encoding = user_encoding
 
1341
 
 
1342
    return user_encoding
 
1343
 
 
1344
 
 
1345
def recv_all(socket, bytes):
 
1346
    """Receive an exact number of bytes.
 
1347
 
 
1348
    Regular Socket.recv() may return less than the requested number of bytes,
 
1349
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
 
1350
    on all platforms, but this should work everywhere.  This will return
 
1351
    less than the requested amount if the remote end closes.
 
1352
 
 
1353
    This isn't optimized and is intended mostly for use in testing.
 
1354
    """
 
1355
    b = ''
 
1356
    while len(b) < bytes:
 
1357
        new = socket.recv(bytes - len(b))
 
1358
        if new == '':
 
1359
            break # eof
 
1360
        b += new
 
1361
    return b
 
1362
 
 
1363
def dereference_path(path):
 
1364
    """Determine the real path to a file.
 
1365
 
 
1366
    All parent elements are dereferenced.  But the file itself is not
 
1367
    dereferenced.
 
1368
    :param path: The original path.  May be absolute or relative.
 
1369
    :return: the real path *to* the file
 
1370
    """
 
1371
    parent, base = os.path.split(path)
 
1372
    # The pathjoin for '.' is a workaround for Python bug #1213894.
 
1373
    # (initial path components aren't dereferenced)
 
1374
    return pathjoin(realpath(pathjoin('.', parent)), base)
 
1375
 
 
1376
 
 
1377
def supports_mapi():
 
1378
    """Return True if we can use MAPI to launch a mail client."""
 
1379
    return sys.platform == "win32"