~bzr-pqm/bzr/bzr.dev

from os import listdir

from shutil import copyfile

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

                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)

import unicodedata

from ntpath import (abspath as _nt_abspath,

                    join as _nt_join,

                    normpath as _nt_normpath,

                    realpath as _nt_realpath,

                    )

_directory_kind = 'directory'

 

    stat.S_IFDIR:_directory_kind,

 

 

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.

    """

        return _formats[stat_mode & 0170000]

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:

 

# 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):

    return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)

    # jam 20060426 This is another possibility which mimics 

    # os.path.abspath, only uses unicode characters instead

    # if not os.path.isabs(path):

    #     return os.path.join(os.getcwdu(), path)

    # return path

 

 

def _posix_realpath(path):

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

 

 

def _win32_abspath(path):

    return _nt_abspath(path.encode(_fs_enc)).decode(_fs_enc).replace('\\', '/')

 

 

def _win32_realpath(path):

    return _nt_realpath(path.encode(_fs_enc)).decode(_fs_enc).replace('\\', '/')

 

 

def _win32_pathjoin(*args):

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

 

 

def _win32_normpath(path):

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

 

 

def _win32_getcwd():

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

 

 

def _win32_mkdtemp(*args, **kwargs):

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

 

 

def _win32_rename(old, new):

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

 

 

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 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

 

 

 

_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)