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

import posixpath

import re

import subprocess

import weakref

from .i18n import _

from .node import (

    bin,

    hex,

    nullid,

    nullrev,

    short,

    wdirid,

    wdirrev,

)

from .pycompat import getattr

from .thirdparty import attr

from . import (

    copies as copiesmod,

    encoding,

    error,

    match as matchmod,

    obsolete,

    obsutil,

    pathutil,

    phases,

    policy,

    pycompat,

    requirements as requirementsmod,

    revsetlang,

    similar,

    smartset,

    url,

    util,

    vfs,

)

from .utils import (

    hashutil,

    procutil,

    stringutil,

)

if pycompat.iswindows:

    from . import scmwindows as scmplatform

else:

    from . import scmposix as scmplatform

parsers = policy.importmod('parsers')

rustrevlog = policy.importrust('revlog')

termsize = scmplatform.termsize

@attr.s(slots=True, repr=False)

class status(object):

    '''Struct with a list of files per status.

    The 'deleted', 'unknown' and 'ignored' properties are only

    relevant to the working copy.

    '''

    modified = attr.ib(default=attr.Factory(list))

    added = attr.ib(default=attr.Factory(list))

    removed = attr.ib(default=attr.Factory(list))

    deleted = attr.ib(default=attr.Factory(list))

    unknown = attr.ib(default=attr.Factory(list))

    ignored = attr.ib(default=attr.Factory(list))

    clean = attr.ib(default=attr.Factory(list))

    def __iter__(self):

        yield self.modified

        yield self.added

        yield self.removed

        yield self.deleted

        yield self.unknown

        yield self.ignored

        yield self.clean

    def __repr__(self):

        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(pycompat.iteritems(subpaths)):

        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(

            _(b"no changes found (ignored %d secret changesets)\n")

            % len(secretlist)

        )

    else:

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

def formatparse(write, inst):

    if inst.location is not None:

        write(

            _(b"hg: parse error at %s: %s\n")

            % (pycompat.bytestr(inst.location), inst.message)

        )

    else:

        write(_(b"hg: parse error: %s\n") % inst.message)

        write(_(b"(%s)\n") % inst.hint)

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.

    """

    coarse_exit_code = -1

    detailed_exit_code = -1

    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:

        detailed_exit_code = 20

        if inst.errno == errno.ETIMEDOUT:

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

                pycompat.bytestr(inst.locker)

            )

        else:

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

        ui.error(

            _(b"abort: %s: %s\n")

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

        )

        if not inst.locker:

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

    except error.LockUnavailable as inst:

        detailed_exit_code = 20

        ui.error(

            _(b"abort: could not lock %s: %s\n")

            % (

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

                encoding.strtolocal(inst.strerror),

            )

        )

    except error.OutOfBandError as inst:

        detailed_exit_code = 100

        if inst.args:

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

        else:

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

        ui.error(msg)

        if inst.args:

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

        if inst.hint:

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

    except error.RepoError as inst:

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

        if inst.hint:

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

    except error.ResponseError as inst:

        ui.error(_(b"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(b" %r\n" % (msg,))

        elif not msg:

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

        else:

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

    except error.CensoredNodeError as inst:

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

    except error.StorageError as inst:

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

        if inst.hint:

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

    except error.InterventionRequired as inst:

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

        if inst.hint:

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

        detailed_exit_code = 240

        coarse_exit_code = 1

    except error.WdirUnsupported:

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

    except error.Abort as inst:

        if isinstance(inst, error.InputError):

            detailed_exit_code = 10

        elif isinstance(inst, error.StateError):

            detailed_exit_code = 20

        elif isinstance(inst, error.ConfigError):

            detailed_exit_code = 30

        elif isinstance(inst, error.CanceledError):

            detailed_exit_code = 250

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

        if inst.hint:

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

    except error.WorkerError as inst:

        # Don't print a message -- the worker already should have

        return inst.status_code

    except ImportError as inst:

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

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

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

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

        elif m in b"zlib".split():

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

    except util.urlerr.httperror as inst:

        detailed_exit_code = 100

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

    except util.urlerr.urlerror as inst:

        detailed_exit_code = 100

        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(_(b"abort: error: %s\n") % stringutil.forcebytestr(reason))

    except (IOError, OSError) as inst:

        if (

            util.safehasattr(inst, b"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(

                    _(b"abort: %s: '%s'\n")

                    % (

                        encoding.strtolocal(inst.strerror),

                        stringutil.forcebytestr(inst.filename),

                    )

                )

            else:

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

        else:  # suspicious IOError

            raise

    except MemoryError:

        ui.error(_(b"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.

        detailed_exit_code = 254

        coarse_exit_code = inst.code

    if ui.configbool(b'ui', b'detailed-exit-code'):

        return detailed_exit_code

    else:

        return coarse_exit_code

def checknewlabel(repo, lbl, kind):

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

    # It makes strings difficult to translate.

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

        raise error.InputError(_(b"the name '%s' is reserved") % lbl)

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

        if c in lbl:

            raise error.InputError(

                _(b"%r cannot be used in a name") % pycompat.bytestr(c)

            )

    try:

        int(lbl)

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

    except ValueError:

        pass

    if lbl.strip() != lbl:

        raise error.InputError(

            _(b"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 b'\r' in f or b'\n' in f:

        raise error.InputError(

            _(b"'\\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 = b"%s: %s" % (msg, procutil.shellquote(f))

            if abort:

                raise error.InputError(msg)

            ui.warn(_(b"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(b'ui', b'portablefilenames')

    lval = val.lower()

    bval = stringutil.parsebool(val)

    abort = pycompat.iswindows or lval == b'abort'

    warn = bval or lval == b'warn'

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

        raise error.ConfigError(

            _(b"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 = b'\0'.join(dirstate)

        self._loweredfiles = set(encoding.lower(allfiles).split(b'\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 = _(b'possible case-folding collision for %s') % f

            if self._abort:

                raise error.Abort(msg)

            self._ui.warn(_(b"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 = cl._filteredrevs_hashcache.get(maxrev)

    if not key:

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

        if revs:

            s = hashutil.sha1()

            for rev in revs:

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

            key = s.digest()

            cl._filteredrevs_hashcache[maxrev] = key

    return key

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

    '''yield every hg repository under path, always recursively.

    The recurse flag will only control recursion into repo working dirs'''

    def errhandler(err):

        if err.filename == path:

            raise err

    samestat = getattr(os.path, 'samestat', None)

    if followsym and samestat is not None:

        def adddir(dirlst, dirname):

            dirstat = os.stat(dirname)

            match = any(samestat(dirstat, lstdirstat) for lstdirstat in dirlst)

            if not match:

                dirlst.append(dirstat)

            return not match

    else:

        followsym = False

    if (seen_dirs is None) and followsym:

        seen_dirs = []

        adddir(seen_dirs, path)

    for root, dirs, files in os.walk(path, topdown=True, onerror=errhandler):

        dirs.sort()

        if b'.hg' in dirs:

            yield root  # found a repository

            qroot = os.path.join(root, b'.hg', b'patches')

            if os.path.isdir(os.path.join(qroot, b'.hg')):

                yield qroot  # we have a patch queue repo here

            if recurse:

                # avoid recursing inside the .hg directory

                dirs.remove(b'.hg')

            else:

                dirs[:] = []  # don't descend further

        elif followsym:

            newdirs = []

            for d in dirs:

                fname = os.path.join(root, d)

                if adddir(seen_dirs, fname):

                    if os.path.islink(fname):

                        for hgname in walkrepos(fname, True, seen_dirs):

                            yield hgname

                    else:

                        newdirs.append(d)

            dirs[:] = newdirs

def binnode(ctx):

    """Return binary node id for a given basectx"""

    node = ctx.node()

    if node is None:

        return wdirid

    return node

def intrev(ctx):

    """Return integer for a given basectx that can be used in comparison or

    arithmetic operation"""

    rev = ctx.rev()

    if rev is None:

        return wdirrev

    return rev