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

import match as matchmod

import os, errno, re, glob, tempfile

if os.name == 'nt':

    import scmwindows as scmplatform

else:

    import scmposix as scmplatform

systemrcpath = scmplatform.systemrcpath

userrcpath = scmplatform.userrcpath

class status(tuple):

    '''Named tuple with a list of files per status. The 'deleted', 'unknown'

       and 'ignored' properties are only relevant to the working copy.

    '''

    __slots__ = ()

    def __new__(cls, modified, added, removed, deleted, unknown, ignored,

                clean):

        return tuple.__new__(cls, (modified, added, removed, deleted, unknown,

                                   ignored, clean))

    @property

    def modified(self):

        '''files that have been modified'''

        return self[0]

    @property

    def added(self):

        '''files that have been added'''

        return self[1]

    @property

    def removed(self):

        '''files that have been removed'''

        return self[2]

    @property

    def deleted(self):

        '''files that are in the dirstate, but have been deleted from the

           working copy (aka "missing")

        '''

        return self[3]

    @property

    def unknown(self):

        '''files not in the dirstate that are not ignored'''

        return self[4]

    @property

    def ignored(self):

        '''files not in the dirstate that are ignored (by _dirignore())'''

        return self[5]

    @property

    def clean(self):

        '''files that have not been modified'''

        return self[6]

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

        return (('<status modified=%r, added=%r, removed=%r, deleted=%r, '

                 'unknown=%r, ignored=%r, clean=%r>') % self)

def itersubrepos(ctx1, ctx2):

    """find subrepos in ctx1 or ctx2"""

    # Create a (subpath, ctx) mapping where we prefer subpaths from

    # ctx1. The subpaths from ctx2 are important when the .hgsub file

    # has been modified (in ctx2) but not yet committed (in ctx1).

    subpaths = dict.fromkeys(ctx2.substate, ctx2)

    subpaths.update(dict.fromkeys(ctx1.substate, ctx1))

    for subpath, ctx in sorted(subpaths.iteritems()):

        yield subpath, ctx.sub(subpath)

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

    # Do not use the "kind" parameter in ui output.

    # It makes strings difficult to translate.

    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(_("cannot use an integer as a name"))

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

        if f in self._newfiles:

            return

        fl = encoding.lower(f)

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

            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 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 open(self, path, mode="r", text=False, atomictemp=False):

        self.open = self.__call__

        return self.__call__(path, mode, text, atomictemp)

    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 chmod(self, path, mode):

        return os.chmod(self.join(path), mode)

    def exists(self, path=None):

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

    def fstat(self, fp):

        return util.fstat(fp)

    def isdir(self, path=None):

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

    def isfile(self, path=None):

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

    def islink(self, path=None):

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

    def lexists(self, path=None):

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

    def lstat(self, path=None):

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

    def listdir(self, path=None):

        return os.listdir(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 makelock(self, info, path):

        return util.makelock(info, self.join(path))

    def mkdir(self, path=None):

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

    def mkstemp(self, suffix='', prefix='tmp', dir=None, text=False):

        fd, name = tempfile.mkstemp(suffix=suffix, prefix=prefix,

                                    dir=self.join(dir), text=text)

        dname, fname = util.split(name)

        if dir:

            return fd, os.path.join(dir, fname)

        else:

            return fd, fname

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

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

    def readlock(self, path):

        return util.readlock(self.join(path))

    def rename(self, src, dst):

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

    def readlink(self, path):

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

    def setflags(self, path, l, x):

        return util.setflags(self.join(path), l, x)

    def stat(self, path=None):

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

    def unlink(self, path=None):

        return util.unlink(self.join(path))

    def unlinkpath(self, path=None, ignoremissing=False):

        return util.unlinkpath(self.join(path), ignoremissing)

    def utime(self, path=None, t=None):

        return os.utime(self.join(path), t)

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 = pathutil.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: