~bzr-pqm/bzr/bzr.dev

from ntpath import (abspath as _nt_abspath,

                    join as _nt_join,

                    normpath as _nt_normpath,

                    realpath as _nt_realpath,

                    splitdrive as _nt_splitdrive,

                    )

from os import listdir

import posixpath

from shutil import copyfile

import stat

from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,

                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)

import unicodedata

from bzrlib.symbol_versioning import (deprecated_function, 

        zero_nine)

_directory_kind = 'directory'

 

_formats = {

    stat.S_IFDIR:_directory_kind,

    stat.S_IFCHR:'chardev',

    stat.S_IFBLK:'block',

    stat.S_IFREG:'file',

    stat.S_IFIFO:'fifo',

    stat.S_IFLNK:'symlink',

    stat.S_IFSOCK:'socket',

}

 

 

def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):

    """Generate a file kind from a stat mode. This is used in walkdirs.

 

    Its performance is critical: Do not mutate without careful benchmarking.

    """

    try:

        return _formats[stat_mode & 0170000]

    except KeyError:

        return _unknown

 

 

def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):

    try:

        return _mapper(_lstat(f).st_mode)

    except OSError, e:

        if getattr(e, 'errno', None) == errno.ENOENT:

            raise bzrlib.errors.NoSuchFile(f)

        raise

    elif kind == _directory_kind:

lexists = getattr(os.path, 'lexists', None)

if lexists is None:

    def lexists(f):

        try:

            if hasattr(os, 'lstat'):

                os.lstat(f)

            else:

                os.stat(f)

            return True

        except OSError,e:

            if e.errno == errno.ENOENT:

                return False;

            else:

                raise BzrError("lstat/stat of (%r): %r" % (f, e))

 

 

# In Python 2.4.2 and older, os.path.abspath and os.path.realpath

# choke on a Unicode string containing a relative path if

# os.getcwd() returns a non-sys.getdefaultencoding()-encoded

# string.

_fs_enc = sys.getfilesystemencoding()

def _posix_abspath(path):

    # jam 20060426 rather than encoding to fsencoding

    # copy posixpath.abspath, but use os.getcwdu instead

    if not posixpath.isabs(path):

        path = posixpath.join(getcwd(), path)

    return posixpath.normpath(path)

 

 

def _posix_realpath(path):

    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)

 

 

def _win32_fixdrive(path):

    """Force drive letters to be consistent.

 

    win32 is inconsistent whether it returns lower or upper case

    and even if it was consistent the user might type the other

    so we force it to uppercase

    running python.exe under cmd.exe return capital C:\\

    running win32 python inside a cygwin shell returns lowercase c:\\

    """

    drive, path = _nt_splitdrive(path)

    return drive.upper() + path

 

 

def _win32_abspath(path):

    # Real _nt_abspath doesn't have a problem with a unicode cwd

    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))

 

 

def _win32_realpath(path):

    # Real _nt_realpath doesn't have a problem with a unicode cwd

    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))

 

 

def _win32_pathjoin(*args):

    return _nt_join(*args).replace('\\', '/')

 

 

def _win32_normpath(path):

    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))

 

 

def _win32_getcwd():

    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))

 

 

def _win32_mkdtemp(*args, **kwargs):

    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))

 

 

def _win32_rename(old, new):

    """We expect to be able to atomically replace 'new' with old.

 

    On win32, if new exists, it must be moved out of the way first,

    and then deleted. 

    """

    try:

        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)

    except OSError, e:

        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY):

            # If we try to rename a non-existant file onto cwd, we get EPERM

            # instead of ENOENT, this will raise ENOENT if the old path

            # doesn't exist

            os.lstat(old)

        raise

 

 

abspath = _posix_abspath

realpath = _posix_realpath

    abspath = _win32_abspath

    realpath = _win32_realpath

    pathjoin = _win32_pathjoin

    normpath = _win32_normpath

    getcwd = _win32_getcwd

    mkdtemp = _win32_mkdtemp

    rename = _win32_rename

def get_terminal_encoding():

    """Find the best encoding for printing to the screen.

 

    This attempts to check both sys.stdout and sys.stdin to see

    what encoding they are in, and if that fails it falls back to

    bzrlib.user_encoding.

    The problem is that on Windows, locale.getpreferredencoding()

    is not the same encoding as that used by the console:

    http://mail.python.org/pipermail/python-list/2003-May/162357.html

 

    On my standard US Windows XP, the preferred encoding is

    cp1252, but the console is cp437

    """

    output_encoding = getattr(sys.stdout, 'encoding', None)

    if not output_encoding:

        input_encoding = getattr(sys.stdin, 'encoding', None)

        if not input_encoding:

            output_encoding = bzrlib.user_encoding

            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)

        else:

            output_encoding = input_encoding

            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)

    else:

        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)

    return output_encoding

 

 

def is_inside_or_parent_of_any(dir_list, fname):

    """True if fname is a child or a parent of any of the given files."""

    for dirname in dir_list:

        if is_inside(dirname, fname) or is_inside(fname, dirname):

            return True

    else:

        return False

 

 

@deprecated_function(zero_nine)

 

_platform_normalizes_filenames = False

if sys.platform == 'darwin':

    _platform_normalizes_filenames = True

 

 

def normalizes_filenames():

    """Return True if this platform normalizes unicode filenames.

 

    Mac OSX does, Windows/Linux do not.

    """

    return _platform_normalizes_filenames

 

 

if _platform_normalizes_filenames:

    def unicode_filename(path):

        """Make sure 'path' is a properly normalized filename.

 

        On platforms where the system normalizes filenames (Mac OSX),

        you can access a file by any path which will normalize

        correctly.

        Internally, bzr only supports NFC/NFKC normalization, since

        that is the standard for XML documents.

        So we return an normalized path, and indicate this has been

        properly normalized.

 

        :return: (path, is_normalized) Return a path which can

                access the file, and whether or not this path is

                normalized.

        """

        return unicodedata.normalize('NFKC', path), True

else:

    def unicode_filename(path):

        """Make sure 'path' is a properly normalized filename.

 

        On platforms where the system does not normalize filenames 

        (Windows, Linux), you have to access a file by its exact path.

        Internally, bzr only supports NFC/NFKC normalization, since

        that is the standard for XML documents.

        So we return the original path, and indicate if this is

        properly normalized.

 

        :return: (path, is_normalized) Return a path which can

                access the file, and whether or not this path is

                normalized.

        """

        return path, unicodedata.normalize('NFKC', path) == path

 

 

 

 

def walkdirs(top, prefix=""):

    """Yield data about all the directories in a tree.

    

    This yields all the data about the contents of a directory at a time.

    After each directory has been yielded, if the caller has mutated the list

    to exclude some directories, they are then not descended into.

    

    The data yielded is of the form:

    [(relpath, basename, kind, lstat, path_from_top), ...]

 

    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 

        allows one to walk a subtree but get paths that are relative to a tree

        rooted higher up.

    :return: an iterator over the dirs.

    """

    lstat = os.lstat

    pending = []

    _directory = _directory_kind

    _listdir = listdir

    pending = [(prefix, "", _directory, None, top)]

    while pending:

        dirblock = []

        currentdir = pending.pop()

        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath

        top = currentdir[4]

        if currentdir[0]:

            relroot = currentdir[0] + '/'

        else:

            relroot = ""

        for name in sorted(_listdir(top)):

            abspath = top + '/' + name

            statvalue = lstat(abspath)

            dirblock.append ((relroot + name, name, file_kind_from_stat_mode(statvalue.st_mode), statvalue, abspath))

        yield dirblock

        # push the user specified dirs from dirblock

        for dir in reversed(dirblock):

            if dir[2] == _directory:

                pending.append(dir)

 

 

def path_prefix_key(path):

    """Generate a prefix-order path key for path.

 

    This can be used to sort paths in the same way that walkdirs does.

    """

    return (dirname(path) , path)

 

 

def compare_paths_prefix_order(path_a, path_b):

    """Compare path_a and path_b to generate the same order walkdirs uses."""

    key_a = path_prefix_key(path_a)

    key_b = path_prefix_key(path_b)

    return cmp(key_a, key_b)