/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: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

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