← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Late bind to PatienceSequenceMatcher to allow plugin to override.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Bazaar-NG -- distributed version control
 
2
#
 
3
# Copyright (C) 2005 by Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
14
16
# along with this program; if not, write to the Free Software
15
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
 
19
from shutil import copyfile
 
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
17
22
from cStringIO import StringIO
 
23
import errno
18
24
import os
19
25
import re
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)
 
26
import sha
 
27
import shutil
 
28
import string
23
29
import sys
24
30
import time
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
import types
43
32
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
 
""")
55
 
 
56
33
 
57
34
import bzrlib
58
 
from bzrlib import symbol_versioning
59
 
from bzrlib.symbol_versioning import (
60
 
    deprecated_function,
61
 
    )
 
35
from bzrlib.errors import (BzrError,
 
36
                           BzrBadParameterNotUnicode,
 
37
                           NoSuchFile,
 
38
                           PathNotChild,
 
39
                           IllegalPath,
 
40
                           )
62
41
from bzrlib.trace import mutter
63
 
 
64
 
 
65
 
# On win32, O_BINARY is used to indicate the file should
66
 
# be opened in binary mode, rather than text mode.
67
 
# On other platforms, O_BINARY doesn't exist, because
68
 
# they always open in binary mode, so it is okay to
69
 
# OR with 0 on those platforms
70
 
O_BINARY = getattr(os, 'O_BINARY', 0)
 
42
import bzrlib.win32console
71
43
 
72
44
 
73
45
def make_readonly(filename):
74
46
    """Make a filename read-only."""
75
 
    mod = os.lstat(filename).st_mode
76
 
    if not stat.S_ISLNK(mod):
77
 
        mod = mod & 0777555
78
 
        os.chmod(filename, mod)
 
47
    mod = os.stat(filename).st_mode
 
48
    mod = mod & 0777555
 
49
    os.chmod(filename, mod)
79
50
 
80
51
 
81
52
def make_writable(filename):
82
 
    mod = os.lstat(filename).st_mode
83
 
    if not stat.S_ISLNK(mod):
84
 
        mod = mod | 0200
85
 
        os.chmod(filename, mod)
86
 
 
87
 
 
88
 
def minimum_path_selection(paths):
89
 
    """Return the smallset subset of paths which are outside paths.
90
 
 
91
 
    :param paths: A container (and hence not None) of paths.
92
 
    :return: A set of paths sufficient to include everything in paths via
93
 
        is_inside_any, drawn from the paths parameter.
94
 
    """
95
 
    search_paths = set()
96
 
    paths = set(paths)
97
 
    for path in paths:
98
 
        other_paths = paths.difference([path])
99
 
        if not is_inside_any(other_paths, path):
100
 
            # this is a top level path, we must check it.
101
 
            search_paths.add(path)
102
 
    return search_paths
 
53
    mod = os.stat(filename).st_mode
 
54
    mod = mod | 0200
 
55
    os.chmod(filename, mod)
103
56
 
104
57
 
105
58
_QUOTE_RE = None
112
65
    Windows."""
113
66
    # TODO: I'm not really sure this is the best format either.x
114
67
    global _QUOTE_RE
115
 
    if _QUOTE_RE is None:
 
68
    if _QUOTE_RE == None:
116
69
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
117
70
        
118
71
    if _QUOTE_RE.search(f):
121
74
        return f
122
75
 
123
76
 
124
 
_directory_kind = 'directory'
125
 
 
126
 
_formats = {
127
 
    stat.S_IFDIR:_directory_kind,
128
 
    stat.S_IFCHR:'chardev',
129
 
    stat.S_IFBLK:'block',
130
 
    stat.S_IFREG:'file',
131
 
    stat.S_IFIFO:'fifo',
132
 
    stat.S_IFLNK:'symlink',
133
 
    stat.S_IFSOCK:'socket',
134
 
}
135
 
 
136
 
 
137
 
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
138
 
    """Generate a file kind from a stat mode. This is used in walkdirs.
139
 
 
140
 
    Its performance is critical: Do not mutate without careful benchmarking.
141
 
    """
142
 
    try:
143
 
        return _formats[stat_mode & 0170000]
144
 
    except KeyError:
145
 
        return _unknown
146
 
 
147
 
 
148
 
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
149
 
    try:
150
 
        return _mapper(_lstat(f).st_mode)
151
 
    except OSError, e:
152
 
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
153
 
            raise errors.NoSuchFile(f)
154
 
        raise
155
 
 
156
 
 
157
 
def get_umask():
158
 
    """Return the current umask"""
159
 
    # Assume that people aren't messing with the umask while running
160
 
    # XXX: This is not thread safe, but there is no way to get the
161
 
    #      umask without setting it
162
 
    umask = os.umask(0)
163
 
    os.umask(umask)
164
 
    return umask
165
 
 
166
 
 
167
 
_kind_marker_map = {
168
 
    "file": "",
169
 
    _directory_kind: "/",
170
 
    "symlink": "@",
171
 
    'tree-reference': '+',
172
 
}
 
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'
173
95
 
174
96
 
175
97
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)
176
110
    try:
177
 
        return _kind_marker_map[kind]
178
 
    except KeyError:
179
 
        raise errors.BzrError('invalid file kind %r' % kind)
180
 
 
181
 
 
182
 
lexists = getattr(os.path, 'lexists', None)
183
 
if lexists is None:
184
 
    def lexists(f):
185
 
        try:
186
 
            stat = getattr(os, 'lstat', os.stat)
187
 
            stat(f)
188
 
            return True
189
 
        except OSError, e:
190
 
            if e.errno == errno.ENOENT:
191
 
                return False;
192
 
            else:
193
 
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
194
 
 
 
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))
195
121
 
196
122
def fancy_rename(old, new, rename_func, unlink_func):
197
123
    """A fancy rename, when you don't have atomic rename.
217
143
    file_existed = False
218
144
    try:
219
145
        rename_func(new, tmp_name)
220
 
    except (errors.NoSuchFile,), e:
 
146
    except (NoSuchFile,), e:
221
147
        pass
222
148
    except IOError, e:
223
149
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
224
 
        # function raises an IOError with errno is None when a rename fails.
 
150
        # function raises an IOError with errno == None when a rename fails.
225
151
        # This then gets caught here.
226
152
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
227
153
            raise
228
154
    except Exception, e:
229
 
        if (getattr(e, 'errno', None) is None
 
155
        if (not hasattr(e, 'errno') 
230
156
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
231
157
            raise
232
158
    else:
234
160
 
235
161
    success = False
236
162
    try:
237
 
        try:
238
 
            # This may throw an exception, in which case success will
239
 
            # not be set.
240
 
            rename_func(old, new)
241
 
            success = True
242
 
        except (IOError, OSError), e:
243
 
            # source and target may be aliases of each other (e.g. on a
244
 
            # case-insensitive filesystem), so we may have accidentally renamed
245
 
            # source by when we tried to rename target
246
 
            if not (file_existed and e.errno in (None, errno.ENOENT)):
247
 
                raise
 
163
        # This may throw an exception, in which case success will
 
164
        # not be set.
 
165
        rename_func(old, new)
 
166
        success = True
248
167
    finally:
249
168
        if file_existed:
250
169
            # If the file used to exist, rename it back into place
254
173
            else:
255
174
                rename_func(tmp_name, new)
256
175
 
257
 
 
258
 
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
259
 
# choke on a Unicode string containing a relative path if
260
 
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
261
 
# string.
262
 
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
263
 
def _posix_abspath(path):
264
 
    # jam 20060426 rather than encoding to fsencoding
265
 
    # copy posixpath.abspath, but use os.getcwdu instead
266
 
    if not posixpath.isabs(path):
267
 
        path = posixpath.join(getcwd(), path)
268
 
    return posixpath.normpath(path)
269
 
 
270
 
 
271
 
def _posix_realpath(path):
272
 
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
273
 
 
274
 
 
275
 
def _win32_fixdrive(path):
276
 
    """Force drive letters to be consistent.
277
 
 
278
 
    win32 is inconsistent whether it returns lower or upper case
279
 
    and even if it was consistent the user might type the other
280
 
    so we force it to uppercase
281
 
    running python.exe under cmd.exe return capital C:\\
282
 
    running win32 python inside a cygwin shell returns lowercase c:\\
283
 
    """
284
 
    drive, path = _nt_splitdrive(path)
285
 
    return drive.upper() + path
286
 
 
287
 
 
288
 
def _win32_abspath(path):
289
 
    # Real _nt_abspath doesn't have a problem with a unicode cwd
290
 
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
291
 
 
292
 
 
293
 
def _win98_abspath(path):
294
 
    """Return the absolute version of a path.
295
 
    Windows 98 safe implementation (python reimplementation
296
 
    of Win32 API function GetFullPathNameW)
297
 
    """
298
 
    # Corner cases:
299
 
    #   C:\path     => C:/path
300
 
    #   C:/path     => C:/path
301
 
    #   \\HOST\path => //HOST/path
302
 
    #   //HOST/path => //HOST/path
303
 
    #   path        => C:/cwd/path
304
 
    #   /path       => C:/path
305
 
    path = unicode(path)
306
 
    # check for absolute path
307
 
    drive = _nt_splitdrive(path)[0]
308
 
    if drive == '' and path[:2] not in('//','\\\\'):
309
 
        cwd = os.getcwdu()
310
 
        # we cannot simply os.path.join cwd and path
311
 
        # because os.path.join('C:','/path') produce '/path'
312
 
        # and this is incorrect
313
 
        if path[:1] in ('/','\\'):
314
 
            cwd = _nt_splitdrive(cwd)[0]
315
 
            path = path[1:]
316
 
        path = cwd + '\\' + path
317
 
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
318
 
 
319
 
if win32utils.winver == 'Windows 98':
320
 
    _win32_abspath = _win98_abspath
321
 
 
322
 
 
323
 
def _win32_realpath(path):
324
 
    # Real _nt_realpath doesn't have a problem with a unicode cwd
325
 
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
326
 
 
327
 
 
328
 
def _win32_pathjoin(*args):
329
 
    return _nt_join(*args).replace('\\', '/')
330
 
 
331
 
 
332
 
def _win32_normpath(path):
333
 
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
334
 
 
335
 
 
336
 
def _win32_getcwd():
337
 
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
338
 
 
339
 
 
340
 
def _win32_mkdtemp(*args, **kwargs):
341
 
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
342
 
 
343
 
 
344
 
def _win32_rename(old, new):
345
 
    """We expect to be able to atomically replace 'new' with old.
346
 
 
347
 
    On win32, if new exists, it must be moved out of the way first,
348
 
    and then deleted. 
349
 
    """
350
 
    try:
351
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
352
 
    except OSError, e:
353
 
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
354
 
            # If we try to rename a non-existant file onto cwd, we get 
355
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
356
 
            # if the old path doesn't exist, sometimes we get EACCES
357
 
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
358
 
            os.lstat(old)
359
 
        raise
360
 
 
361
 
 
362
 
def _mac_getcwd():
363
 
    return unicodedata.normalize('NFC', os.getcwdu())
364
 
 
365
 
 
366
176
# Default is to just use the python builtins, but these can be rebound on
367
177
# particular platforms.
368
 
abspath = _posix_abspath
369
 
realpath = _posix_realpath
 
178
abspath = os.path.abspath
 
179
realpath = os.path.realpath
370
180
pathjoin = os.path.join
371
181
normpath = os.path.normpath
372
182
getcwd = os.getcwdu
 
183
mkdtemp = tempfile.mkdtemp
373
184
rename = os.rename
374
185
dirname = os.path.dirname
375
186
basename = os.path.basename
376
 
split = os.path.split
377
 
splitext = os.path.splitext
378
 
# These were already imported into local scope
379
 
# mkdtemp = tempfile.mkdtemp
380
 
# rmtree = shutil.rmtree
 
187
rmtree = shutil.rmtree
381
188
 
382
189
MIN_ABS_PATHLENGTH = 1
383
190
 
 
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)
384
202
 
385
203
if sys.platform == 'win32':
386
 
    abspath = _win32_abspath
387
 
    realpath = _win32_realpath
388
 
    pathjoin = _win32_pathjoin
389
 
    normpath = _win32_normpath
390
 
    getcwd = _win32_getcwd
391
 
    mkdtemp = _win32_mkdtemp
392
 
    rename = _win32_rename
 
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)
393
226
 
394
227
    MIN_ABS_PATHLENGTH = 3
395
228
 
397
230
        """Error handler for shutil.rmtree function [for win32]
398
231
        Helps to remove files and dirs marked as read-only.
399
232
        """
400
 
        exception = excinfo[1]
 
233
        type_, value = excinfo[:2]
401
234
        if function in (os.remove, os.rmdir) \
402
 
            and isinstance(exception, OSError) \
403
 
            and exception.errno == errno.EACCES:
404
 
            make_writable(path)
 
235
            and type_ == OSError \
 
236
            and value.errno == errno.EACCES:
 
237
            bzrlib.osutils.make_writable(path)
405
238
            function(path)
406
239
        else:
407
240
            raise
409
242
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
410
243
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
411
244
        return shutil.rmtree(path, ignore_errors, onerror)
412
 
elif sys.platform == 'darwin':
413
 
    getcwd = _mac_getcwd
414
 
 
415
 
 
416
 
def get_terminal_encoding():
417
 
    """Find the best encoding for printing to the screen.
418
 
 
419
 
    This attempts to check both sys.stdout and sys.stdin to see
420
 
    what encoding they are in, and if that fails it falls back to
421
 
    bzrlib.user_encoding.
422
 
    The problem is that on Windows, locale.getpreferredencoding()
423
 
    is not the same encoding as that used by the console:
424
 
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
425
 
 
426
 
    On my standard US Windows XP, the preferred encoding is
427
 
    cp1252, but the console is cp437
428
 
    """
429
 
    output_encoding = getattr(sys.stdout, 'encoding', None)
430
 
    if not output_encoding:
431
 
        input_encoding = getattr(sys.stdin, 'encoding', None)
432
 
        if not input_encoding:
433
 
            output_encoding = bzrlib.user_encoding
434
 
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
435
 
        else:
436
 
            output_encoding = input_encoding
437
 
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
438
 
    else:
439
 
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
440
 
    if output_encoding == 'cp0':
441
 
        # invalid encoding (cp0 means 'no codepage' on Windows)
442
 
        output_encoding = bzrlib.user_encoding
443
 
        mutter('cp0 is invalid encoding.'
444
 
               ' encoding stdout as bzrlib.user_encoding %r', output_encoding)
445
 
    # check encoding
446
 
    try:
447
 
        codecs.lookup(output_encoding)
448
 
    except LookupError:
449
 
        sys.stderr.write('bzr: warning:'
450
 
                         ' unknown terminal encoding %s.\n'
451
 
                         '  Using encoding %s instead.\n'
452
 
                         % (output_encoding, bzrlib.user_encoding)
453
 
                        )
454
 
        output_encoding = bzrlib.user_encoding
455
 
 
456
 
    return output_encoding
457
245
 
458
246
 
459
247
def normalizepath(f):
460
 
    if getattr(os.path, 'realpath', None) is not None:
 
248
    if hasattr(os.path, 'realpath'):
461
249
        F = realpath
462
250
    else:
463
251
        F = abspath
468
256
        return pathjoin(F(p), e)
469
257
 
470
258
 
 
259
def backup_file(fn):
 
260
    """Copy a file to a backup.
 
261
 
 
262
    Backups are named in GNU-style, with a ~ suffix.
 
263
 
 
264
    If the file is already a backup, it's not copied.
 
265
    """
 
266
    if fn[-1] == '~':
 
267
        return
 
268
    bfn = fn + '~'
 
269
 
 
270
    if has_symlinks() and os.path.islink(fn):
 
271
        target = os.readlink(fn)
 
272
        os.symlink(target, bfn)
 
273
        return
 
274
    inf = file(fn, 'rb')
 
275
    try:
 
276
        content = inf.read()
 
277
    finally:
 
278
        inf.close()
 
279
    
 
280
    outf = file(bfn, 'wb')
 
281
    try:
 
282
        outf.write(content)
 
283
    finally:
 
284
        outf.close()
 
285
 
 
286
 
471
287
def isdir(f):
472
288
    """True if f is an accessible directory."""
473
289
    try:
499
315
    
500
316
    The empty string as a dir name is taken as top-of-tree and matches 
501
317
    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
502
331
    """
503
332
    # XXX: Most callers of this can actually do something smarter by 
504
333
    # looking at the inventory
519
348
    for dirname in dir_list:
520
349
        if is_inside(dirname, fname):
521
350
            return True
522
 
    return False
523
 
 
524
 
 
525
 
def is_inside_or_parent_of_any(dir_list, fname):
526
 
    """True if fname is a child or a parent of any of the given files."""
527
 
    for dirname in dir_list:
528
 
        if is_inside(dirname, fname) or is_inside(fname, dirname):
529
 
            return True
530
 
    return False
531
 
 
532
 
 
533
 
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768):
534
 
    """Copy contents of one file to another.
535
 
 
536
 
    The read_length can either be -1 to read to end-of-file (EOF) or
537
 
    it can specify the maximum number of bytes to read.
538
 
 
539
 
    The buff_size represents the maximum size for each read operation
540
 
    performed on from_file.
541
 
 
542
 
    :return: The number of bytes copied.
543
 
    """
544
 
    length = 0
545
 
    if read_length >= 0:
546
 
        # read specified number of bytes
547
 
 
548
 
        while read_length > 0:
549
 
            num_bytes_to_read = min(read_length, buff_size)
550
 
 
551
 
            block = from_file.read(num_bytes_to_read)
552
 
            if not block:
553
 
                # EOF reached
554
 
                break
555
 
            to_file.write(block)
556
 
 
557
 
            actual_bytes_read = len(block)
558
 
            read_length -= actual_bytes_read
559
 
            length += actual_bytes_read
560
351
    else:
561
 
        # read to EOF
562
 
        while True:
563
 
            block = from_file.read(buff_size)
564
 
            if not block:
565
 
                # EOF reached
566
 
                break
567
 
            to_file.write(block)
568
 
            length += len(block)
569
 
    return length
570
 
 
571
 
 
572
 
def pump_string_file(bytes, file_handle, segment_size=None):
573
 
    """Write bytes to file_handle in many smaller writes.
574
 
 
575
 
    :param bytes: The string to write.
576
 
    :param file_handle: The file to write to.
577
 
    """
578
 
    # Write data in chunks rather than all at once, because very large
579
 
    # writes fail on some platforms (e.g. Windows with SMB  mounted
580
 
    # drives).
581
 
    if not segment_size:
582
 
        segment_size = 5242880 # 5MB
583
 
    segments = range(len(bytes) / segment_size + 1)
584
 
    write = file_handle.write
585
 
    for segment_index in segments:
586
 
        segment = buffer(bytes, segment_index * segment_size, segment_size)
587
 
        write(segment)
 
352
        return False
 
353
 
 
354
 
 
355
def pumpfile(fromfile, tofile):
 
356
    """Copy contents of one file to another."""
 
357
    BUFSIZE = 32768
 
358
    while True:
 
359
        b = fromfile.read(BUFSIZE)
 
360
        if not b:
 
361
            break
 
362
        tofile.write(b)
588
363
 
589
364
 
590
365
def file_iterator(input_file, readsize=32768):
596
371
 
597
372
 
598
373
def sha_file(f):
599
 
    """Calculate the hexdigest of an open file.
600
 
 
601
 
    The file cursor should be already at the start.
602
 
    """
 
374
    if hasattr(f, 'tell'):
 
375
        assert f.tell() == 0
603
376
    s = sha.new()
604
377
    BUFSIZE = 128<<10
605
378
    while True:
610
383
    return s.hexdigest()
611
384
 
612
385
 
613
 
def sha_file_by_name(fname):
614
 
    """Calculate the SHA1 of a file by reading the full text"""
615
 
    s = sha.new()
616
 
    f = os.open(fname, os.O_RDONLY | O_BINARY)
617
 
    try:
618
 
        while True:
619
 
            b = os.read(f, 1<<16)
620
 
            if not b:
621
 
                return s.hexdigest()
622
 
            s.update(b)
623
 
    finally:
624
 
        os.close(f)
625
 
 
626
 
 
627
 
def sha_strings(strings, _factory=sha.new):
 
386
 
 
387
def sha_strings(strings):
628
388
    """Return the sha-1 of concatenation of strings"""
629
 
    s = _factory()
 
389
    s = sha.new()
630
390
    map(s.update, strings)
631
391
    return s.hexdigest()
632
392
 
633
393
 
634
 
def sha_string(f, _factory=sha.new):
635
 
    return _factory(f).hexdigest()
 
394
def sha_string(f):
 
395
    s = sha.new()
 
396
    s.update(f)
 
397
    return s.hexdigest()
636
398
 
637
399
 
638
400
def fingerprint_file(f):
 
401
    s = sha.new()
639
402
    b = f.read()
640
 
    return {'size': len(b),
641
 
            'sha1': sha.new(b).hexdigest()}
 
403
    s.update(b)
 
404
    size = len(b)
 
405
    return {'size': size,
 
406
            'sha1': s.hexdigest()}
642
407
 
643
408
 
644
409
def compare_files(a, b):
655
420
 
656
421
def local_time_offset(t=None):
657
422
    """Return offset of local zone from GMT, either at present or at time t."""
658
 
    if t is None:
 
423
    # python2.3 localtime() can't take None
 
424
    if t == None:
659
425
        t = time.time()
660
 
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
661
 
    return offset.days * 86400 + offset.seconds
 
426
        
 
427
    if time.localtime(t).tm_isdst and time.daylight:
 
428
        return -time.altzone
 
429
    else:
 
430
        return -time.timezone
662
431
 
663
 
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
664
432
    
665
 
def format_date(t, offset=0, timezone='original', date_fmt=None,
 
433
def format_date(t, offset=0, timezone='original', date_fmt=None, 
666
434
                show_offset=True):
667
 
    """Return a formatted date string.
668
 
 
669
 
    :param t: Seconds since the epoch.
670
 
    :param offset: Timezone offset in seconds east of utc.
671
 
    :param timezone: How to display the time: 'utc', 'original' for the
672
 
         timezone specified by offset, or 'local' for the process's current
673
 
         timezone.
674
 
    :param show_offset: Whether to append the timezone.
675
 
    :param date_fmt: strftime format.
676
 
    """
 
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
    
677
439
    if timezone == 'utc':
678
440
        tt = time.gmtime(t)
679
441
        offset = 0
680
442
    elif timezone == 'original':
681
 
        if offset is None:
 
443
        if offset == None:
682
444
            offset = 0
683
445
        tt = time.gmtime(t + offset)
684
446
    elif timezone == 'local':
685
447
        tt = time.localtime(t)
686
448
        offset = local_time_offset(t)
687
449
    else:
688
 
        raise errors.UnsupportedTimezoneFormat(timezone)
 
450
        raise BzrError("unsupported timezone format %r" % timezone,
 
451
                       ['options are "utc", "original", "local"'])
689
452
    if date_fmt is None:
690
453
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
691
454
    if show_offset:
692
455
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
693
456
    else:
694
457
        offset_str = ''
695
 
    # day of week depends on locale, so we do this ourself
696
 
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
697
458
    return (time.strftime(date_fmt, tt) +  offset_str)
698
459
 
699
460
 
701
462
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
702
463
    
703
464
 
704
 
def format_delta(delta):
705
 
    """Get a nice looking string for a time delta.
706
 
 
707
 
    :param delta: The time difference in seconds, can be positive or negative.
708
 
        positive indicates time in the past, negative indicates time in the
709
 
        future. (usually time.time() - stored_time)
710
 
    :return: String formatted to show approximate resolution
711
 
    """
712
 
    delta = int(delta)
713
 
    if delta >= 0:
714
 
        direction = 'ago'
715
 
    else:
716
 
        direction = 'in the future'
717
 
        delta = -delta
718
 
 
719
 
    seconds = delta
720
 
    if seconds < 90: # print seconds up to 90 seconds
721
 
        if seconds == 1:
722
 
            return '%d second %s' % (seconds, direction,)
723
 
        else:
724
 
            return '%d seconds %s' % (seconds, direction)
725
 
 
726
 
    minutes = int(seconds / 60)
727
 
    seconds -= 60 * minutes
728
 
    if seconds == 1:
729
 
        plural_seconds = ''
730
 
    else:
731
 
        plural_seconds = 's'
732
 
    if minutes < 90: # print minutes, seconds up to 90 minutes
733
 
        if minutes == 1:
734
 
            return '%d minute, %d second%s %s' % (
735
 
                    minutes, seconds, plural_seconds, direction)
736
 
        else:
737
 
            return '%d minutes, %d second%s %s' % (
738
 
                    minutes, seconds, plural_seconds, direction)
739
 
 
740
 
    hours = int(minutes / 60)
741
 
    minutes -= 60 * hours
742
 
    if minutes == 1:
743
 
        plural_minutes = ''
744
 
    else:
745
 
        plural_minutes = 's'
746
 
 
747
 
    if hours == 1:
748
 
        return '%d hour, %d minute%s %s' % (hours, minutes,
749
 
                                            plural_minutes, direction)
750
 
    return '%d hours, %d minute%s %s' % (hours, minutes,
751
 
                                         plural_minutes, direction)
752
465
 
753
466
def filesize(f):
754
467
    """Return size of given open file."""
764
477
except (NotImplementedError, AttributeError):
765
478
    # If python doesn't have os.urandom, or it doesn't work,
766
479
    # then try to first pull random data from /dev/urandom
767
 
    try:
 
480
    if os.path.exists("/dev/urandom"):
768
481
        rand_bytes = file('/dev/urandom', 'rb').read
769
482
    # Otherwise, use this hack as a last resort
770
 
    except (IOError, OSError):
 
483
    else:
771
484
        # not well seeded, but better than nothing
772
485
        def rand_bytes(n):
773
486
            import random
795
508
## decomposition (might be too tricksy though.)
796
509
 
797
510
def splitpath(p):
798
 
    """Turn string into list of parts."""
 
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)
 
527
 
799
528
    # split on either delimiter because people might use either on
800
529
    # Windows
801
530
    ps = re.split(r'[\\/]', p)
803
532
    rps = []
804
533
    for f in ps:
805
534
        if f == '..':
806
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
535
            raise BzrError("sorry, %r not allowed in path" % f)
807
536
        elif (f == '.') or (f == ''):
808
537
            pass
809
538
        else:
811
540
    return rps
812
541
 
813
542
def joinpath(p):
 
543
    assert isinstance(p, list)
814
544
    for f in p:
815
 
        if (f == '..') or (f is None) or (f == ''):
816
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
545
        if (f == '..') or (f == None) or (f == ''):
 
546
            raise BzrError("sorry, %r not allowed in path" % f)
817
547
    return pathjoin(*p)
818
548
 
819
549
 
 
550
def appendpath(p1, p2):
 
551
    if p1 == '':
 
552
        return p2
 
553
    else:
 
554
        return pathjoin(p1, p2)
 
555
    
 
556
 
820
557
def split_lines(s):
821
558
    """Split s into lines, but without removing the newline characters."""
822
559
    lines = s.split('\n')
833
570
def link_or_copy(src, dest):
834
571
    """Hardlink a file, or copy it if it can't be hardlinked."""
835
572
    if not hardlinks_good():
836
 
        shutil.copyfile(src, dest)
 
573
        copyfile(src, dest)
837
574
        return
838
575
    try:
839
576
        os.link(src, dest)
840
577
    except (OSError, IOError), e:
841
578
        if e.errno != errno.EXDEV:
842
579
            raise
843
 
        shutil.copyfile(src, dest)
844
 
 
845
 
 
846
 
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
847
 
# Forgiveness than Permission (EAFP) because:
848
 
# - root can damage a solaris file system by using unlink,
849
 
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
850
 
#   EACCES, OSX: EPERM) when invoked on a directory.
851
 
def delete_any(path):
 
580
        copyfile(src, dest)
 
581
 
 
582
def delete_any(full_path):
852
583
    """Delete a file or directory."""
853
 
    if isdir(path): # Takes care of symlinks
854
 
        os.rmdir(path)
855
 
    else:
856
 
        os.unlink(path)
 
584
    try:
 
585
        os.unlink(full_path)
 
586
    except OSError, e:
 
587
    # We may be renaming a dangling inventory id
 
588
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
589
            raise
 
590
        os.rmdir(full_path)
857
591
 
858
592
 
859
593
def has_symlinks():
860
 
    if getattr(os, 'symlink', None) is not None:
861
 
        return True
862
 
    else:
863
 
        return False
864
 
 
865
 
 
866
 
def has_hardlinks():
867
 
    if getattr(os, 'link', None) is not None:
868
 
        return True
869
 
    else:
870
 
        return False
871
 
 
872
 
 
873
 
def host_os_dereferences_symlinks():
874
 
    return (has_symlinks()
875
 
            and sys.platform not in ('cygwin', 'win32'))
876
 
 
 
594
    if hasattr(os, 'symlink'):
 
595
        return True
 
596
    else:
 
597
        return False
 
598
        
877
599
 
878
600
def contains_whitespace(s):
879
601
    """True if there are any whitespace characters in s."""
880
 
    # string.whitespace can include '\xa0' in certain locales, because it is
881
 
    # considered "non-breaking-space" as part of ISO-8859-1. But it
882
 
    # 1) Isn't a breaking whitespace
883
 
    # 2) Isn't one of ' \t\r\n' which are characters we sometimes use as
884
 
    #    separators
885
 
    # 3) '\xa0' isn't unicode safe since it is >128.
886
 
 
887
 
    # This should *not* be a unicode set of characters in case the source
888
 
    # string is not a Unicode string. We can auto-up-cast the characters since
889
 
    # they are ascii, but we don't want to auto-up-cast the string in case it
890
 
    # is utf-8
891
 
    for ch in ' \t\n\r\v\f':
 
602
    for ch in string.whitespace:
892
603
        if ch in s:
893
604
            return True
894
605
    else:
915
626
    avoids that problem.
916
627
    """
917
628
 
918
 
    if len(base) < MIN_ABS_PATHLENGTH:
919
 
        # must have space for e.g. a drive letter
920
 
        raise ValueError('%r is too short to calculate a relative path'
921
 
            % (base,))
922
 
 
 
629
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
 
630
        ' exceed the platform minimum length (which is %d)' % 
 
631
        MIN_ABS_PATHLENGTH)
923
632
    rp = abspath(path)
924
633
 
925
634
    s = []
931
640
        if tail:
932
641
            s.insert(0, tail)
933
642
    else:
934
 
        raise errors.PathNotChild(rp, base)
 
643
        # XXX This should raise a NotChildPath exception, as its not tied
 
644
        # to branch anymore.
 
645
        raise PathNotChild(rp, base)
935
646
 
936
647
    if s:
937
648
        return pathjoin(*s)
952
663
    try:
953
664
        return unicode_or_utf8_string.decode('utf8')
954
665
    except UnicodeDecodeError:
955
 
        raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
956
 
 
957
 
 
958
 
def safe_utf8(unicode_or_utf8_string):
959
 
    """Coerce unicode_or_utf8_string to a utf8 string.
960
 
 
961
 
    If it is a str, it is returned.
962
 
    If it is Unicode, it is encoded into a utf-8 string.
963
 
    """
964
 
    if isinstance(unicode_or_utf8_string, str):
965
 
        # TODO: jam 20070209 This is overkill, and probably has an impact on
966
 
        #       performance if we are dealing with lots of apis that want a
967
 
        #       utf-8 revision id
968
 
        try:
969
 
            # Make sure it is a valid utf-8 string
970
 
            unicode_or_utf8_string.decode('utf-8')
971
 
        except UnicodeDecodeError:
972
 
            raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
973
 
        return unicode_or_utf8_string
974
 
    return unicode_or_utf8_string.encode('utf-8')
975
 
 
976
 
 
977
 
_revision_id_warning = ('Unicode revision ids were deprecated in bzr 0.15.'
978
 
                        ' Revision id generators should be creating utf8'
979
 
                        ' revision ids.')
980
 
 
981
 
 
982
 
def safe_revision_id(unicode_or_utf8_string, warn=True):
983
 
    """Revision ids should now be utf8, but at one point they were unicode.
984
 
 
985
 
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
986
 
        utf8 or None).
987
 
    :param warn: Functions that are sanitizing user data can set warn=False
988
 
    :return: None or a utf8 revision id.
989
 
    """
990
 
    if (unicode_or_utf8_string is None
991
 
        or unicode_or_utf8_string.__class__ == str):
992
 
        return unicode_or_utf8_string
993
 
    if warn:
994
 
        symbol_versioning.warn(_revision_id_warning, DeprecationWarning,
995
 
                               stacklevel=2)
996
 
    return cache_utf8.encode(unicode_or_utf8_string)
997
 
 
998
 
 
999
 
_file_id_warning = ('Unicode file ids were deprecated in bzr 0.15. File id'
1000
 
                    ' generators should be creating utf8 file ids.')
1001
 
 
1002
 
 
1003
 
def safe_file_id(unicode_or_utf8_string, warn=True):
1004
 
    """File ids should now be utf8, but at one point they were unicode.
1005
 
 
1006
 
    This is the same as safe_utf8, except it uses the cached encode functions
1007
 
    to save a little bit of performance.
1008
 
 
1009
 
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
1010
 
        utf8 or None).
1011
 
    :param warn: Functions that are sanitizing user data can set warn=False
1012
 
    :return: None or a utf8 file id.
1013
 
    """
1014
 
    if (unicode_or_utf8_string is None
1015
 
        or unicode_or_utf8_string.__class__ == str):
1016
 
        return unicode_or_utf8_string
1017
 
    if warn:
1018
 
        symbol_versioning.warn(_file_id_warning, DeprecationWarning,
1019
 
                               stacklevel=2)
1020
 
    return cache_utf8.encode(unicode_or_utf8_string)
1021
 
 
1022
 
 
1023
 
_platform_normalizes_filenames = False
1024
 
if sys.platform == 'darwin':
1025
 
    _platform_normalizes_filenames = True
1026
 
 
1027
 
 
1028
 
def normalizes_filenames():
1029
 
    """Return True if this platform normalizes unicode filenames.
1030
 
 
1031
 
    Mac OSX does, Windows/Linux do not.
1032
 
    """
1033
 
    return _platform_normalizes_filenames
1034
 
 
1035
 
 
1036
 
def _accessible_normalized_filename(path):
1037
 
    """Get the unicode normalized path, and if you can access the file.
1038
 
 
1039
 
    On platforms where the system normalizes filenames (Mac OSX),
1040
 
    you can access a file by any path which will normalize correctly.
1041
 
    On platforms where the system does not normalize filenames 
1042
 
    (Windows, Linux), you have to access a file by its exact path.
1043
 
 
1044
 
    Internally, bzr only supports NFC normalization, since that is 
1045
 
    the standard for XML documents.
1046
 
 
1047
 
    So return the normalized path, and a flag indicating if the file
1048
 
    can be accessed by that path.
1049
 
    """
1050
 
 
1051
 
    return unicodedata.normalize('NFC', unicode(path)), True
1052
 
 
1053
 
 
1054
 
def _inaccessible_normalized_filename(path):
1055
 
    __doc__ = _accessible_normalized_filename.__doc__
1056
 
 
1057
 
    normalized = unicodedata.normalize('NFC', unicode(path))
1058
 
    return normalized, normalized == path
1059
 
 
1060
 
 
1061
 
if _platform_normalizes_filenames:
1062
 
    normalized_filename = _accessible_normalized_filename
1063
 
else:
1064
 
    normalized_filename = _inaccessible_normalized_filename
 
666
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
1065
667
 
1066
668
 
1067
669
def terminal_width():
1068
670
    """Return estimated terminal width."""
1069
671
    if sys.platform == 'win32':
1070
 
        return win32utils.get_console_size()[0]
 
672
        import bzrlib.win32console
 
673
        return bzrlib.win32console.get_console_size()[0]
1071
674
    width = 0
1072
675
    try:
1073
676
        import struct, fcntl, termios
1086
689
 
1087
690
    return width
1088
691
 
1089
 
 
1090
692
def supports_executable():
1091
693
    return sys.platform != "win32"
1092
694
 
1093
695
 
1094
 
def supports_posix_readonly():
1095
 
    """Return True if 'readonly' has POSIX semantics, False otherwise.
1096
 
 
1097
 
    Notably, a win32 readonly file cannot be deleted, unlike POSIX where the
1098
 
    directory controls creation/deletion, etc.
1099
 
 
1100
 
    And under win32, readonly means that the directory itself cannot be
1101
 
    deleted.  The contents of a readonly directory can be changed, unlike POSIX
1102
 
    where files in readonly directories cannot be added, deleted or renamed.
1103
 
    """
1104
 
    return sys.platform != "win32"
1105
 
 
1106
 
 
1107
 
def set_or_unset_env(env_variable, value):
1108
 
    """Modify the environment, setting or removing the env_variable.
1109
 
 
1110
 
    :param env_variable: The environment variable in question
1111
 
    :param value: The value to set the environment to. If None, then
1112
 
        the variable will be removed.
1113
 
    :return: The original value of the environment variable.
1114
 
    """
1115
 
    orig_val = os.environ.get(env_variable)
1116
 
    if value is None:
1117
 
        if orig_val is not None:
1118
 
            del os.environ[env_variable]
 
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]
1119
702
    else:
1120
 
        if isinstance(value, unicode):
1121
 
            value = value.encode(bzrlib.user_encoding)
1122
 
        os.environ[env_variable] = value
1123
 
    return orig_val
 
703
        return path
1124
704
 
1125
705
 
1126
706
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
1134
714
    if sys.platform != "win32":
1135
715
        return
1136
716
    if _validWin32PathRE.match(path) is None:
1137
 
        raise errors.IllegalPath(path)
1138
 
 
1139
 
 
1140
 
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
1141
 
 
1142
 
def _is_error_enotdir(e):
1143
 
    """Check if this exception represents ENOTDIR.
1144
 
 
1145
 
    Unfortunately, python is very inconsistent about the exception
1146
 
    here. The cases are:
1147
 
      1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
1148
 
      2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
1149
 
         which is the windows error code.
1150
 
      3) Windows, Python2.5 uses errno == EINVAL and
1151
 
         winerror == ERROR_DIRECTORY
1152
 
 
1153
 
    :param e: An Exception object (expected to be OSError with an errno
1154
 
        attribute, but we should be able to cope with anything)
1155
 
    :return: True if this represents an ENOTDIR error. False otherwise.
1156
 
    """
1157
 
    en = getattr(e, 'errno', None)
1158
 
    if (en == errno.ENOTDIR
1159
 
        or (sys.platform == 'win32'
1160
 
            and (en == _WIN32_ERROR_DIRECTORY
1161
 
                 or (en == errno.EINVAL
1162
 
                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
1163
 
        ))):
1164
 
        return True
1165
 
    return False
1166
 
 
1167
 
 
1168
 
def walkdirs(top, prefix=""):
1169
 
    """Yield data about all the directories in a tree.
1170
 
    
1171
 
    This yields all the data about the contents of a directory at a time.
1172
 
    After each directory has been yielded, if the caller has mutated the list
1173
 
    to exclude some directories, they are then not descended into.
1174
 
    
1175
 
    The data yielded is of the form:
1176
 
    ((directory-relpath, directory-path-from-top),
1177
 
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1178
 
     - directory-relpath is the relative path of the directory being returned
1179
 
       with respect to top. prefix is prepended to this.
1180
 
     - directory-path-from-root is the path including top for this directory. 
1181
 
       It is suitable for use with os functions.
1182
 
     - relpath is the relative path within the subtree being walked.
1183
 
     - basename is the basename of the path
1184
 
     - kind is the kind of the file now. If unknown then the file is not
1185
 
       present within the tree - but it may be recorded as versioned. See
1186
 
       versioned_kind.
1187
 
     - lstat is the stat data *if* the file was statted.
1188
 
     - planned, not implemented: 
1189
 
       path_from_tree_root is the path from the root of the tree.
1190
 
 
1191
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
1192
 
        allows one to walk a subtree but get paths that are relative to a tree
1193
 
        rooted higher up.
1194
 
    :return: an iterator over the dirs.
1195
 
    """
1196
 
    #TODO there is a bit of a smell where the results of the directory-
1197
 
    # summary in this, and the path from the root, may not agree 
1198
 
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1199
 
    # potentially confusing output. We should make this more robust - but
1200
 
    # not at a speed cost. RBC 20060731
1201
 
    _lstat = os.lstat
1202
 
    _directory = _directory_kind
1203
 
    _listdir = os.listdir
1204
 
    _kind_from_mode = _formats.get
1205
 
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1206
 
    while pending:
1207
 
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1208
 
        relroot, _, _, _, top = pending.pop()
1209
 
        if relroot:
1210
 
            relprefix = relroot + u'/'
1211
 
        else:
1212
 
            relprefix = ''
1213
 
        top_slash = top + u'/'
1214
 
 
1215
 
        dirblock = []
1216
 
        append = dirblock.append
1217
 
        try:
1218
 
            names = sorted(_listdir(top))
1219
 
        except OSError, e:
1220
 
            if not _is_error_enotdir(e):
1221
 
                raise
1222
 
        else:
1223
 
            for name in names:
1224
 
                abspath = top_slash + name
1225
 
                statvalue = _lstat(abspath)
1226
 
                kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1227
 
                append((relprefix + name, name, kind, statvalue, abspath))
1228
 
        yield (relroot, top), dirblock
1229
 
 
1230
 
        # push the user specified dirs from dirblock
1231
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1232
 
 
1233
 
 
1234
 
_real_walkdirs_utf8 = None
1235
 
 
1236
 
def _walkdirs_utf8(top, prefix=""):
1237
 
    """Yield data about all the directories in a tree.
1238
 
 
1239
 
    This yields the same information as walkdirs() only each entry is yielded
1240
 
    in utf-8. On platforms which have a filesystem encoding of utf8 the paths
1241
 
    are returned as exact byte-strings.
1242
 
 
1243
 
    :return: yields a tuple of (dir_info, [file_info])
1244
 
        dir_info is (utf8_relpath, path-from-top)
1245
 
        file_info is (utf8_relpath, utf8_name, kind, lstat, path-from-top)
1246
 
        if top is an absolute path, path-from-top is also an absolute path.
1247
 
        path-from-top might be unicode or utf8, but it is the correct path to
1248
 
        pass to os functions to affect the file in question. (such as os.lstat)
1249
 
    """
1250
 
    global _real_walkdirs_utf8
1251
 
    if _real_walkdirs_utf8 is None:
1252
 
        fs_encoding = _fs_enc.upper()
1253
 
        if win32utils.winver == 'Windows NT':
1254
 
            # Win98 doesn't have unicode apis like FindFirstFileW
1255
 
            # TODO: We possibly could support Win98 by falling back to the
1256
 
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
1257
 
            #       but that gets a bit tricky, and requires custom compiling
1258
 
            #       for win98 anyway.
1259
 
            try:
1260
 
                from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1261
 
            except ImportError:
1262
 
                _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
1263
 
            else:
1264
 
                _real_walkdirs_utf8 = _walkdirs_utf8_win32_find_file
1265
 
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1266
 
            # ANSI_X3.4-1968 is a form of ASCII
1267
 
            _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
1268
 
        else:
1269
 
            _real_walkdirs_utf8 = _walkdirs_fs_utf8
1270
 
    return _real_walkdirs_utf8(top, prefix=prefix)
1271
 
 
1272
 
 
1273
 
def _walkdirs_fs_utf8(top, prefix=""):
1274
 
    """See _walkdirs_utf8.
1275
 
 
1276
 
    This sub-function is called when we know the filesystem is already in utf8
1277
 
    encoding. So we don't need to transcode filenames.
1278
 
    """
1279
 
    _lstat = os.lstat
1280
 
    _directory = _directory_kind
1281
 
    # Use C accelerated directory listing.
1282
 
    _listdir = _read_dir
1283
 
    _kind_from_mode = _formats.get
1284
 
 
1285
 
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1286
 
    # But we don't actually uses 1-3 in pending, so set them to None
1287
 
    pending = [(safe_utf8(prefix), None, None, None, safe_utf8(top))]
1288
 
    while pending:
1289
 
        relroot, _, _, _, top = pending.pop()
1290
 
        if relroot:
1291
 
            relprefix = relroot + '/'
1292
 
        else:
1293
 
            relprefix = ''
1294
 
        top_slash = top + '/'
1295
 
 
1296
 
        dirblock = []
1297
 
        append = dirblock.append
1298
 
        # read_dir supplies in should-stat order.
1299
 
        for _, name in sorted(_listdir(top)):
1300
 
            abspath = top_slash + name
1301
 
            statvalue = _lstat(abspath)
1302
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1303
 
            append((relprefix + name, name, kind, statvalue, abspath))
1304
 
        dirblock.sort()
1305
 
        yield (relroot, top), dirblock
1306
 
 
1307
 
        # push the user specified dirs from dirblock
1308
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1309
 
 
1310
 
 
1311
 
def _walkdirs_unicode_to_utf8(top, prefix=""):
1312
 
    """See _walkdirs_utf8
1313
 
 
1314
 
    Because Win32 has a Unicode api, all of the 'path-from-top' entries will be
1315
 
    Unicode paths.
1316
 
    This is currently the fallback code path when the filesystem encoding is
1317
 
    not UTF-8. It may be better to implement an alternative so that we can
1318
 
    safely handle paths that are not properly decodable in the current
1319
 
    encoding.
1320
 
    """
1321
 
    _utf8_encode = codecs.getencoder('utf8')
1322
 
    _lstat = os.lstat
1323
 
    _directory = _directory_kind
1324
 
    _listdir = os.listdir
1325
 
    _kind_from_mode = _formats.get
1326
 
 
1327
 
    pending = [(safe_utf8(prefix), None, None, None, safe_unicode(top))]
1328
 
    while pending:
1329
 
        relroot, _, _, _, top = pending.pop()
1330
 
        if relroot:
1331
 
            relprefix = relroot + '/'
1332
 
        else:
1333
 
            relprefix = ''
1334
 
        top_slash = top + u'/'
1335
 
 
1336
 
        dirblock = []
1337
 
        append = dirblock.append
1338
 
        for name in sorted(_listdir(top)):
1339
 
            name_utf8 = _utf8_encode(name)[0]
1340
 
            abspath = top_slash + name
1341
 
            statvalue = _lstat(abspath)
1342
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1343
 
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1344
 
        yield (relroot, top), dirblock
1345
 
 
1346
 
        # push the user specified dirs from dirblock
1347
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1348
 
 
1349
 
 
1350
 
def copy_tree(from_path, to_path, handlers={}):
1351
 
    """Copy all of the entries in from_path into to_path.
1352
 
 
1353
 
    :param from_path: The base directory to copy. 
1354
 
    :param to_path: The target directory. If it does not exist, it will
1355
 
        be created.
1356
 
    :param handlers: A dictionary of functions, which takes a source and
1357
 
        destinations for files, directories, etc.
1358
 
        It is keyed on the file kind, such as 'directory', 'symlink', or 'file'
1359
 
        'file', 'directory', and 'symlink' should always exist.
1360
 
        If they are missing, they will be replaced with 'os.mkdir()',
1361
 
        'os.readlink() + os.symlink()', and 'shutil.copy2()', respectively.
1362
 
    """
1363
 
    # Now, just copy the existing cached tree to the new location
1364
 
    # We use a cheap trick here.
1365
 
    # Absolute paths are prefixed with the first parameter
1366
 
    # relative paths are prefixed with the second.
1367
 
    # So we can get both the source and target returned
1368
 
    # without any extra work.
1369
 
 
1370
 
    def copy_dir(source, dest):
1371
 
        os.mkdir(dest)
1372
 
 
1373
 
    def copy_link(source, dest):
1374
 
        """Copy the contents of a symlink"""
1375
 
        link_to = os.readlink(source)
1376
 
        os.symlink(link_to, dest)
1377
 
 
1378
 
    real_handlers = {'file':shutil.copy2,
1379
 
                     'symlink':copy_link,
1380
 
                     'directory':copy_dir,
1381
 
                    }
1382
 
    real_handlers.update(handlers)
1383
 
 
1384
 
    if not os.path.exists(to_path):
1385
 
        real_handlers['directory'](from_path, to_path)
1386
 
 
1387
 
    for dir_info, entries in walkdirs(from_path, prefix=to_path):
1388
 
        for relpath, name, kind, st, abspath in entries:
1389
 
            real_handlers[kind](abspath, relpath)
1390
 
 
1391
 
 
1392
 
def path_prefix_key(path):
1393
 
    """Generate a prefix-order path key for path.
1394
 
 
1395
 
    This can be used to sort paths in the same way that walkdirs does.
1396
 
    """
1397
 
    return (dirname(path) , path)
1398
 
 
1399
 
 
1400
 
def compare_paths_prefix_order(path_a, path_b):
1401
 
    """Compare path_a and path_b to generate the same order walkdirs uses."""
1402
 
    key_a = path_prefix_key(path_a)
1403
 
    key_b = path_prefix_key(path_b)
1404
 
    return cmp(key_a, key_b)
1405
 
 
1406
 
 
1407
 
_cached_user_encoding = None
1408
 
 
1409
 
 
1410
 
def get_user_encoding(use_cache=True):
1411
 
    """Find out what the preferred user encoding is.
1412
 
 
1413
 
    This is generally the encoding that is used for command line parameters
1414
 
    and file contents. This may be different from the terminal encoding
1415
 
    or the filesystem encoding.
1416
 
 
1417
 
    :param  use_cache:  Enable cache for detected encoding.
1418
 
                        (This parameter is turned on by default,
1419
 
                        and required only for selftesting)
1420
 
 
1421
 
    :return: A string defining the preferred user encoding
1422
 
    """
1423
 
    global _cached_user_encoding
1424
 
    if _cached_user_encoding is not None and use_cache:
1425
 
        return _cached_user_encoding
1426
 
 
1427
 
    if sys.platform == 'darwin':
1428
 
        # work around egregious python 2.4 bug
1429
 
        sys.platform = 'posix'
1430
 
        try:
1431
 
            import locale
1432
 
        finally:
1433
 
            sys.platform = 'darwin'
1434
 
    else:
1435
 
        import locale
1436
 
 
1437
 
    try:
1438
 
        user_encoding = locale.getpreferredencoding()
1439
 
    except locale.Error, e:
1440
 
        sys.stderr.write('bzr: warning: %s\n'
1441
 
                         '  Could not determine what text encoding to use.\n'
1442
 
                         '  This error usually means your Python interpreter\n'
1443
 
                         '  doesn\'t support the locale set by $LANG (%s)\n'
1444
 
                         "  Continuing with ascii encoding.\n"
1445
 
                         % (e, os.environ.get('LANG')))
1446
 
        user_encoding = 'ascii'
1447
 
 
1448
 
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
1449
 
    # treat that as ASCII, and not support printing unicode characters to the
1450
 
    # console.
1451
 
    #
1452
 
    # For python scripts run under vim, we get '', so also treat that as ASCII
1453
 
    if user_encoding in (None, 'cp0', ''):
1454
 
        user_encoding = 'ascii'
1455
 
    else:
1456
 
        # check encoding
1457
 
        try:
1458
 
            codecs.lookup(user_encoding)
1459
 
        except LookupError:
1460
 
            sys.stderr.write('bzr: warning:'
1461
 
                             ' unknown encoding %s.'
1462
 
                             ' Continuing with ascii encoding.\n'
1463
 
                             % user_encoding
1464
 
                            )
1465
 
            user_encoding = 'ascii'
1466
 
 
1467
 
    if use_cache:
1468
 
        _cached_user_encoding = user_encoding
1469
 
 
1470
 
    return user_encoding
1471
 
 
1472
 
 
1473
 
def get_host_name():
1474
 
    """Return the current unicode host name.
1475
 
 
1476
 
    This is meant to be used in place of socket.gethostname() because that
1477
 
    behaves inconsistently on different platforms.
1478
 
    """
1479
 
    if sys.platform == "win32":
1480
 
        import win32utils
1481
 
        return win32utils.get_host_name()
1482
 
    else:
1483
 
        import socket
1484
 
        return socket.gethostname().decode(get_user_encoding())
1485
 
 
1486
 
 
1487
 
def recv_all(socket, bytes):
1488
 
    """Receive an exact number of bytes.
1489
 
 
1490
 
    Regular Socket.recv() may return less than the requested number of bytes,
1491
 
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
1492
 
    on all platforms, but this should work everywhere.  This will return
1493
 
    less than the requested amount if the remote end closes.
1494
 
 
1495
 
    This isn't optimized and is intended mostly for use in testing.
1496
 
    """
1497
 
    b = ''
1498
 
    while len(b) < bytes:
1499
 
        new = socket.recv(bytes - len(b))
1500
 
        if new == '':
1501
 
            break # eof
1502
 
        b += new
1503
 
    return b
1504
 
 
1505
 
 
1506
 
def send_all(socket, bytes):
1507
 
    """Send all bytes on a socket.
1508
 
 
1509
 
    Regular socket.sendall() can give socket error 10053 on Windows.  This
1510
 
    implementation sends no more than 64k at a time, which avoids this problem.
1511
 
    """
1512
 
    chunk_size = 2**16
1513
 
    for pos in xrange(0, len(bytes), chunk_size):
1514
 
        socket.sendall(bytes[pos:pos+chunk_size])
1515
 
 
1516
 
 
1517
 
def dereference_path(path):
1518
 
    """Determine the real path to a file.
1519
 
 
1520
 
    All parent elements are dereferenced.  But the file itself is not
1521
 
    dereferenced.
1522
 
    :param path: The original path.  May be absolute or relative.
1523
 
    :return: the real path *to* the file
1524
 
    """
1525
 
    parent, base = os.path.split(path)
1526
 
    # The pathjoin for '.' is a workaround for Python bug #1213894.
1527
 
    # (initial path components aren't dereferenced)
1528
 
    return pathjoin(realpath(pathjoin('.', parent)), base)
1529
 
 
1530
 
 
1531
 
def supports_mapi():
1532
 
    """Return True if we can use MAPI to launch a mail client."""
1533
 
    return sys.platform == "win32"
1534
 
 
1535
 
 
1536
 
def resource_string(package, resource_name):
1537
 
    """Load a resource from a package and return it as a string.
1538
 
 
1539
 
    Note: Only packages that start with bzrlib are currently supported.
1540
 
 
1541
 
    This is designed to be a lightweight implementation of resource
1542
 
    loading in a way which is API compatible with the same API from
1543
 
    pkg_resources. See
1544
 
    http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
1545
 
    If and when pkg_resources becomes a standard library, this routine
1546
 
    can delegate to it.
1547
 
    """
1548
 
    # Check package name is within bzrlib
1549
 
    if package == "bzrlib":
1550
 
        resource_relpath = resource_name
1551
 
    elif package.startswith("bzrlib."):
1552
 
        package = package[len("bzrlib."):].replace('.', os.sep)
1553
 
        resource_relpath = pathjoin(package, resource_name)
1554
 
    else:
1555
 
        raise errors.BzrError('resource package %s not in bzrlib' % package)
1556
 
 
1557
 
    # Map the resource to a file and read its contents
1558
 
    base = dirname(bzrlib.__file__)
1559
 
    if getattr(sys, 'frozen', None):    # bzr.exe
1560
 
        base = abspath(pathjoin(base, '..', '..'))
1561
 
    filename = pathjoin(base, resource_relpath)
1562
 
    return open(filename, 'rU').read()
1563
 
 
1564
 
 
1565
 
try:
1566
 
    from bzrlib._readdir_pyx import read_dir as _read_dir
1567
 
except ImportError:
1568
 
    from bzrlib._readdir_py import read_dir as _read_dir
 
717
        raise IllegalPath(path)