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

if os.name == 'nt':

else:

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

    missing = set()

    for subpath in ctx2.substate:

        if subpath not in ctx1.substate:

            del subpaths[subpath]

            missing.add(subpath)

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

        yield subpath, ctx.sub(subpath)

    # Yield an empty subrepo based on ctx1 for anything only in ctx2.  That way,

    # status and diff will have an accurate result when it does

    # 'sub.{status|diff}(rev2)'.  Otherwise, the ctx2 subrepo is compared

    # against itself.

    for subpath in missing:

        yield subpath, ctx2.nullsub(subpath, ctx1)

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 error.Abort(_("the name '%s' is reserved") % lbl)

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

        if c in lbl:

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

    try:

        int(lbl)

        raise error.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 error.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 error.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 error.Abort(msg)

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

        self._loweredfiles.add(fl)

        self._newfiles.add(f)

def filteredhash(repo, maxrev):

    """build hash of filtered revisions in the current repoview.

    Multiple caches perform up-to-date validation by checking that the

    tiprev and tipnode stored in the cache file match the current repository.

    However, this is not sufficient for validating repoviews because the set

    of revisions in the view may change without the repository tiprev and

    tipnode changing.

    This function hashes all the revs filtered from the view and returns

    that SHA-1 digest.

    """

    cl = repo.changelog

    if not cl.filteredrevs:

        return None

    key = None

    revs = sorted(r for r in cl.filteredrevs if r <= maxrev)

    if revs:

        s = util.sha1()

        for rev in revs:

            s.update('%s;' % rev)

        key = s.digest()

    return key

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 as inst:

            if inst.errno != errno.ENOENT:

                raise

        return ""

    def tryreadlines(self, path, mode='rb'):

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

        try:

            return self.readlines(path, mode=mode)

        except IOError as inst:

            if inst.errno != errno.ENOENT:

                raise

        return []

    def open(self, path, mode="r", text=False, atomictemp=False,

             notindexed=False):

        '''Open ``path`` file, which is relative to vfs root.

        Newly created directories are marked as "not to be indexed by

        the content indexing service", if ``notindexed`` is specified

        for "write" mode access.

        '''

        self.open = self.__call__

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

    def read(self, path):

        fp = self(path, 'rb')

        try:

            return fp.read()

        finally:

            fp.close()

    def readlines(self, path, mode='rb'):

        fp = self(path, mode=mode)

        try:

            return fp.readlines()

        finally:

            fp.close()

    def write(self, path, data):

        fp = self(path, 'wb')

        try:

            return fp.write(data)

        finally:

            fp.close()

    def writelines(self, path, data, mode='wb', notindexed=False):

        fp = self(path, mode=mode, notindexed=notindexed)

        try:

            return fp.writelines(data)

        finally:

            fp.close()

    def append(self, path, data):

        fp = self(path, 'ab')

        try:

            return fp.write(data)

        finally:

            fp.close()

    def basename(self, path):

        """return base element of a path (as os.path.basename would do)

        This exists to allow handling of strange encoding if needed."""

        return os.path.basename(path)

    def chmod(self, path, mode):

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

    def dirname(self, path):

        """return dirname element of a path (as os.path.dirname would do)

        This exists to allow handling of strange encoding if needed."""

        return os.path.dirname(path)

    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 reljoin(self, *paths):

        """join various elements of a path together (as os.path.join would do)

        The vfs base is not injected so that path stay relative. This exists

        to allow handling of strange encoding if needed."""

        return os.path.join(*paths)

    def split(self, path):

        """split top-most element of a path (as os.path.split would do)

        This exists to allow handling of strange encoding if needed."""

        return os.path.split(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):