/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: 2009-05-23 21:01:51 UTC
  • mto: This revision was merged to the branch mainline in revision 4441.
  • Revision ID: robertc@robertcollins.net-20090523210151-69jmrka5l4eh0zf3
Get missing command support sorted out.

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
4
 
 
 
1
# Copyright (C) 2005, 2006, 2007, 2009 Canonical Ltd
 
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
7
5
# the Free Software Foundation; either version 2 of the License, or
8
6
# (at your option) any later version.
9
 
 
 
7
#
10
8
# This program is distributed in the hope that it will be useful,
11
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
11
# GNU General Public License for more details.
14
 
 
 
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
19
 
import os, types, re, time, errno, sys
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
 
 
22
 
from bzrlib.errors import BzrError
23
 
from bzrlib.trace import mutter
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
import os
 
18
import re
 
19
import stat
 
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
22
import sys
 
23
import time
 
24
 
 
25
from bzrlib.lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
import codecs
 
28
from datetime import datetime
 
29
import errno
 
30
from ntpath import (abspath as _nt_abspath,
 
31
                    join as _nt_join,
 
32
                    normpath as _nt_normpath,
 
33
                    realpath as _nt_realpath,
 
34
                    splitdrive as _nt_splitdrive,
 
35
                    )
 
36
import posixpath
 
37
import shutil
 
38
from shutil import (
 
39
    rmtree,
 
40
    )
 
41
import tempfile
 
42
from tempfile import (
 
43
    mkdtemp,
 
44
    )
 
45
import unicodedata
 
46
 
 
47
from bzrlib import (
 
48
    cache_utf8,
 
49
    errors,
 
50
    win32utils,
 
51
    )
 
52
""")
 
53
 
 
54
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
 
55
# of 2.5
 
56
if sys.version_info < (2, 5):
 
57
    import md5 as _mod_md5
 
58
    md5 = _mod_md5.new
 
59
    import sha as _mod_sha
 
60
    sha = _mod_sha.new
 
61
else:
 
62
    from hashlib import (
 
63
        md5,
 
64
        sha1 as sha,
 
65
        )
 
66
 
 
67
 
24
68
import bzrlib
 
69
from bzrlib import symbol_versioning
 
70
 
 
71
 
 
72
# On win32, O_BINARY is used to indicate the file should
 
73
# be opened in binary mode, rather than text mode.
 
74
# On other platforms, O_BINARY doesn't exist, because
 
75
# they always open in binary mode, so it is okay to
 
76
# OR with 0 on those platforms
 
77
O_BINARY = getattr(os, 'O_BINARY', 0)
 
78
 
 
79
 
 
80
def get_unicode_argv():
 
81
    try:
 
82
        user_encoding = get_user_encoding()
 
83
        return [a.decode(user_encoding) for a in sys.argv[1:]]
 
84
    except UnicodeDecodeError:
 
85
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
86
                                                            "encoding." % a))
 
87
 
25
88
 
26
89
def make_readonly(filename):
27
90
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
 
    mod = os.stat(filename).st_mode
30
 
    mod = mod & 0777555
31
 
    os.chmod(filename, mod)
 
91
    mod = os.lstat(filename).st_mode
 
92
    if not stat.S_ISLNK(mod):
 
93
        mod = mod & 0777555
 
94
        os.chmod(filename, mod)
32
95
 
33
96
 
34
97
def make_writable(filename):
35
 
    mod = os.stat(filename).st_mode
36
 
    mod = mod | 0200
37
 
    os.chmod(filename, mod)
38
 
 
39
 
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
41
 
 
42
 
_SLASH_RE = re.compile(r'[\\/]+')
 
98
    mod = os.lstat(filename).st_mode
 
99
    if not stat.S_ISLNK(mod):
 
100
        mod = mod | 0200
 
101
        os.chmod(filename, mod)
 
102
 
 
103
 
 
104
def minimum_path_selection(paths):
 
105
    """Return the smallset subset of paths which are outside paths.
 
106
 
 
107
    :param paths: A container (and hence not None) of paths.
 
108
    :return: A set of paths sufficient to include everything in paths via
 
109
        is_inside, drawn from the paths parameter.
 
110
    """
 
111
    if len(paths) < 2:
 
112
        return set(paths)
 
113
 
 
114
    def sort_key(path):
 
115
        return path.split('/')
 
116
    sorted_paths = sorted(list(paths), key=sort_key)
 
117
 
 
118
    search_paths = [sorted_paths[0]]
 
119
    for path in sorted_paths[1:]:
 
120
        if not is_inside(search_paths[-1], path):
 
121
            # This path is unique, add it
 
122
            search_paths.append(path)
 
123
 
 
124
    return set(search_paths)
 
125
 
 
126
 
 
127
_QUOTE_RE = None
 
128
 
43
129
 
44
130
def quotefn(f):
45
131
    """Return a quoted filename filename
47
133
    This previously used backslash quoting, but that works poorly on
48
134
    Windows."""
49
135
    # TODO: I'm not really sure this is the best format either.x
 
136
    global _QUOTE_RE
 
137
    if _QUOTE_RE is None:
 
138
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
139
 
50
140
    if _QUOTE_RE.search(f):
51
141
        return '"' + f + '"'
52
142
    else:
53
143
        return f
54
144
 
55
145
 
56
 
def file_kind(f):
57
 
    mode = os.lstat(f)[ST_MODE]
58
 
    if S_ISREG(mode):
59
 
        return 'file'
60
 
    elif S_ISDIR(mode):
61
 
        return 'directory'
62
 
    elif S_ISLNK(mode):
63
 
        return 'symlink'
64
 
    else:
65
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
146
_directory_kind = 'directory'
 
147
 
 
148
def get_umask():
 
149
    """Return the current umask"""
 
150
    # Assume that people aren't messing with the umask while running
 
151
    # XXX: This is not thread safe, but there is no way to get the
 
152
    #      umask without setting it
 
153
    umask = os.umask(0)
 
154
    os.umask(umask)
 
155
    return umask
 
156
 
 
157
 
 
158
_kind_marker_map = {
 
159
    "file": "",
 
160
    _directory_kind: "/",
 
161
    "symlink": "@",
 
162
    'tree-reference': '+',
 
163
}
66
164
 
67
165
 
68
166
def kind_marker(kind):
69
 
    if kind == 'file':
70
 
        return ''
71
 
    elif kind == 'directory':
72
 
        return '/'
73
 
    elif kind == 'symlink':
74
 
        return '@'
75
 
    else:
76
 
        raise BzrError('invalid file kind %r' % kind)
77
 
 
78
 
 
79
 
 
80
 
def backup_file(fn):
81
 
    """Copy a file to a backup.
82
 
 
83
 
    Backups are named in GNU-style, with a ~ suffix.
84
 
 
85
 
    If the file is already a backup, it's not copied.
86
 
    """
87
 
    import os
88
 
    if fn[-1] == '~':
89
 
        return
90
 
    bfn = fn + '~'
91
 
 
92
 
    inf = file(fn, 'rb')
93
 
    try:
94
 
        content = inf.read()
95
 
    finally:
96
 
        inf.close()
97
 
    
98
 
    outf = file(bfn, 'wb')
99
 
    try:
100
 
        outf.write(content)
101
 
    finally:
102
 
        outf.close()
103
 
 
104
 
def rename(path_from, path_to):
105
 
    """Basically the same as os.rename() just special for win32"""
106
 
    if sys.platform == 'win32':
 
167
    try:
 
168
        return _kind_marker_map[kind]
 
169
    except KeyError:
 
170
        raise errors.BzrError('invalid file kind %r' % kind)
 
171
 
 
172
 
 
173
lexists = getattr(os.path, 'lexists', None)
 
174
if lexists is None:
 
175
    def lexists(f):
107
176
        try:
108
 
            os.remove(path_to)
 
177
            stat = getattr(os, 'lstat', os.stat)
 
178
            stat(f)
 
179
            return True
109
180
        except OSError, e:
110
 
            if e.errno != e.ENOENT:
 
181
            if e.errno == errno.ENOENT:
 
182
                return False;
 
183
            else:
 
184
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
 
185
 
 
186
 
 
187
def fancy_rename(old, new, rename_func, unlink_func):
 
188
    """A fancy rename, when you don't have atomic rename.
 
189
 
 
190
    :param old: The old path, to rename from
 
191
    :param new: The new path, to rename to
 
192
    :param rename_func: The potentially non-atomic rename function
 
193
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
194
    """
 
195
 
 
196
    # sftp rename doesn't allow overwriting, so play tricks:
 
197
    base = os.path.basename(new)
 
198
    dirname = os.path.dirname(new)
 
199
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
200
    tmp_name = pathjoin(dirname, tmp_name)
 
201
 
 
202
    # Rename the file out of the way, but keep track if it didn't exist
 
203
    # We don't want to grab just any exception
 
204
    # something like EACCES should prevent us from continuing
 
205
    # The downside is that the rename_func has to throw an exception
 
206
    # with an errno = ENOENT, or NoSuchFile
 
207
    file_existed = False
 
208
    try:
 
209
        rename_func(new, tmp_name)
 
210
    except (errors.NoSuchFile,), e:
 
211
        pass
 
212
    except IOError, e:
 
213
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
214
        # function raises an IOError with errno is None when a rename fails.
 
215
        # This then gets caught here.
 
216
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
217
            raise
 
218
    except Exception, e:
 
219
        if (getattr(e, 'errno', None) is None
 
220
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
221
            raise
 
222
    else:
 
223
        file_existed = True
 
224
 
 
225
    success = False
 
226
    try:
 
227
        try:
 
228
            # This may throw an exception, in which case success will
 
229
            # not be set.
 
230
            rename_func(old, new)
 
231
            success = True
 
232
        except (IOError, OSError), e:
 
233
            # source and target may be aliases of each other (e.g. on a
 
234
            # case-insensitive filesystem), so we may have accidentally renamed
 
235
            # source by when we tried to rename target
 
236
            if not (file_existed and e.errno in (None, errno.ENOENT)):
111
237
                raise
112
 
    os.rename(path_from, path_to)
113
 
 
114
 
 
115
 
 
 
238
    finally:
 
239
        if file_existed:
 
240
            # If the file used to exist, rename it back into place
 
241
            # otherwise just delete it from the tmp location
 
242
            if success:
 
243
                unlink_func(tmp_name)
 
244
            else:
 
245
                rename_func(tmp_name, new)
 
246
 
 
247
 
 
248
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
249
# choke on a Unicode string containing a relative path if
 
250
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
251
# string.
 
252
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
 
253
def _posix_abspath(path):
 
254
    # jam 20060426 rather than encoding to fsencoding
 
255
    # copy posixpath.abspath, but use os.getcwdu instead
 
256
    if not posixpath.isabs(path):
 
257
        path = posixpath.join(getcwd(), path)
 
258
    return posixpath.normpath(path)
 
259
 
 
260
 
 
261
def _posix_realpath(path):
 
262
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
263
 
 
264
 
 
265
def _win32_fixdrive(path):
 
266
    """Force drive letters to be consistent.
 
267
 
 
268
    win32 is inconsistent whether it returns lower or upper case
 
269
    and even if it was consistent the user might type the other
 
270
    so we force it to uppercase
 
271
    running python.exe under cmd.exe return capital C:\\
 
272
    running win32 python inside a cygwin shell returns lowercase c:\\
 
273
    """
 
274
    drive, path = _nt_splitdrive(path)
 
275
    return drive.upper() + path
 
276
 
 
277
 
 
278
def _win32_abspath(path):
 
279
    # Real _nt_abspath doesn't have a problem with a unicode cwd
 
280
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
 
281
 
 
282
 
 
283
def _win98_abspath(path):
 
284
    """Return the absolute version of a path.
 
285
    Windows 98 safe implementation (python reimplementation
 
286
    of Win32 API function GetFullPathNameW)
 
287
    """
 
288
    # Corner cases:
 
289
    #   C:\path     => C:/path
 
290
    #   C:/path     => C:/path
 
291
    #   \\HOST\path => //HOST/path
 
292
    #   //HOST/path => //HOST/path
 
293
    #   path        => C:/cwd/path
 
294
    #   /path       => C:/path
 
295
    path = unicode(path)
 
296
    # check for absolute path
 
297
    drive = _nt_splitdrive(path)[0]
 
298
    if drive == '' and path[:2] not in('//','\\\\'):
 
299
        cwd = os.getcwdu()
 
300
        # we cannot simply os.path.join cwd and path
 
301
        # because os.path.join('C:','/path') produce '/path'
 
302
        # and this is incorrect
 
303
        if path[:1] in ('/','\\'):
 
304
            cwd = _nt_splitdrive(cwd)[0]
 
305
            path = path[1:]
 
306
        path = cwd + '\\' + path
 
307
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
 
308
 
 
309
 
 
310
def _win32_realpath(path):
 
311
    # Real _nt_realpath doesn't have a problem with a unicode cwd
 
312
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
 
313
 
 
314
 
 
315
def _win32_pathjoin(*args):
 
316
    return _nt_join(*args).replace('\\', '/')
 
317
 
 
318
 
 
319
def _win32_normpath(path):
 
320
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
321
 
 
322
 
 
323
def _win32_getcwd():
 
324
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
 
325
 
 
326
 
 
327
def _win32_mkdtemp(*args, **kwargs):
 
328
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
 
329
 
 
330
 
 
331
def _win32_rename(old, new):
 
332
    """We expect to be able to atomically replace 'new' with old.
 
333
 
 
334
    On win32, if new exists, it must be moved out of the way first,
 
335
    and then deleted.
 
336
    """
 
337
    try:
 
338
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
339
    except OSError, e:
 
340
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
 
341
            # If we try to rename a non-existant file onto cwd, we get
 
342
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
 
343
            # if the old path doesn't exist, sometimes we get EACCES
 
344
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
 
345
            os.lstat(old)
 
346
        raise
 
347
 
 
348
 
 
349
def _mac_getcwd():
 
350
    return unicodedata.normalize('NFC', os.getcwdu())
 
351
 
 
352
 
 
353
# Default is to just use the python builtins, but these can be rebound on
 
354
# particular platforms.
 
355
abspath = _posix_abspath
 
356
realpath = _posix_realpath
 
357
pathjoin = os.path.join
 
358
normpath = os.path.normpath
 
359
getcwd = os.getcwdu
 
360
rename = os.rename
 
361
dirname = os.path.dirname
 
362
basename = os.path.basename
 
363
split = os.path.split
 
364
splitext = os.path.splitext
 
365
# These were already imported into local scope
 
366
# mkdtemp = tempfile.mkdtemp
 
367
# rmtree = shutil.rmtree
 
368
 
 
369
MIN_ABS_PATHLENGTH = 1
 
370
 
 
371
 
 
372
if sys.platform == 'win32':
 
373
    if win32utils.winver == 'Windows 98':
 
374
        abspath = _win98_abspath
 
375
    else:
 
376
        abspath = _win32_abspath
 
377
    realpath = _win32_realpath
 
378
    pathjoin = _win32_pathjoin
 
379
    normpath = _win32_normpath
 
380
    getcwd = _win32_getcwd
 
381
    mkdtemp = _win32_mkdtemp
 
382
    rename = _win32_rename
 
383
 
 
384
    MIN_ABS_PATHLENGTH = 3
 
385
 
 
386
    def _win32_delete_readonly(function, path, excinfo):
 
387
        """Error handler for shutil.rmtree function [for win32]
 
388
        Helps to remove files and dirs marked as read-only.
 
389
        """
 
390
        exception = excinfo[1]
 
391
        if function in (os.remove, os.rmdir) \
 
392
            and isinstance(exception, OSError) \
 
393
            and exception.errno == errno.EACCES:
 
394
            make_writable(path)
 
395
            function(path)
 
396
        else:
 
397
            raise
 
398
 
 
399
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
 
400
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
 
401
        return shutil.rmtree(path, ignore_errors, onerror)
 
402
 
 
403
    f = win32utils.get_unicode_argv     # special function or None
 
404
    if f is not None:
 
405
        get_unicode_argv = f
 
406
 
 
407
elif sys.platform == 'darwin':
 
408
    getcwd = _mac_getcwd
 
409
 
 
410
 
 
411
def get_terminal_encoding():
 
412
    """Find the best encoding for printing to the screen.
 
413
 
 
414
    This attempts to check both sys.stdout and sys.stdin to see
 
415
    what encoding they are in, and if that fails it falls back to
 
416
    osutils.get_user_encoding().
 
417
    The problem is that on Windows, locale.getpreferredencoding()
 
418
    is not the same encoding as that used by the console:
 
419
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
 
420
 
 
421
    On my standard US Windows XP, the preferred encoding is
 
422
    cp1252, but the console is cp437
 
423
    """
 
424
    from bzrlib.trace import mutter
 
425
    output_encoding = getattr(sys.stdout, 'encoding', None)
 
426
    if not output_encoding:
 
427
        input_encoding = getattr(sys.stdin, 'encoding', None)
 
428
        if not input_encoding:
 
429
            output_encoding = get_user_encoding()
 
430
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
431
                   output_encoding)
 
432
        else:
 
433
            output_encoding = input_encoding
 
434
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
435
    else:
 
436
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
437
    if output_encoding == 'cp0':
 
438
        # invalid encoding (cp0 means 'no codepage' on Windows)
 
439
        output_encoding = get_user_encoding()
 
440
        mutter('cp0 is invalid encoding.'
 
441
               ' encoding stdout as osutils.get_user_encoding() %r',
 
442
               output_encoding)
 
443
    # check encoding
 
444
    try:
 
445
        codecs.lookup(output_encoding)
 
446
    except LookupError:
 
447
        sys.stderr.write('bzr: warning:'
 
448
                         ' unknown terminal encoding %s.\n'
 
449
                         '  Using encoding %s instead.\n'
 
450
                         % (output_encoding, get_user_encoding())
 
451
                        )
 
452
        output_encoding = get_user_encoding()
 
453
 
 
454
    return output_encoding
 
455
 
 
456
 
 
457
def normalizepath(f):
 
458
    if getattr(os.path, 'realpath', None) is not None:
 
459
        F = realpath
 
460
    else:
 
461
        F = abspath
 
462
    [p,e] = os.path.split(f)
 
463
    if e == "" or e == "." or e == "..":
 
464
        return F(f)
 
465
    else:
 
466
        return pathjoin(F(p), e)
116
467
 
117
468
 
118
469
def isdir(f):
123
474
        return False
124
475
 
125
476
 
126
 
 
127
477
def isfile(f):
128
478
    """True if f is a regular file."""
129
479
    try:
131
481
    except OSError:
132
482
        return False
133
483
 
 
484
def islink(f):
 
485
    """True if f is a symlink."""
 
486
    try:
 
487
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
488
    except OSError:
 
489
        return False
134
490
 
135
491
def is_inside(dir, fname):
136
492
    """True if fname is inside dir.
137
 
    
138
 
    The parameters should typically be passed to os.path.normpath first, so
 
493
 
 
494
    The parameters should typically be passed to osutils.normpath first, so
139
495
    that . and .. and repeated slashes are eliminated, and the separators
140
496
    are canonical for the platform.
141
 
    
142
 
    The empty string as a dir name is taken as top-of-tree and matches 
 
497
 
 
498
    The empty string as a dir name is taken as top-of-tree and matches
143
499
    everything.
144
 
    
145
 
    >>> is_inside('src', 'src/foo.c')
146
 
    True
147
 
    >>> is_inside('src', 'srccontrol')
148
 
    False
149
 
    >>> is_inside('src', 'src/a/a/a/foo.c')
150
 
    True
151
 
    >>> is_inside('foo.c', 'foo.c')
152
 
    True
153
 
    >>> is_inside('foo.c', '')
154
 
    False
155
 
    >>> is_inside('', 'foo.c')
156
 
    True
157
500
    """
158
 
    # XXX: Most callers of this can actually do something smarter by 
 
501
    # XXX: Most callers of this can actually do something smarter by
159
502
    # looking at the inventory
160
503
    if dir == fname:
161
504
        return True
162
 
    
 
505
 
163
506
    if dir == '':
164
507
        return True
165
 
    
166
 
    if dir[-1] != os.sep:
167
 
        dir += os.sep
168
 
    
 
508
 
 
509
    if dir[-1] != '/':
 
510
        dir += '/'
 
511
 
169
512
    return fname.startswith(dir)
170
513
 
171
514
 
174
517
    for dirname in dir_list:
175
518
        if is_inside(dirname, fname):
176
519
            return True
 
520
    return False
 
521
 
 
522
 
 
523
def is_inside_or_parent_of_any(dir_list, fname):
 
524
    """True if fname is a child or a parent of any of the given files."""
 
525
    for dirname in dir_list:
 
526
        if is_inside(dirname, fname) or is_inside(fname, dirname):
 
527
            return True
 
528
    return False
 
529
 
 
530
 
 
531
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768,
 
532
             report_activity=None, direction='read'):
 
533
    """Copy contents of one file to another.
 
534
 
 
535
    The read_length can either be -1 to read to end-of-file (EOF) or
 
536
    it can specify the maximum number of bytes to read.
 
537
 
 
538
    The buff_size represents the maximum size for each read operation
 
539
    performed on from_file.
 
540
 
 
541
    :param report_activity: Call this as bytes are read, see
 
542
        Transport._report_activity
 
543
    :param direction: Will be passed to report_activity
 
544
 
 
545
    :return: The number of bytes copied.
 
546
    """
 
547
    length = 0
 
548
    if read_length >= 0:
 
549
        # read specified number of bytes
 
550
 
 
551
        while read_length > 0:
 
552
            num_bytes_to_read = min(read_length, buff_size)
 
553
 
 
554
            block = from_file.read(num_bytes_to_read)
 
555
            if not block:
 
556
                # EOF reached
 
557
                break
 
558
            if report_activity is not None:
 
559
                report_activity(len(block), direction)
 
560
            to_file.write(block)
 
561
 
 
562
            actual_bytes_read = len(block)
 
563
            read_length -= actual_bytes_read
 
564
            length += actual_bytes_read
177
565
    else:
178
 
        return False
179
 
 
180
 
 
181
 
def pumpfile(fromfile, tofile):
182
 
    """Copy contents of one file to another."""
183
 
    tofile.write(fromfile.read())
184
 
 
185
 
 
186
 
def uuid():
187
 
    """Return a new UUID"""
188
 
    try:
189
 
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
190
 
    except IOError:
191
 
        return chomp(os.popen('uuidgen').readline())
 
566
        # read to EOF
 
567
        while True:
 
568
            block = from_file.read(buff_size)
 
569
            if not block:
 
570
                # EOF reached
 
571
                break
 
572
            if report_activity is not None:
 
573
                report_activity(len(block), direction)
 
574
            to_file.write(block)
 
575
            length += len(block)
 
576
    return length
 
577
 
 
578
 
 
579
def pump_string_file(bytes, file_handle, segment_size=None):
 
580
    """Write bytes to file_handle in many smaller writes.
 
581
 
 
582
    :param bytes: The string to write.
 
583
    :param file_handle: The file to write to.
 
584
    """
 
585
    # Write data in chunks rather than all at once, because very large
 
586
    # writes fail on some platforms (e.g. Windows with SMB  mounted
 
587
    # drives).
 
588
    if not segment_size:
 
589
        segment_size = 5242880 # 5MB
 
590
    segments = range(len(bytes) / segment_size + 1)
 
591
    write = file_handle.write
 
592
    for segment_index in segments:
 
593
        segment = buffer(bytes, segment_index * segment_size, segment_size)
 
594
        write(segment)
 
595
 
 
596
 
 
597
def file_iterator(input_file, readsize=32768):
 
598
    while True:
 
599
        b = input_file.read(readsize)
 
600
        if len(b) == 0:
 
601
            break
 
602
        yield b
192
603
 
193
604
 
194
605
def sha_file(f):
195
 
    import sha
196
 
    if hasattr(f, 'tell'):
197
 
        assert f.tell() == 0
198
 
    s = sha.new()
199
 
    BUFSIZE = 128<<10
200
 
    while True:
201
 
        b = f.read(BUFSIZE)
202
 
        if not b:
203
 
            break
204
 
        s.update(b)
205
 
    return s.hexdigest()
206
 
 
207
 
 
208
 
def sha_string(f):
209
 
    import sha
210
 
    s = sha.new()
211
 
    s.update(f)
212
 
    return s.hexdigest()
213
 
 
 
606
    """Calculate the hexdigest of an open file.
 
607
 
 
608
    The file cursor should be already at the start.
 
609
    """
 
610
    s = sha()
 
611
    BUFSIZE = 128<<10
 
612
    while True:
 
613
        b = f.read(BUFSIZE)
 
614
        if not b:
 
615
            break
 
616
        s.update(b)
 
617
    return s.hexdigest()
 
618
 
 
619
 
 
620
def size_sha_file(f):
 
621
    """Calculate the size and hexdigest of an open file.
 
622
 
 
623
    The file cursor should be already at the start and
 
624
    the caller is responsible for closing the file afterwards.
 
625
    """
 
626
    size = 0
 
627
    s = sha()
 
628
    BUFSIZE = 128<<10
 
629
    while True:
 
630
        b = f.read(BUFSIZE)
 
631
        if not b:
 
632
            break
 
633
        size += len(b)
 
634
        s.update(b)
 
635
    return size, s.hexdigest()
 
636
 
 
637
 
 
638
def sha_file_by_name(fname):
 
639
    """Calculate the SHA1 of a file by reading the full text"""
 
640
    s = sha()
 
641
    f = os.open(fname, os.O_RDONLY | O_BINARY)
 
642
    try:
 
643
        while True:
 
644
            b = os.read(f, 1<<16)
 
645
            if not b:
 
646
                return s.hexdigest()
 
647
            s.update(b)
 
648
    finally:
 
649
        os.close(f)
 
650
 
 
651
 
 
652
def sha_strings(strings, _factory=sha):
 
653
    """Return the sha-1 of concatenation of strings"""
 
654
    s = _factory()
 
655
    map(s.update, strings)
 
656
    return s.hexdigest()
 
657
 
 
658
 
 
659
def sha_string(f, _factory=sha):
 
660
    return _factory(f).hexdigest()
214
661
 
215
662
 
216
663
def fingerprint_file(f):
217
 
    import sha
218
 
    s = sha.new()
219
664
    b = f.read()
220
 
    s.update(b)
221
 
    size = len(b)
222
 
    return {'size': size,
223
 
            'sha1': s.hexdigest()}
224
 
 
225
 
 
226
 
def config_dir():
227
 
    """Return per-user configuration directory.
228
 
 
229
 
    By default this is ~/.bzr.conf/
230
 
    
231
 
    TODO: Global option --config-dir to override this.
232
 
    """
233
 
    return os.path.expanduser("~/.bzr.conf")
234
 
 
235
 
 
236
 
def _auto_user_id():
237
 
    """Calculate automatic user identification.
238
 
 
239
 
    Returns (realname, email).
240
 
 
241
 
    Only used when none is set in the environment or the id file.
242
 
 
243
 
    This previously used the FQDN as the default domain, but that can
244
 
    be very slow on machines where DNS is broken.  So now we simply
245
 
    use the hostname.
246
 
    """
247
 
    import socket
248
 
 
249
 
    # XXX: Any good way to get real user name on win32?
250
 
 
251
 
    try:
252
 
        import pwd
253
 
        uid = os.getuid()
254
 
        w = pwd.getpwuid(uid)
255
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
256
 
        username = w.pw_name.decode(bzrlib.user_encoding)
257
 
        comma = gecos.find(',')
258
 
        if comma == -1:
259
 
            realname = gecos
260
 
        else:
261
 
            realname = gecos[:comma]
262
 
        if not realname:
263
 
            realname = username
264
 
 
265
 
    except ImportError:
266
 
        import getpass
267
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
268
 
 
269
 
    return realname, (username + '@' + socket.gethostname())
270
 
 
271
 
 
272
 
def _get_user_id():
273
 
    """Return the full user id from a file or environment variable.
274
 
 
275
 
    TODO: Allow taking this from a file in the branch directory too
276
 
    for per-branch ids."""
277
 
    v = os.environ.get('BZREMAIL')
278
 
    if v:
279
 
        return v.decode(bzrlib.user_encoding)
280
 
    
281
 
    try:
282
 
        return (open(os.path.join(config_dir(), "email"))
283
 
                .read()
284
 
                .decode(bzrlib.user_encoding)
285
 
                .rstrip("\r\n"))
286
 
    except IOError, e:
287
 
        if e.errno != errno.ENOENT:
288
 
            raise e
289
 
 
290
 
    v = os.environ.get('EMAIL')
291
 
    if v:
292
 
        return v.decode(bzrlib.user_encoding)
293
 
    else:    
294
 
        return None
295
 
 
296
 
 
297
 
def username():
298
 
    """Return email-style username.
299
 
 
300
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
301
 
 
302
 
    TODO: Check it's reasonably well-formed.
303
 
    """
304
 
    v = _get_user_id()
305
 
    if v:
306
 
        return v
307
 
    
308
 
    name, email = _auto_user_id()
309
 
    if name:
310
 
        return '%s <%s>' % (name, email)
311
 
    else:
312
 
        return email
313
 
 
314
 
 
315
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
316
 
def user_email():
317
 
    """Return just the email component of a username."""
318
 
    e = _get_user_id()
319
 
    if e:
320
 
        m = _EMAIL_RE.search(e)
321
 
        if not m:
322
 
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
323
 
        return m.group(0)
324
 
 
325
 
    return _auto_user_id()[1]
326
 
    
 
665
    return {'size': len(b),
 
666
            'sha1': sha(b).hexdigest()}
327
667
 
328
668
 
329
669
def compare_files(a, b):
338
678
            return True
339
679
 
340
680
 
341
 
 
342
681
def local_time_offset(t=None):
343
682
    """Return offset of local zone from GMT, either at present or at time t."""
344
 
    # python2.3 localtime() can't take None
345
 
    if t == None:
 
683
    if t is None:
346
684
        t = time.time()
347
 
        
348
 
    if time.localtime(t).tm_isdst and time.daylight:
349
 
        return -time.altzone
350
 
    else:
351
 
        return -time.timezone
352
 
 
353
 
    
354
 
def format_date(t, offset=0, timezone='original'):
355
 
    ## TODO: Perhaps a global option to use either universal or local time?
356
 
    ## Or perhaps just let people set $TZ?
357
 
    assert isinstance(t, float)
358
 
    
 
685
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
 
686
    return offset.days * 86400 + offset.seconds
 
687
 
 
688
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 
689
 
 
690
def format_date(t, offset=0, timezone='original', date_fmt=None,
 
691
                show_offset=True):
 
692
    """Return a formatted date string.
 
693
 
 
694
    :param t: Seconds since the epoch.
 
695
    :param offset: Timezone offset in seconds east of utc.
 
696
    :param timezone: How to display the time: 'utc', 'original' for the
 
697
         timezone specified by offset, or 'local' for the process's current
 
698
         timezone.
 
699
    :param date_fmt: strftime format.
 
700
    :param show_offset: Whether to append the timezone.
 
701
    """
 
702
    (date_fmt, tt, offset_str) = \
 
703
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
704
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
705
    date_str = time.strftime(date_fmt, tt)
 
706
    return date_str + offset_str
 
707
 
 
708
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
 
709
                      show_offset=True):
 
710
    """Return an unicode date string formatted according to the current locale.
 
711
 
 
712
    :param t: Seconds since the epoch.
 
713
    :param offset: Timezone offset in seconds east of utc.
 
714
    :param timezone: How to display the time: 'utc', 'original' for the
 
715
         timezone specified by offset, or 'local' for the process's current
 
716
         timezone.
 
717
    :param date_fmt: strftime format.
 
718
    :param show_offset: Whether to append the timezone.
 
719
    """
 
720
    (date_fmt, tt, offset_str) = \
 
721
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
722
    date_str = time.strftime(date_fmt, tt)
 
723
    if not isinstance(date_str, unicode):
 
724
        date_str = date_str.decode(bzrlib.user_encoding, 'replace')
 
725
    return date_str + offset_str
 
726
 
 
727
def _format_date(t, offset, timezone, date_fmt, show_offset):
359
728
    if timezone == 'utc':
360
729
        tt = time.gmtime(t)
361
730
        offset = 0
362
731
    elif timezone == 'original':
363
 
        if offset == None:
 
732
        if offset is None:
364
733
            offset = 0
365
734
        tt = time.gmtime(t + offset)
366
735
    elif timezone == 'local':
367
736
        tt = time.localtime(t)
368
737
        offset = local_time_offset(t)
369
738
    else:
370
 
        raise BzrError("unsupported timezone format %r" % timezone,
371
 
                       ['options are "utc", "original", "local"'])
372
 
 
373
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
374
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
739
        raise errors.UnsupportedTimezoneFormat(timezone)
 
740
    if date_fmt is None:
 
741
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
742
    if show_offset:
 
743
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
744
    else:
 
745
        offset_str = ''
 
746
    return (date_fmt, tt, offset_str)
375
747
 
376
748
 
377
749
def compact_date(when):
378
750
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
379
 
    
380
 
 
 
751
 
 
752
 
 
753
def format_delta(delta):
 
754
    """Get a nice looking string for a time delta.
 
755
 
 
756
    :param delta: The time difference in seconds, can be positive or negative.
 
757
        positive indicates time in the past, negative indicates time in the
 
758
        future. (usually time.time() - stored_time)
 
759
    :return: String formatted to show approximate resolution
 
760
    """
 
761
    delta = int(delta)
 
762
    if delta >= 0:
 
763
        direction = 'ago'
 
764
    else:
 
765
        direction = 'in the future'
 
766
        delta = -delta
 
767
 
 
768
    seconds = delta
 
769
    if seconds < 90: # print seconds up to 90 seconds
 
770
        if seconds == 1:
 
771
            return '%d second %s' % (seconds, direction,)
 
772
        else:
 
773
            return '%d seconds %s' % (seconds, direction)
 
774
 
 
775
    minutes = int(seconds / 60)
 
776
    seconds -= 60 * minutes
 
777
    if seconds == 1:
 
778
        plural_seconds = ''
 
779
    else:
 
780
        plural_seconds = 's'
 
781
    if minutes < 90: # print minutes, seconds up to 90 minutes
 
782
        if minutes == 1:
 
783
            return '%d minute, %d second%s %s' % (
 
784
                    minutes, seconds, plural_seconds, direction)
 
785
        else:
 
786
            return '%d minutes, %d second%s %s' % (
 
787
                    minutes, seconds, plural_seconds, direction)
 
788
 
 
789
    hours = int(minutes / 60)
 
790
    minutes -= 60 * hours
 
791
    if minutes == 1:
 
792
        plural_minutes = ''
 
793
    else:
 
794
        plural_minutes = 's'
 
795
 
 
796
    if hours == 1:
 
797
        return '%d hour, %d minute%s %s' % (hours, minutes,
 
798
                                            plural_minutes, direction)
 
799
    return '%d hours, %d minute%s %s' % (hours, minutes,
 
800
                                         plural_minutes, direction)
381
801
 
382
802
def filesize(f):
383
803
    """Return size of given open file."""
384
804
    return os.fstat(f.fileno())[ST_SIZE]
385
805
 
386
806
 
387
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
807
# Define rand_bytes based on platform.
 
808
try:
 
809
    # Python 2.4 and later have os.urandom,
 
810
    # but it doesn't work on some arches
 
811
    os.urandom(1)
388
812
    rand_bytes = os.urandom
389
 
elif sys.platform == 'linux2':
390
 
    rand_bytes = file('/dev/urandom', 'rb').read
391
 
else:
392
 
    # not well seeded, but better than nothing
393
 
    def rand_bytes(n):
394
 
        import random
395
 
        s = ''
396
 
        while n:
397
 
            s += chr(random.randint(0, 255))
398
 
            n -= 1
399
 
        return s
 
813
except (NotImplementedError, AttributeError):
 
814
    # If python doesn't have os.urandom, or it doesn't work,
 
815
    # then try to first pull random data from /dev/urandom
 
816
    try:
 
817
        rand_bytes = file('/dev/urandom', 'rb').read
 
818
    # Otherwise, use this hack as a last resort
 
819
    except (IOError, OSError):
 
820
        # not well seeded, but better than nothing
 
821
        def rand_bytes(n):
 
822
            import random
 
823
            s = ''
 
824
            while n:
 
825
                s += chr(random.randint(0, 255))
 
826
                n -= 1
 
827
            return s
 
828
 
 
829
 
 
830
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
831
def rand_chars(num):
 
832
    """Return a random string of num alphanumeric characters
 
833
 
 
834
    The result only contains lowercase chars because it may be used on
 
835
    case-insensitive filesystems.
 
836
    """
 
837
    s = ''
 
838
    for raw_byte in rand_bytes(num):
 
839
        s += ALNUM[ord(raw_byte) % 36]
 
840
    return s
400
841
 
401
842
 
402
843
## TODO: We could later have path objects that remember their list
403
844
## decomposition (might be too tricksy though.)
404
845
 
405
846
def splitpath(p):
406
 
    """Turn string into list of parts.
407
 
 
408
 
    >>> splitpath('a')
409
 
    ['a']
410
 
    >>> splitpath('a/b')
411
 
    ['a', 'b']
412
 
    >>> splitpath('a/./b')
413
 
    ['a', 'b']
414
 
    >>> splitpath('a/.b')
415
 
    ['a', '.b']
416
 
    >>> splitpath('a/../b')
417
 
    Traceback (most recent call last):
418
 
    ...
419
 
    BzrError: sorry, '..' not allowed in path
420
 
    """
421
 
    assert isinstance(p, types.StringTypes)
422
 
 
 
847
    """Turn string into list of parts."""
423
848
    # split on either delimiter because people might use either on
424
849
    # Windows
425
850
    ps = re.split(r'[\\/]', p)
427
852
    rps = []
428
853
    for f in ps:
429
854
        if f == '..':
430
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
855
            raise errors.BzrError("sorry, %r not allowed in path" % f)
431
856
        elif (f == '.') or (f == ''):
432
857
            pass
433
858
        else:
434
859
            rps.append(f)
435
860
    return rps
436
861
 
 
862
 
437
863
def joinpath(p):
438
 
    assert isinstance(p, list)
439
864
    for f in p:
440
 
        if (f == '..') or (f == None) or (f == ''):
441
 
            raise BzrError("sorry, %r not allowed in path" % f)
442
 
    return os.path.join(*p)
443
 
 
444
 
 
445
 
def appendpath(p1, p2):
446
 
    if p1 == '':
447
 
        return p2
448
 
    else:
449
 
        return os.path.join(p1, p2)
450
 
    
451
 
 
452
 
def extern_command(cmd, ignore_errors = False):
453
 
    mutter('external command: %s' % `cmd`)
454
 
    if os.system(cmd):
455
 
        if not ignore_errors:
456
 
            raise BzrError('command failed')
457
 
 
458
 
 
459
 
def _read_config_value(name):
460
 
    """Read a config value from the file ~/.bzr.conf/<name>
461
 
    Return None if the file does not exist"""
462
 
    try:
463
 
        f = file(os.path.join(config_dir(), name), "r")
464
 
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
465
 
    except IOError, e:
466
 
        if e.errno == errno.ENOENT:
467
 
            return None
 
865
        if (f == '..') or (f is None) or (f == ''):
 
866
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
867
    return pathjoin(*p)
 
868
 
 
869
 
 
870
try:
 
871
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
872
except ImportError:
 
873
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
874
 
 
875
 
 
876
def split_lines(s):
 
877
    """Split s into lines, but without removing the newline characters."""
 
878
    # Trivially convert a fulltext into a 'chunked' representation, and let
 
879
    # chunks_to_lines do the heavy lifting.
 
880
    if isinstance(s, str):
 
881
        # chunks_to_lines only supports 8-bit strings
 
882
        return chunks_to_lines([s])
 
883
    else:
 
884
        return _split_lines(s)
 
885
 
 
886
 
 
887
def _split_lines(s):
 
888
    """Split s into lines, but without removing the newline characters.
 
889
 
 
890
    This supports Unicode or plain string objects.
 
891
    """
 
892
    lines = s.split('\n')
 
893
    result = [line + '\n' for line in lines[:-1]]
 
894
    if lines[-1]:
 
895
        result.append(lines[-1])
 
896
    return result
 
897
 
 
898
 
 
899
def hardlinks_good():
 
900
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
901
 
 
902
 
 
903
def link_or_copy(src, dest):
 
904
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
905
    if not hardlinks_good():
 
906
        shutil.copyfile(src, dest)
 
907
        return
 
908
    try:
 
909
        os.link(src, dest)
 
910
    except (OSError, IOError), e:
 
911
        if e.errno != errno.EXDEV:
 
912
            raise
 
913
        shutil.copyfile(src, dest)
 
914
 
 
915
 
 
916
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
917
# Forgiveness than Permission (EAFP) because:
 
918
# - root can damage a solaris file system by using unlink,
 
919
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
920
#   EACCES, OSX: EPERM) when invoked on a directory.
 
921
def delete_any(path):
 
922
    """Delete a file or directory."""
 
923
    if isdir(path): # Takes care of symlinks
 
924
        os.rmdir(path)
 
925
    else:
 
926
        os.unlink(path)
 
927
 
 
928
 
 
929
def has_symlinks():
 
930
    if getattr(os, 'symlink', None) is not None:
 
931
        return True
 
932
    else:
 
933
        return False
 
934
 
 
935
 
 
936
def has_hardlinks():
 
937
    if getattr(os, 'link', None) is not None:
 
938
        return True
 
939
    else:
 
940
        return False
 
941
 
 
942
 
 
943
def host_os_dereferences_symlinks():
 
944
    return (has_symlinks()
 
945
            and sys.platform not in ('cygwin', 'win32'))
 
946
 
 
947
 
 
948
def readlink(abspath):
 
949
    """Return a string representing the path to which the symbolic link points.
 
950
 
 
951
    :param abspath: The link absolute unicode path.
 
952
 
 
953
    This his guaranteed to return the symbolic link in unicode in all python
 
954
    versions.
 
955
    """
 
956
    link = abspath.encode(_fs_enc)
 
957
    target = os.readlink(link)
 
958
    target = target.decode(_fs_enc)
 
959
    return target
 
960
 
 
961
 
 
962
def contains_whitespace(s):
 
963
    """True if there are any whitespace characters in s."""
 
964
    # string.whitespace can include '\xa0' in certain locales, because it is
 
965
    # considered "non-breaking-space" as part of ISO-8859-1. But it
 
966
    # 1) Isn't a breaking whitespace
 
967
    # 2) Isn't one of ' \t\r\n' which are characters we sometimes use as
 
968
    #    separators
 
969
    # 3) '\xa0' isn't unicode safe since it is >128.
 
970
 
 
971
    # This should *not* be a unicode set of characters in case the source
 
972
    # string is not a Unicode string. We can auto-up-cast the characters since
 
973
    # they are ascii, but we don't want to auto-up-cast the string in case it
 
974
    # is utf-8
 
975
    for ch in ' \t\n\r\v\f':
 
976
        if ch in s:
 
977
            return True
 
978
    else:
 
979
        return False
 
980
 
 
981
 
 
982
def contains_linebreaks(s):
 
983
    """True if there is any vertical whitespace in s."""
 
984
    for ch in '\f\n\r':
 
985
        if ch in s:
 
986
            return True
 
987
    else:
 
988
        return False
 
989
 
 
990
 
 
991
def relpath(base, path):
 
992
    """Return path relative to base, or raise exception.
 
993
 
 
994
    The path may be either an absolute path or a path relative to the
 
995
    current working directory.
 
996
 
 
997
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
998
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
999
    avoids that problem.
 
1000
    """
 
1001
 
 
1002
    if len(base) < MIN_ABS_PATHLENGTH:
 
1003
        # must have space for e.g. a drive letter
 
1004
        raise ValueError('%r is too short to calculate a relative path'
 
1005
            % (base,))
 
1006
 
 
1007
    rp = abspath(path)
 
1008
 
 
1009
    s = []
 
1010
    head = rp
 
1011
    while len(head) >= len(base):
 
1012
        if head == base:
 
1013
            break
 
1014
        head, tail = os.path.split(head)
 
1015
        if tail:
 
1016
            s.insert(0, tail)
 
1017
    else:
 
1018
        raise errors.PathNotChild(rp, base)
 
1019
 
 
1020
    if s:
 
1021
        return pathjoin(*s)
 
1022
    else:
 
1023
        return ''
 
1024
 
 
1025
 
 
1026
def _cicp_canonical_relpath(base, path):
 
1027
    """Return the canonical path relative to base.
 
1028
 
 
1029
    Like relpath, but on case-insensitive-case-preserving file-systems, this
 
1030
    will return the relpath as stored on the file-system rather than in the
 
1031
    case specified in the input string, for all existing portions of the path.
 
1032
 
 
1033
    This will cause O(N) behaviour if called for every path in a tree; if you
 
1034
    have a number of paths to convert, you should use canonical_relpaths().
 
1035
    """
 
1036
    # TODO: it should be possible to optimize this for Windows by using the
 
1037
    # win32 API FindFiles function to look for the specified name - but using
 
1038
    # os.listdir() still gives us the correct, platform agnostic semantics in
 
1039
    # the short term.
 
1040
 
 
1041
    rel = relpath(base, path)
 
1042
    # '.' will have been turned into ''
 
1043
    if not rel:
 
1044
        return rel
 
1045
 
 
1046
    abs_base = abspath(base)
 
1047
    current = abs_base
 
1048
    _listdir = os.listdir
 
1049
 
 
1050
    # use an explicit iterator so we can easily consume the rest on early exit.
 
1051
    bit_iter = iter(rel.split('/'))
 
1052
    for bit in bit_iter:
 
1053
        lbit = bit.lower()
 
1054
        for look in _listdir(current):
 
1055
            if lbit == look.lower():
 
1056
                current = pathjoin(current, look)
 
1057
                break
 
1058
        else:
 
1059
            # got to the end, nothing matched, so we just return the
 
1060
            # non-existing bits as they were specified (the filename may be
 
1061
            # the target of a move, for example).
 
1062
            current = pathjoin(current, bit, *list(bit_iter))
 
1063
            break
 
1064
    return current[len(abs_base)+1:]
 
1065
 
 
1066
# XXX - TODO - we need better detection/integration of case-insensitive
 
1067
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
 
1068
# filesystems), for example, so could probably benefit from the same basic
 
1069
# support there.  For now though, only Windows and OSX get that support, and
 
1070
# they get it for *all* file-systems!
 
1071
if sys.platform in ('win32', 'darwin'):
 
1072
    canonical_relpath = _cicp_canonical_relpath
 
1073
else:
 
1074
    canonical_relpath = relpath
 
1075
 
 
1076
def canonical_relpaths(base, paths):
 
1077
    """Create an iterable to canonicalize a sequence of relative paths.
 
1078
 
 
1079
    The intent is for this implementation to use a cache, vastly speeding
 
1080
    up multiple transformations in the same directory.
 
1081
    """
 
1082
    # but for now, we haven't optimized...
 
1083
    return [canonical_relpath(base, p) for p in paths]
 
1084
 
 
1085
def safe_unicode(unicode_or_utf8_string):
 
1086
    """Coerce unicode_or_utf8_string into unicode.
 
1087
 
 
1088
    If it is unicode, it is returned.
 
1089
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
 
1090
    wrapped in a BzrBadParameterNotUnicode exception.
 
1091
    """
 
1092
    if isinstance(unicode_or_utf8_string, unicode):
 
1093
        return unicode_or_utf8_string
 
1094
    try:
 
1095
        return unicode_or_utf8_string.decode('utf8')
 
1096
    except UnicodeDecodeError:
 
1097
        raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
1098
 
 
1099
 
 
1100
def safe_utf8(unicode_or_utf8_string):
 
1101
    """Coerce unicode_or_utf8_string to a utf8 string.
 
1102
 
 
1103
    If it is a str, it is returned.
 
1104
    If it is Unicode, it is encoded into a utf-8 string.
 
1105
    """
 
1106
    if isinstance(unicode_or_utf8_string, str):
 
1107
        # TODO: jam 20070209 This is overkill, and probably has an impact on
 
1108
        #       performance if we are dealing with lots of apis that want a
 
1109
        #       utf-8 revision id
 
1110
        try:
 
1111
            # Make sure it is a valid utf-8 string
 
1112
            unicode_or_utf8_string.decode('utf-8')
 
1113
        except UnicodeDecodeError:
 
1114
            raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
1115
        return unicode_or_utf8_string
 
1116
    return unicode_or_utf8_string.encode('utf-8')
 
1117
 
 
1118
 
 
1119
_revision_id_warning = ('Unicode revision ids were deprecated in bzr 0.15.'
 
1120
                        ' Revision id generators should be creating utf8'
 
1121
                        ' revision ids.')
 
1122
 
 
1123
 
 
1124
def safe_revision_id(unicode_or_utf8_string, warn=True):
 
1125
    """Revision ids should now be utf8, but at one point they were unicode.
 
1126
 
 
1127
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
 
1128
        utf8 or None).
 
1129
    :param warn: Functions that are sanitizing user data can set warn=False
 
1130
    :return: None or a utf8 revision id.
 
1131
    """
 
1132
    if (unicode_or_utf8_string is None
 
1133
        or unicode_or_utf8_string.__class__ == str):
 
1134
        return unicode_or_utf8_string
 
1135
    if warn:
 
1136
        symbol_versioning.warn(_revision_id_warning, DeprecationWarning,
 
1137
                               stacklevel=2)
 
1138
    return cache_utf8.encode(unicode_or_utf8_string)
 
1139
 
 
1140
 
 
1141
_file_id_warning = ('Unicode file ids were deprecated in bzr 0.15. File id'
 
1142
                    ' generators should be creating utf8 file ids.')
 
1143
 
 
1144
 
 
1145
def safe_file_id(unicode_or_utf8_string, warn=True):
 
1146
    """File ids should now be utf8, but at one point they were unicode.
 
1147
 
 
1148
    This is the same as safe_utf8, except it uses the cached encode functions
 
1149
    to save a little bit of performance.
 
1150
 
 
1151
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
 
1152
        utf8 or None).
 
1153
    :param warn: Functions that are sanitizing user data can set warn=False
 
1154
    :return: None or a utf8 file id.
 
1155
    """
 
1156
    if (unicode_or_utf8_string is None
 
1157
        or unicode_or_utf8_string.__class__ == str):
 
1158
        return unicode_or_utf8_string
 
1159
    if warn:
 
1160
        symbol_versioning.warn(_file_id_warning, DeprecationWarning,
 
1161
                               stacklevel=2)
 
1162
    return cache_utf8.encode(unicode_or_utf8_string)
 
1163
 
 
1164
 
 
1165
_platform_normalizes_filenames = False
 
1166
if sys.platform == 'darwin':
 
1167
    _platform_normalizes_filenames = True
 
1168
 
 
1169
 
 
1170
def normalizes_filenames():
 
1171
    """Return True if this platform normalizes unicode filenames.
 
1172
 
 
1173
    Mac OSX does, Windows/Linux do not.
 
1174
    """
 
1175
    return _platform_normalizes_filenames
 
1176
 
 
1177
 
 
1178
def _accessible_normalized_filename(path):
 
1179
    """Get the unicode normalized path, and if you can access the file.
 
1180
 
 
1181
    On platforms where the system normalizes filenames (Mac OSX),
 
1182
    you can access a file by any path which will normalize correctly.
 
1183
    On platforms where the system does not normalize filenames
 
1184
    (Windows, Linux), you have to access a file by its exact path.
 
1185
 
 
1186
    Internally, bzr only supports NFC normalization, since that is
 
1187
    the standard for XML documents.
 
1188
 
 
1189
    So return the normalized path, and a flag indicating if the file
 
1190
    can be accessed by that path.
 
1191
    """
 
1192
 
 
1193
    return unicodedata.normalize('NFC', unicode(path)), True
 
1194
 
 
1195
 
 
1196
def _inaccessible_normalized_filename(path):
 
1197
    __doc__ = _accessible_normalized_filename.__doc__
 
1198
 
 
1199
    normalized = unicodedata.normalize('NFC', unicode(path))
 
1200
    return normalized, normalized == path
 
1201
 
 
1202
 
 
1203
if _platform_normalizes_filenames:
 
1204
    normalized_filename = _accessible_normalized_filename
 
1205
else:
 
1206
    normalized_filename = _inaccessible_normalized_filename
 
1207
 
 
1208
 
 
1209
def terminal_width():
 
1210
    """Return estimated terminal width."""
 
1211
    if sys.platform == 'win32':
 
1212
        return win32utils.get_console_size()[0]
 
1213
    width = 0
 
1214
    try:
 
1215
        import struct, fcntl, termios
 
1216
        s = struct.pack('HHHH', 0, 0, 0, 0)
 
1217
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
 
1218
        width = struct.unpack('HHHH', x)[1]
 
1219
    except IOError:
 
1220
        pass
 
1221
    if width <= 0:
 
1222
        try:
 
1223
            width = int(os.environ['COLUMNS'])
 
1224
        except:
 
1225
            pass
 
1226
    if width <= 0:
 
1227
        width = 80
 
1228
 
 
1229
    return width
 
1230
 
 
1231
 
 
1232
def supports_executable():
 
1233
    return sys.platform != "win32"
 
1234
 
 
1235
 
 
1236
def supports_posix_readonly():
 
1237
    """Return True if 'readonly' has POSIX semantics, False otherwise.
 
1238
 
 
1239
    Notably, a win32 readonly file cannot be deleted, unlike POSIX where the
 
1240
    directory controls creation/deletion, etc.
 
1241
 
 
1242
    And under win32, readonly means that the directory itself cannot be
 
1243
    deleted.  The contents of a readonly directory can be changed, unlike POSIX
 
1244
    where files in readonly directories cannot be added, deleted or renamed.
 
1245
    """
 
1246
    return sys.platform != "win32"
 
1247
 
 
1248
 
 
1249
def set_or_unset_env(env_variable, value):
 
1250
    """Modify the environment, setting or removing the env_variable.
 
1251
 
 
1252
    :param env_variable: The environment variable in question
 
1253
    :param value: The value to set the environment to. If None, then
 
1254
        the variable will be removed.
 
1255
    :return: The original value of the environment variable.
 
1256
    """
 
1257
    orig_val = os.environ.get(env_variable)
 
1258
    if value is None:
 
1259
        if orig_val is not None:
 
1260
            del os.environ[env_variable]
 
1261
    else:
 
1262
        if isinstance(value, unicode):
 
1263
            value = value.encode(get_user_encoding())
 
1264
        os.environ[env_variable] = value
 
1265
    return orig_val
 
1266
 
 
1267
 
 
1268
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
 
1269
 
 
1270
 
 
1271
def check_legal_path(path):
 
1272
    """Check whether the supplied path is legal.
 
1273
    This is only required on Windows, so we don't test on other platforms
 
1274
    right now.
 
1275
    """
 
1276
    if sys.platform != "win32":
 
1277
        return
 
1278
    if _validWin32PathRE.match(path) is None:
 
1279
        raise errors.IllegalPath(path)
 
1280
 
 
1281
 
 
1282
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
 
1283
 
 
1284
def _is_error_enotdir(e):
 
1285
    """Check if this exception represents ENOTDIR.
 
1286
 
 
1287
    Unfortunately, python is very inconsistent about the exception
 
1288
    here. The cases are:
 
1289
      1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
 
1290
      2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
 
1291
         which is the windows error code.
 
1292
      3) Windows, Python2.5 uses errno == EINVAL and
 
1293
         winerror == ERROR_DIRECTORY
 
1294
 
 
1295
    :param e: An Exception object (expected to be OSError with an errno
 
1296
        attribute, but we should be able to cope with anything)
 
1297
    :return: True if this represents an ENOTDIR error. False otherwise.
 
1298
    """
 
1299
    en = getattr(e, 'errno', None)
 
1300
    if (en == errno.ENOTDIR
 
1301
        or (sys.platform == 'win32'
 
1302
            and (en == _WIN32_ERROR_DIRECTORY
 
1303
                 or (en == errno.EINVAL
 
1304
                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
 
1305
        ))):
 
1306
        return True
 
1307
    return False
 
1308
 
 
1309
 
 
1310
def walkdirs(top, prefix=""):
 
1311
    """Yield data about all the directories in a tree.
 
1312
 
 
1313
    This yields all the data about the contents of a directory at a time.
 
1314
    After each directory has been yielded, if the caller has mutated the list
 
1315
    to exclude some directories, they are then not descended into.
 
1316
 
 
1317
    The data yielded is of the form:
 
1318
    ((directory-relpath, directory-path-from-top),
 
1319
    [(relpath, basename, kind, lstat, path-from-top), ...]),
 
1320
     - directory-relpath is the relative path of the directory being returned
 
1321
       with respect to top. prefix is prepended to this.
 
1322
     - directory-path-from-root is the path including top for this directory.
 
1323
       It is suitable for use with os functions.
 
1324
     - relpath is the relative path within the subtree being walked.
 
1325
     - basename is the basename of the path
 
1326
     - kind is the kind of the file now. If unknown then the file is not
 
1327
       present within the tree - but it may be recorded as versioned. See
 
1328
       versioned_kind.
 
1329
     - lstat is the stat data *if* the file was statted.
 
1330
     - planned, not implemented:
 
1331
       path_from_tree_root is the path from the root of the tree.
 
1332
 
 
1333
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
 
1334
        allows one to walk a subtree but get paths that are relative to a tree
 
1335
        rooted higher up.
 
1336
    :return: an iterator over the dirs.
 
1337
    """
 
1338
    #TODO there is a bit of a smell where the results of the directory-
 
1339
    # summary in this, and the path from the root, may not agree
 
1340
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
 
1341
    # potentially confusing output. We should make this more robust - but
 
1342
    # not at a speed cost. RBC 20060731
 
1343
    _lstat = os.lstat
 
1344
    _directory = _directory_kind
 
1345
    _listdir = os.listdir
 
1346
    _kind_from_mode = file_kind_from_stat_mode
 
1347
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
 
1348
    while pending:
 
1349
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
1350
        relroot, _, _, _, top = pending.pop()
 
1351
        if relroot:
 
1352
            relprefix = relroot + u'/'
 
1353
        else:
 
1354
            relprefix = ''
 
1355
        top_slash = top + u'/'
 
1356
 
 
1357
        dirblock = []
 
1358
        append = dirblock.append
 
1359
        try:
 
1360
            names = sorted(_listdir(top))
 
1361
        except OSError, e:
 
1362
            if not _is_error_enotdir(e):
 
1363
                raise
 
1364
        else:
 
1365
            for name in names:
 
1366
                abspath = top_slash + name
 
1367
                statvalue = _lstat(abspath)
 
1368
                kind = _kind_from_mode(statvalue.st_mode)
 
1369
                append((relprefix + name, name, kind, statvalue, abspath))
 
1370
        yield (relroot, top), dirblock
 
1371
 
 
1372
        # push the user specified dirs from dirblock
 
1373
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1374
 
 
1375
 
 
1376
class DirReader(object):
 
1377
    """An interface for reading directories."""
 
1378
 
 
1379
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1380
        """Converts top and prefix to a starting dir entry
 
1381
 
 
1382
        :param top: A utf8 path
 
1383
        :param prefix: An optional utf8 path to prefix output relative paths
 
1384
            with.
 
1385
        :return: A tuple starting with prefix, and ending with the native
 
1386
            encoding of top.
 
1387
        """
 
1388
        raise NotImplementedError(self.top_prefix_to_starting_dir)
 
1389
 
 
1390
    def read_dir(self, prefix, top):
 
1391
        """Read a specific dir.
 
1392
 
 
1393
        :param prefix: A utf8 prefix to be preprended to the path basenames.
 
1394
        :param top: A natively encoded path to read.
 
1395
        :return: A list of the directories contents. Each item contains:
 
1396
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
 
1397
        """
 
1398
        raise NotImplementedError(self.read_dir)
 
1399
 
 
1400
 
 
1401
_selected_dir_reader = None
 
1402
 
 
1403
 
 
1404
def _walkdirs_utf8(top, prefix=""):
 
1405
    """Yield data about all the directories in a tree.
 
1406
 
 
1407
    This yields the same information as walkdirs() only each entry is yielded
 
1408
    in utf-8. On platforms which have a filesystem encoding of utf8 the paths
 
1409
    are returned as exact byte-strings.
 
1410
 
 
1411
    :return: yields a tuple of (dir_info, [file_info])
 
1412
        dir_info is (utf8_relpath, path-from-top)
 
1413
        file_info is (utf8_relpath, utf8_name, kind, lstat, path-from-top)
 
1414
        if top is an absolute path, path-from-top is also an absolute path.
 
1415
        path-from-top might be unicode or utf8, but it is the correct path to
 
1416
        pass to os functions to affect the file in question. (such as os.lstat)
 
1417
    """
 
1418
    global _selected_dir_reader
 
1419
    if _selected_dir_reader is None:
 
1420
        fs_encoding = _fs_enc.upper()
 
1421
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
 
1422
            # Win98 doesn't have unicode apis like FindFirstFileW
 
1423
            # TODO: We possibly could support Win98 by falling back to the
 
1424
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
 
1425
            #       but that gets a bit tricky, and requires custom compiling
 
1426
            #       for win98 anyway.
 
1427
            try:
 
1428
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1429
                _selected_dir_reader = Win32ReadDir()
 
1430
            except ImportError:
 
1431
                pass
 
1432
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1433
            # ANSI_X3.4-1968 is a form of ASCII
 
1434
            try:
 
1435
                from bzrlib._readdir_pyx import UTF8DirReader
 
1436
                _selected_dir_reader = UTF8DirReader()
 
1437
            except ImportError:
 
1438
                pass
 
1439
 
 
1440
    if _selected_dir_reader is None:
 
1441
        # Fallback to the python version
 
1442
        _selected_dir_reader = UnicodeDirReader()
 
1443
 
 
1444
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
1445
    # But we don't actually uses 1-3 in pending, so set them to None
 
1446
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
 
1447
    read_dir = _selected_dir_reader.read_dir
 
1448
    _directory = _directory_kind
 
1449
    while pending:
 
1450
        relroot, _, _, _, top = pending[-1].pop()
 
1451
        if not pending[-1]:
 
1452
            pending.pop()
 
1453
        dirblock = sorted(read_dir(relroot, top))
 
1454
        yield (relroot, top), dirblock
 
1455
        # push the user specified dirs from dirblock
 
1456
        next = [d for d in reversed(dirblock) if d[2] == _directory]
 
1457
        if next:
 
1458
            pending.append(next)
 
1459
 
 
1460
 
 
1461
class UnicodeDirReader(DirReader):
 
1462
    """A dir reader for non-utf8 file systems, which transcodes."""
 
1463
 
 
1464
    __slots__ = ['_utf8_encode']
 
1465
 
 
1466
    def __init__(self):
 
1467
        self._utf8_encode = codecs.getencoder('utf8')
 
1468
 
 
1469
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1470
        """See DirReader.top_prefix_to_starting_dir."""
 
1471
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
 
1472
 
 
1473
    def read_dir(self, prefix, top):
 
1474
        """Read a single directory from a non-utf8 file system.
 
1475
 
 
1476
        top, and the abspath element in the output are unicode, all other paths
 
1477
        are utf8. Local disk IO is done via unicode calls to listdir etc.
 
1478
 
 
1479
        This is currently the fallback code path when the filesystem encoding is
 
1480
        not UTF-8. It may be better to implement an alternative so that we can
 
1481
        safely handle paths that are not properly decodable in the current
 
1482
        encoding.
 
1483
 
 
1484
        See DirReader.read_dir for details.
 
1485
        """
 
1486
        _utf8_encode = self._utf8_encode
 
1487
        _lstat = os.lstat
 
1488
        _listdir = os.listdir
 
1489
        _kind_from_mode = file_kind_from_stat_mode
 
1490
 
 
1491
        if prefix:
 
1492
            relprefix = prefix + '/'
 
1493
        else:
 
1494
            relprefix = ''
 
1495
        top_slash = top + u'/'
 
1496
 
 
1497
        dirblock = []
 
1498
        append = dirblock.append
 
1499
        for name in sorted(_listdir(top)):
 
1500
            try:
 
1501
                name_utf8 = _utf8_encode(name)[0]
 
1502
            except UnicodeDecodeError:
 
1503
                raise errors.BadFilenameEncoding(
 
1504
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
 
1505
            abspath = top_slash + name
 
1506
            statvalue = _lstat(abspath)
 
1507
            kind = _kind_from_mode(statvalue.st_mode)
 
1508
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
 
1509
        return dirblock
 
1510
 
 
1511
 
 
1512
def copy_tree(from_path, to_path, handlers={}):
 
1513
    """Copy all of the entries in from_path into to_path.
 
1514
 
 
1515
    :param from_path: The base directory to copy.
 
1516
    :param to_path: The target directory. If it does not exist, it will
 
1517
        be created.
 
1518
    :param handlers: A dictionary of functions, which takes a source and
 
1519
        destinations for files, directories, etc.
 
1520
        It is keyed on the file kind, such as 'directory', 'symlink', or 'file'
 
1521
        'file', 'directory', and 'symlink' should always exist.
 
1522
        If they are missing, they will be replaced with 'os.mkdir()',
 
1523
        'os.readlink() + os.symlink()', and 'shutil.copy2()', respectively.
 
1524
    """
 
1525
    # Now, just copy the existing cached tree to the new location
 
1526
    # We use a cheap trick here.
 
1527
    # Absolute paths are prefixed with the first parameter
 
1528
    # relative paths are prefixed with the second.
 
1529
    # So we can get both the source and target returned
 
1530
    # without any extra work.
 
1531
 
 
1532
    def copy_dir(source, dest):
 
1533
        os.mkdir(dest)
 
1534
 
 
1535
    def copy_link(source, dest):
 
1536
        """Copy the contents of a symlink"""
 
1537
        link_to = os.readlink(source)
 
1538
        os.symlink(link_to, dest)
 
1539
 
 
1540
    real_handlers = {'file':shutil.copy2,
 
1541
                     'symlink':copy_link,
 
1542
                     'directory':copy_dir,
 
1543
                    }
 
1544
    real_handlers.update(handlers)
 
1545
 
 
1546
    if not os.path.exists(to_path):
 
1547
        real_handlers['directory'](from_path, to_path)
 
1548
 
 
1549
    for dir_info, entries in walkdirs(from_path, prefix=to_path):
 
1550
        for relpath, name, kind, st, abspath in entries:
 
1551
            real_handlers[kind](abspath, relpath)
 
1552
 
 
1553
 
 
1554
def path_prefix_key(path):
 
1555
    """Generate a prefix-order path key for path.
 
1556
 
 
1557
    This can be used to sort paths in the same way that walkdirs does.
 
1558
    """
 
1559
    return (dirname(path) , path)
 
1560
 
 
1561
 
 
1562
def compare_paths_prefix_order(path_a, path_b):
 
1563
    """Compare path_a and path_b to generate the same order walkdirs uses."""
 
1564
    key_a = path_prefix_key(path_a)
 
1565
    key_b = path_prefix_key(path_b)
 
1566
    return cmp(key_a, key_b)
 
1567
 
 
1568
 
 
1569
_cached_user_encoding = None
 
1570
 
 
1571
 
 
1572
def get_user_encoding(use_cache=True):
 
1573
    """Find out what the preferred user encoding is.
 
1574
 
 
1575
    This is generally the encoding that is used for command line parameters
 
1576
    and file contents. This may be different from the terminal encoding
 
1577
    or the filesystem encoding.
 
1578
 
 
1579
    :param  use_cache:  Enable cache for detected encoding.
 
1580
                        (This parameter is turned on by default,
 
1581
                        and required only for selftesting)
 
1582
 
 
1583
    :return: A string defining the preferred user encoding
 
1584
    """
 
1585
    global _cached_user_encoding
 
1586
    if _cached_user_encoding is not None and use_cache:
 
1587
        return _cached_user_encoding
 
1588
 
 
1589
    if sys.platform == 'darwin':
 
1590
        # python locale.getpreferredencoding() always return
 
1591
        # 'mac-roman' on darwin. That's a lie.
 
1592
        sys.platform = 'posix'
 
1593
        try:
 
1594
            if os.environ.get('LANG', None) is None:
 
1595
                # If LANG is not set, we end up with 'ascii', which is bad
 
1596
                # ('mac-roman' is more than ascii), so we set a default which
 
1597
                # will give us UTF-8 (which appears to work in all cases on
 
1598
                # OSX). Users are still free to override LANG of course, as
 
1599
                # long as it give us something meaningful. This work-around
 
1600
                # *may* not be needed with python 3k and/or OSX 10.5, but will
 
1601
                # work with them too -- vila 20080908
 
1602
                os.environ['LANG'] = 'en_US.UTF-8'
 
1603
            import locale
 
1604
        finally:
 
1605
            sys.platform = 'darwin'
 
1606
    else:
 
1607
        import locale
 
1608
 
 
1609
    try:
 
1610
        user_encoding = locale.getpreferredencoding()
 
1611
    except locale.Error, e:
 
1612
        sys.stderr.write('bzr: warning: %s\n'
 
1613
                         '  Could not determine what text encoding to use.\n'
 
1614
                         '  This error usually means your Python interpreter\n'
 
1615
                         '  doesn\'t support the locale set by $LANG (%s)\n'
 
1616
                         "  Continuing with ascii encoding.\n"
 
1617
                         % (e, os.environ.get('LANG')))
 
1618
        user_encoding = 'ascii'
 
1619
 
 
1620
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
 
1621
    # treat that as ASCII, and not support printing unicode characters to the
 
1622
    # console.
 
1623
    #
 
1624
    # For python scripts run under vim, we get '', so also treat that as ASCII
 
1625
    if user_encoding in (None, 'cp0', ''):
 
1626
        user_encoding = 'ascii'
 
1627
    else:
 
1628
        # check encoding
 
1629
        try:
 
1630
            codecs.lookup(user_encoding)
 
1631
        except LookupError:
 
1632
            sys.stderr.write('bzr: warning:'
 
1633
                             ' unknown encoding %s.'
 
1634
                             ' Continuing with ascii encoding.\n'
 
1635
                             % user_encoding
 
1636
                            )
 
1637
            user_encoding = 'ascii'
 
1638
 
 
1639
    if use_cache:
 
1640
        _cached_user_encoding = user_encoding
 
1641
 
 
1642
    return user_encoding
 
1643
 
 
1644
 
 
1645
def get_host_name():
 
1646
    """Return the current unicode host name.
 
1647
 
 
1648
    This is meant to be used in place of socket.gethostname() because that
 
1649
    behaves inconsistently on different platforms.
 
1650
    """
 
1651
    if sys.platform == "win32":
 
1652
        import win32utils
 
1653
        return win32utils.get_host_name()
 
1654
    else:
 
1655
        import socket
 
1656
        return socket.gethostname().decode(get_user_encoding())
 
1657
 
 
1658
 
 
1659
def recv_all(socket, bytes):
 
1660
    """Receive an exact number of bytes.
 
1661
 
 
1662
    Regular Socket.recv() may return less than the requested number of bytes,
 
1663
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
 
1664
    on all platforms, but this should work everywhere.  This will return
 
1665
    less than the requested amount if the remote end closes.
 
1666
 
 
1667
    This isn't optimized and is intended mostly for use in testing.
 
1668
    """
 
1669
    b = ''
 
1670
    while len(b) < bytes:
 
1671
        new = until_no_eintr(socket.recv, bytes - len(b))
 
1672
        if new == '':
 
1673
            break # eof
 
1674
        b += new
 
1675
    return b
 
1676
 
 
1677
 
 
1678
def send_all(socket, bytes, report_activity=None):
 
1679
    """Send all bytes on a socket.
 
1680
 
 
1681
    Regular socket.sendall() can give socket error 10053 on Windows.  This
 
1682
    implementation sends no more than 64k at a time, which avoids this problem.
 
1683
 
 
1684
    :param report_activity: Call this as bytes are read, see
 
1685
        Transport._report_activity
 
1686
    """
 
1687
    chunk_size = 2**16
 
1688
    for pos in xrange(0, len(bytes), chunk_size):
 
1689
        block = bytes[pos:pos+chunk_size]
 
1690
        if report_activity is not None:
 
1691
            report_activity(len(block), 'write')
 
1692
        until_no_eintr(socket.sendall, block)
 
1693
 
 
1694
 
 
1695
def dereference_path(path):
 
1696
    """Determine the real path to a file.
 
1697
 
 
1698
    All parent elements are dereferenced.  But the file itself is not
 
1699
    dereferenced.
 
1700
    :param path: The original path.  May be absolute or relative.
 
1701
    :return: the real path *to* the file
 
1702
    """
 
1703
    parent, base = os.path.split(path)
 
1704
    # The pathjoin for '.' is a workaround for Python bug #1213894.
 
1705
    # (initial path components aren't dereferenced)
 
1706
    return pathjoin(realpath(pathjoin('.', parent)), base)
 
1707
 
 
1708
 
 
1709
def supports_mapi():
 
1710
    """Return True if we can use MAPI to launch a mail client."""
 
1711
    return sys.platform == "win32"
 
1712
 
 
1713
 
 
1714
def resource_string(package, resource_name):
 
1715
    """Load a resource from a package and return it as a string.
 
1716
 
 
1717
    Note: Only packages that start with bzrlib are currently supported.
 
1718
 
 
1719
    This is designed to be a lightweight implementation of resource
 
1720
    loading in a way which is API compatible with the same API from
 
1721
    pkg_resources. See
 
1722
    http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
 
1723
    If and when pkg_resources becomes a standard library, this routine
 
1724
    can delegate to it.
 
1725
    """
 
1726
    # Check package name is within bzrlib
 
1727
    if package == "bzrlib":
 
1728
        resource_relpath = resource_name
 
1729
    elif package.startswith("bzrlib."):
 
1730
        package = package[len("bzrlib."):].replace('.', os.sep)
 
1731
        resource_relpath = pathjoin(package, resource_name)
 
1732
    else:
 
1733
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
1734
 
 
1735
    # Map the resource to a file and read its contents
 
1736
    base = dirname(bzrlib.__file__)
 
1737
    if getattr(sys, 'frozen', None):    # bzr.exe
 
1738
        base = abspath(pathjoin(base, '..', '..'))
 
1739
    filename = pathjoin(base, resource_relpath)
 
1740
    return open(filename, 'rU').read()
 
1741
 
 
1742
 
 
1743
def file_kind_from_stat_mode_thunk(mode):
 
1744
    global file_kind_from_stat_mode
 
1745
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
 
1746
        try:
 
1747
            from bzrlib._readdir_pyx import UTF8DirReader
 
1748
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
 
1749
        except ImportError:
 
1750
            from bzrlib._readdir_py import (
 
1751
                _kind_from_mode as file_kind_from_stat_mode
 
1752
                )
 
1753
    return file_kind_from_stat_mode(mode)
 
1754
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
 
1755
 
 
1756
 
 
1757
def file_kind(f, _lstat=os.lstat):
 
1758
    try:
 
1759
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
1760
    except OSError, e:
 
1761
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
 
1762
            raise errors.NoSuchFile(f)
468
1763
        raise
469
1764
 
470
1765
 
471
 
def _get_editor():
472
 
    """Return a sequence of possible editor binaries for the current platform"""
473
 
    e = _read_config_value("editor")
474
 
    if e is not None:
475
 
        yield e
476
 
        
477
 
    if os.name == "windows":
478
 
        yield "notepad.exe"
479
 
    elif os.name == "posix":
 
1766
def until_no_eintr(f, *a, **kw):
 
1767
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
 
1768
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
 
1769
    while True:
480
1770
        try:
481
 
            yield os.environ["EDITOR"]
482
 
        except KeyError:
483
 
            yield "/usr/bin/vi"
484
 
 
485
 
 
486
 
def _run_editor(filename):
487
 
    """Try to execute an editor to edit the commit message. Returns True on success,
488
 
    False on failure"""
489
 
    for e in _get_editor():
490
 
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
491
 
        if x == 0:
492
 
            return True
493
 
        elif x == 127:
494
 
            continue
495
 
        else:
496
 
            break
497
 
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
498
 
    return False
499
 
                          
500
 
 
501
 
def get_text_message(infotext, ignoreline = "default"):
502
 
    import tempfile
503
 
    
504
 
    if ignoreline == "default":
505
 
        ignoreline = "-- This line and the following will be ignored --"
506
 
        
 
1771
            return f(*a, **kw)
 
1772
        except (IOError, OSError), e:
 
1773
            if e.errno == errno.EINTR:
 
1774
                continue
 
1775
            raise
 
1776
 
 
1777
def re_compile_checked(re_string, flags=0, where=""):
 
1778
    """Return a compiled re, or raise a sensible error.
 
1779
 
 
1780
    This should only be used when compiling user-supplied REs.
 
1781
 
 
1782
    :param re_string: Text form of regular expression.
 
1783
    :param flags: eg re.IGNORECASE
 
1784
    :param where: Message explaining to the user the context where
 
1785
        it occurred, eg 'log search filter'.
 
1786
    """
 
1787
    # from https://bugs.launchpad.net/bzr/+bug/251352
507
1788
    try:
508
 
        tmp_fileno, msgfilename = tempfile.mkstemp()
509
 
        msgfile = os.close(tmp_fileno)
510
 
        if infotext is not None and infotext != "":
511
 
            hasinfo = True
512
 
            msgfile = file(msgfilename, "w")
513
 
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
514
 
            msgfile.close()
515
 
        else:
516
 
            hasinfo = False
517
 
 
518
 
        if not _run_editor(msgfilename):
519
 
            return None
520
 
        
521
 
        started = False
522
 
        msg = []
523
 
        lastline, nlines = 0, 0
524
 
        for line in file(msgfilename, "r"):
525
 
            stripped_line = line.strip()
526
 
            # strip empty line before the log message starts
527
 
            if not started:
528
 
                if stripped_line != "":
529
 
                    started = True
530
 
                else:
531
 
                    continue
532
 
            # check for the ignore line only if there
533
 
            # is additional information at the end
534
 
            if hasinfo and stripped_line == ignoreline:
535
 
                break
536
 
            nlines += 1
537
 
            # keep track of the last line that had some content
538
 
            if stripped_line != "":
539
 
                lastline = nlines
540
 
            msg.append(line)
541
 
            
542
 
        if len(msg) == 0:
543
 
            return None
544
 
        # delete empty lines at the end
545
 
        del msg[lastline:]
546
 
        # add a newline at the end, if needed
547
 
        if not msg[-1].endswith("\n"):
548
 
            return "%s%s" % ("".join(msg), "\n")
549
 
        else:
550
 
            return "".join(msg)
551
 
    finally:
552
 
        # delete the msg file in any case
553
 
        try: os.unlink(msgfilename)
554
 
        except IOError: pass
 
1789
        re_obj = re.compile(re_string, flags)
 
1790
        re_obj.search("")
 
1791
        return re_obj
 
1792
    except re.error, e:
 
1793
        if where:
 
1794
            where = ' in ' + where
 
1795
        # despite the name 'error' is a type
 
1796
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
1797
            % (where, re_string, e))
 
1798
 
 
1799
 
 
1800
if sys.platform == "win32":
 
1801
    import msvcrt
 
1802
    def getchar():
 
1803
        return msvcrt.getch()
 
1804
else:
 
1805
    import tty
 
1806
    import termios
 
1807
    def getchar():
 
1808
        fd = sys.stdin.fileno()
 
1809
        settings = termios.tcgetattr(fd)
 
1810
        try:
 
1811
            tty.setraw(fd)
 
1812
            ch = sys.stdin.read(1)
 
1813
        finally:
 
1814
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
 
1815
        return ch