# scmutil.py - Mercurial core utility functions

#

#  Copyright Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from i18n import _

from mercurial.node import nullrev

import util, error, osutil, revset, similar, encoding, phases, parsers

import match as matchmod

import os, errno, re, stat, glob

if os.name == 'nt':

    import scmwindows as scmplatform

else:

    import scmposix as scmplatform

systemrcpath = scmplatform.systemrcpath

userrcpath = scmplatform.userrcpath

def nochangesfound(ui, repo, excluded=None):

    '''Report no changes for push/pull, excluded is None or a list of

    nodes excluded from the push/pull.

    '''

    secretlist = []

    if excluded:

        for n in excluded:

            if n not in repo:

                # discovery should not have included the filtered revision,

                # we have to explicitly exclude it until discovery is cleanup.

                continue

            ctx = repo[n]

            if ctx.phase() >= phases.secret and not ctx.extinct():

                secretlist.append(n)

    if secretlist:

        ui.status(_("no changes found (ignored %d secret changesets)\n")

                  % len(secretlist))

    else:

        ui.status(_("no changes found\n"))

def checknewlabel(repo, lbl, kind):

    if lbl in ['tip', '.', 'null']:

        raise util.Abort(_("the name '%s' is reserved") % lbl)

    for c in (':', '\0', '\n', '\r'):

        if c in lbl:

            raise util.Abort(_("%r cannot be used in a name") % c)

    try:

        int(lbl)

        raise util.Abort(_("a %s cannot have an integer as its name") % kind)

    except ValueError:

        pass

def checkfilename(f):

    '''Check that the filename f is an acceptable filename for a tracked file'''

    if '\r' in f or '\n' in f:

        raise util.Abort(_("'\\n' and '\\r' disallowed in filenames: %r") % f)

def checkportable(ui, f):

    '''Check if filename f is portable and warn or abort depending on config'''

    checkfilename(f)

    abort, warn = checkportabilityalert(ui)

    if abort or warn:

        msg = util.checkwinfilename(f)

        if msg:

            msg = "%s: %r" % (msg, f)

            if abort:

                raise util.Abort(msg)

            ui.warn(_("warning: %s\n") % msg)

def checkportabilityalert(ui):

    '''check if the user's config requests nothing, a warning, or abort for

    non-portable filenames'''

    val = ui.config('ui', 'portablefilenames', 'warn')

    lval = val.lower()

    bval = util.parsebool(val)

    abort = os.name == 'nt' or lval == 'abort'

    warn = bval or lval == 'warn'

    if bval is None and not (warn or abort or lval == 'ignore'):

        raise error.ConfigError(

            _("ui.portablefilenames value is invalid ('%s')") % val)

    return abort, warn

class casecollisionauditor(object):

    def __init__(self, ui, abort, dirstate):

        self._ui = ui

        self._abort = abort

        allfiles = '\0'.join(dirstate._map)

        self._loweredfiles = set(encoding.lower(allfiles).split('\0'))

        self._dirstate = dirstate

        # The purpose of _newfiles is so that we don't complain about

        # case collisions if someone were to call this object with the

        # same filename twice.

        self._newfiles = set()

    def __call__(self, f):

        fl = encoding.lower(f)

        if (fl in self._loweredfiles and f not in self._dirstate and

            f not in self._newfiles):

            msg = _('possible case-folding collision for %s') % f

            if self._abort:

                raise util.Abort(msg)

            self._ui.warn(_("warning: %s\n") % msg)

        self._loweredfiles.add(fl)

        self._newfiles.add(f)

class pathauditor(object):

    '''ensure that a filesystem path contains no banned components.

    the following properties of a path are checked:

    - ends with a directory separator

    - under top-level .hg

    - starts at the root of a windows drive

    - contains ".."

    - traverses a symlink (e.g. a/symlink_here/b)

    - inside a nested repository (a callback can be used to approve

      some nested repositories, e.g., subrepositories)

    '''

    def __init__(self, root, callback=None):

        self.audited = set()

        self.auditeddir = set()

        self.root = root

        self.callback = callback

        if os.path.lexists(root) and not util.checkcase(root):

            self.normcase = util.normcase

        else:

            self.normcase = lambda x: x

    def __call__(self, path):

        '''Check the relative path.

        path may contain a pattern (e.g. foodir/**.txt)'''

        path = util.localpath(path)

        normpath = self.normcase(path)

        if normpath in self.audited:

            return

        # AIX ignores "/" at end of path, others raise EISDIR.

        if util.endswithsep(path):

            raise util.Abort(_("path ends in directory separator: %s") % path)

        parts = util.splitpath(path)

        if (os.path.splitdrive(path)[0]

            or parts[0].lower() in ('.hg', '.hg.', '')

            or os.pardir in parts):

            raise util.Abort(_("path contains illegal component: %s") % path)

        if '.hg' in path.lower():

            lparts = [p.lower() for p in parts]

            for p in '.hg', '.hg.':

                if p in lparts[1:]:

                    pos = lparts.index(p)

                    base = os.path.join(*parts[:pos])

                    raise util.Abort(_("path '%s' is inside nested repo %r")

                                     % (path, base))

        normparts = util.splitpath(normpath)

        assert len(parts) == len(normparts)

        parts.pop()

        normparts.pop()

        prefixes = []

        while parts:

            prefix = os.sep.join(parts)

            normprefix = os.sep.join(normparts)

            if normprefix in self.auditeddir:

                break

            curpath = os.path.join(self.root, prefix)

            try:

                st = os.lstat(curpath)

            except OSError, err:

                # EINVAL can be raised as invalid path syntax under win32.

                # They must be ignored for patterns can be checked too.

                if err.errno not in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):

                    raise

            else:

                if stat.S_ISLNK(st.st_mode):

                    raise util.Abort(

                        _('path %r traverses symbolic link %r')

                        % (path, prefix))

                elif (stat.S_ISDIR(st.st_mode) and

                      os.path.isdir(os.path.join(curpath, '.hg'))):

                    if not self.callback or not self.callback(curpath):

                        raise util.Abort(_("path '%s' is inside nested "

                                           "repo %r")

                                         % (path, prefix))

            prefixes.append(normprefix)

            parts.pop()

            normparts.pop()

        self.audited.add(normpath)

        # only add prefixes to the cache after checking everything: we don't

        # want to add "foo/bar/baz" before checking if there's a "foo/.hg"

        self.auditeddir.update(prefixes)

    def check(self, path):

        try:

            self(path)

            return True

        except (OSError, util.Abort):

            return False

class abstractvfs(object):

    """Abstract base class; cannot be instantiated"""

    def __init__(self, *args, **kwargs):

        '''Prevent instantiation; don't call this from subclasses.'''

        raise NotImplementedError('attempted instantiating ' + str(type(self)))

    def tryread(self, path):

        '''gracefully return an empty string for missing files'''

        try:

            return self.read(path)

        except IOError, inst:

            if inst.errno != errno.ENOENT:

                raise

        return ""

    def read(self, path):

        fp = self(path, 'rb')

        try:

            return fp.read()

        finally:

            fp.close()

    def write(self, path, data):

        fp = self(path, 'wb')

        try:

            return fp.write(data)

        finally:

            fp.close()

    def append(self, path, data):

        fp = self(path, 'ab')

        try:

            return fp.write(data)

        finally:

            fp.close()

    def exists(self, path=None):

        return os.path.exists(self.join(path))

    def isdir(self, path=None):

        return os.path.isdir(self.join(path))

    def islink(self, path=None):

        return os.path.islink(self.join(path))

    def makedir(self, path=None, notindexed=True):

        return util.makedir(self.join(path), notindexed)

    def makedirs(self, path=None, mode=None):

        return util.makedirs(self.join(path), mode)

    def mkdir(self, path=None):

        return os.mkdir(self.join(path))

    def readdir(self, path=None, stat=None, skip=None):

        return osutil.listdir(self.join(path), stat, skip)

    def rename(self, src, dst):

        return util.rename(self.join(src), self.join(dst))

    def stat(self, path=None):

        return os.stat(self.join(path))

class vfs(abstractvfs):

    '''Operate files relative to a base directory

    This class is used to hide the details of COW semantics and

    remote file access from higher level code.

    '''

    def __init__(self, base, audit=True, expandpath=False, realpath=False):

        if expandpath:

            base = util.expandpath(base)

        if realpath:

            base = os.path.realpath(base)

        self.base = base

        self._setmustaudit(audit)

        self.createmode = None

        self._trustnlink = None

    def _getmustaudit(self):

        return self._audit

    def _setmustaudit(self, onoff):

        self._audit = onoff

        if onoff:

            self.audit = pathauditor(self.base)

        else:

            self.audit = util.always

    mustaudit = property(_getmustaudit, _setmustaudit)

    @util.propertycache

    def _cansymlink(self):

        return util.checklink(self.base)

    @util.propertycache

    def _chmod(self):

        return util.checkexec(self.base)

    def _fixfilemode(self, name):

        if self.createmode is None or not self._chmod:

            return

        os.chmod(name, self.createmode & 0666)

    def __call__(self, path, mode="r", text=False, atomictemp=False):

        if self._audit:

            r = util.checkosfilename(path)

            if r:

                raise util.Abort("%s: %r" % (r, path))

        self.audit(path)

        f = self.join(path)

        if not text and "b" not in mode:

            mode += "b" # for that other OS

        nlink = -1

        if mode not in ('r', 'rb'):

            dirname, basename = util.split(f)

            # If basename is empty, then the path is malformed because it points

            # to a directory. Let the posixfile() call below raise IOError.

            if basename:

                if atomictemp:

                    util.ensuredirs(dirname, self.createmode)

                    return util.atomictempfile(f, mode, self.createmode)

                try:

                    if 'w' in mode:

                        util.unlink(f)

                        nlink = 0

                    else:

                        # nlinks() may behave differently for files on Windows

                        # shares if the file is open.

                        fd = util.posixfile(f)

                        nlink = util.nlinks(f)

                        if nlink < 1:

                            nlink = 2 # force mktempcopy (issue1922)

                        fd.close()

                except (OSError, IOError), e:

                    if e.errno != errno.ENOENT:

                        raise

                    nlink = 0

                    util.ensuredirs(dirname, self.createmode)

                if nlink > 0:

                    if self._trustnlink is None:

                        self._trustnlink = nlink > 1 or util.checknlink(f)

                    if nlink > 1 or not self._trustnlink:

                        util.rename(util.mktempcopy(f), f)

        fp = util.posixfile(f, mode)

        if nlink == 0:

            self._fixfilemode(f)

        return fp

    def symlink(self, src, dst):

        self.audit(dst)

        linkname = self.join(dst)

        try:

            os.unlink(linkname)

        except OSError: