/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-10-17 05:59:11 UTC
  • mfrom: (2903.2.11 commit)
  • Revision ID: pqm@pqm.ubuntu.com-20071017055911-jots6fwy20740n0i
commit produces (but does not yet use) a basis delta and avoids one iter_entries (mbp)

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