# 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 __future__ import absolute_import

import errno

import glob

import hashlib

import os

import re

import subprocess

import weakref

from .i18n import _

from .node import (

    bin,

    hex,

    nullid,

    nullrev,

    short,

    wdirid,

    wdirrev,

)

from . import (

    encoding,

    error,

    match as matchmod,

    obsolete,

    obsutil,

    pathutil,

    phases,

    policy,

    pycompat,

    revsetlang,

    similar,

    smartset,

    url,

    util,

    vfs,

)

from .utils import (

    procutil,

    stringutil,

)

if pycompat.iswindows:

    from . import scmwindows as scmplatform

else:

    from . import scmposix as scmplatform

parsers = policy.importmod(r'parsers')

termsize = scmplatform.termsize

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 ((r'<status modified=%s, added=%s, removed=%s, deleted=%s, '

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

                tuple(pycompat.sysstr(stringutil.pprint(v)) for v in 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:

            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 callcatch(ui, func):

    """call func() with global exception handling

    return func() if no exception happens. otherwise do some error handling

    and return an exit code accordingly. does not handle all exceptions.

    """

    try:

        try:

            return func()

        except: # re-raises

            ui.traceback()

            raise

    # Global exception handling, alphabetically

    # Mercurial-specific first, followed by built-in and library exceptions

    except error.LockHeld as inst:

        if inst.errno == errno.ETIMEDOUT:

            reason = _('timed out waiting for lock held by %r') % (

                pycompat.bytestr(inst.locker))

        else:

            reason = _('lock held by %r') % inst.locker

        ui.error(_("abort: %s: %s\n") % (

            inst.desc or stringutil.forcebytestr(inst.filename), reason))

        if not inst.locker:

            ui.error(_("(lock might be very busy)\n"))

    except error.LockUnavailable as inst:

        ui.error(_("abort: could not lock %s: %s\n") %

                 (inst.desc or stringutil.forcebytestr(inst.filename),

                  encoding.strtolocal(inst.strerror)))

    except error.OutOfBandError as inst:

        if inst.args:

            msg = _("abort: remote error:\n")

        else:

            msg = _("abort: remote error\n")

        ui.error(msg)

        if inst.args:

            ui.error(''.join(inst.args))

        if inst.hint:

            ui.error('(%s)\n' % inst.hint)

    except error.RepoError as inst:

        ui.error(_("abort: %s!\n") % inst)

        if inst.hint:

            ui.error(_("(%s)\n") % inst.hint)

    except error.ResponseError as inst:

        ui.error(_("abort: %s") % inst.args[0])

        msg = inst.args[1]

        if isinstance(msg, type(u'')):

            msg = pycompat.sysbytes(msg)

        if not isinstance(msg, bytes):

            ui.error(" %r\n" % (msg,))

        elif not msg:

            ui.error(_(" empty string\n"))

        else:

            ui.error("\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg)))

    except error.CensoredNodeError as inst:

        ui.error(_("abort: file censored %s!\n") % inst)

    except error.StorageError as inst:

        ui.error(_("abort: %s!\n") % inst)

        if inst.hint:

            ui.error(_("(%s)\n") % inst.hint)

    except error.InterventionRequired as inst:

        ui.error("%s\n" % inst)

        if inst.hint:

            ui.error(_("(%s)\n") % inst.hint)

        return 1

    except error.WdirUnsupported:

        ui.error(_("abort: working directory revision cannot be specified\n"))

    except error.Abort as inst:

        ui.error(_("abort: %s\n") % inst)

        if inst.hint:

            ui.error(_("(%s)\n") % inst.hint)

    except ImportError as inst:

        ui.error(_("abort: %s!\n") % stringutil.forcebytestr(inst))

        m = stringutil.forcebytestr(inst).split()[-1]

        if m in "mpatch bdiff".split():

            ui.error(_("(did you forget to compile extensions?)\n"))

        elif m in "zlib".split():

            ui.error(_("(is your Python install correct?)\n"))

    except (IOError, OSError) as inst:

        if util.safehasattr(inst, "code"): # HTTPError

            ui.error(_("abort: %s\n") % stringutil.forcebytestr(inst))

        elif util.safehasattr(inst, "reason"): # URLError or SSLError

            try: # usually it is in the form (errno, strerror)

                reason = inst.reason.args[1]

            except (AttributeError, IndexError):

                # it might be anything, for example a string

                reason = inst.reason

            if isinstance(reason, pycompat.unicode):

                # SSLError of Python 2.7.9 contains a unicode

                reason = encoding.unitolocal(reason)

            ui.error(_("abort: error: %s\n") % reason)

        elif (util.safehasattr(inst, "args")

              and inst.args and inst.args[0] == errno.EPIPE):

            pass

        elif getattr(inst, "strerror", None): # common IOError or OSError

            if getattr(inst, "filename", None) is not None:

                ui.error(_("abort: %s: '%s'\n") % (

                    encoding.strtolocal(inst.strerror),

                    stringutil.forcebytestr(inst.filename)))

            else:

                ui.error(_("abort: %s\n") % encoding.strtolocal(inst.strerror))

        else: # suspicious IOError

            raise

    except MemoryError:

        ui.error(_("abort: out of memory\n"))

    except SystemExit as inst:

        # Commands shouldn't sys.exit directly, but give a return code.

        # Just in case catch this and and pass exit code to caller.

        return inst.code

    return -1

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") % pycompat.bytestr(c))

    try:

        int(lbl)

        raise error.Abort(_("cannot use an integer as a name"))

    except ValueError:

        pass

    if lbl.strip() != lbl:

        raise error.Abort(_("leading or trailing whitespace in name %r") % lbl)

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

                          % pycompat.bytestr(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: %s" % (msg, procutil.shellquote(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')

    lval = val.lower()

    bval = stringutil.parsebool(val)

    abort = pycompat.iswindows 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 = hashlib.sha1()

        for rev in revs:

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

        key = s.digest()

    return key

def walkrepos(path, followsym=False, seen_dirs=None, recurse=False):