# error.py - Mercurial exceptions

#

# Copyright 2005-2008 Olivia Mackall <olivia@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.

"""Mercurial exceptions.

This allows us to catch exceptions at higher levels without forcing

imports.

"""

from __future__ import absolute_import

import difflib

# Do not import anything but pycompat here, please

from . import pycompat

if pycompat.TYPE_CHECKING:

    from typing import (

        Any,

        AnyStr,

        Iterable,

        List,

        Optional,

        Sequence,

        Union,

    )

def _tobytes(exc):

    # type: (...) -> bytes

    """Byte-stringify exception in the same way as BaseException_str()"""

    if not exc.args:

        return b''

    if len(exc.args) == 1:

        return pycompat.bytestr(exc.args[0])

    return b'(%s)' % b', '.join(b"'%s'" % pycompat.bytestr(a) for a in exc.args)

class Hint(object):

    """Mix-in to provide a hint of an error

    This should come first in the inheritance list to consume a hint and

    pass remaining arguments to the exception class.

    """

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

        self.hint = kw.pop('hint', None)  # type: Optional[bytes]

        super(Hint, self).__init__(*args, **kw)

class Error(Hint, Exception):

    """Base class for Mercurial errors."""

    coarse_exit_code = None

    detailed_exit_code = None

    def __init__(self, message, hint=None):

        # type: (bytes, Optional[bytes]) -> None

        self.message = message

        self.hint = hint

        # Pass the message into the Exception constructor to help extensions

        # that look for exc.args[0].

        Exception.__init__(self, message)

    def __bytes__(self):

        return self.message

    if pycompat.ispy3:

        def __str__(self):

            # type: () -> str

            # the output would be unreadable if the message was translated,

            # but do not replace it with encoding.strfromlocal(), which

            # may raise another exception.

            return pycompat.sysstr(self.__bytes__())

    def format(self):

        # type: () -> bytes

        from .i18n import _

        message = _(b"abort: %s\n") % self.message

        if self.hint:

            message += _(b"(%s)\n") % self.hint

        return message

class Abort(Error):

    """Raised if a command needs to print an error and exit."""

class StorageError(Error):

    """Raised when an error occurs in a storage layer.

    Usually subclassed by a storage-specific exception.

    """

    detailed_exit_code = 50

class RevlogError(StorageError):

    pass

class SidedataHashError(RevlogError):

    def __init__(self, key, expected, got):

        # type: (int, bytes, bytes) -> None

        self.hint = None

        self.sidedatakey = key

        self.expecteddigest = expected

        self.actualdigest = got

class FilteredIndexError(IndexError):

    __bytes__ = _tobytes

class LookupError(RevlogError, KeyError):

    def __init__(self, name, index, message):

        # type: (bytes, bytes, bytes) -> None

        self.name = name

        self.index = index

        # this can't be called 'message' because at least some installs of

        # Python 2.6+ complain about the 'message' property being deprecated

        self.lookupmessage = message

        if isinstance(name, bytes) and len(name) == 20:

            from .node import hex

            name = hex(name)

        # if name is a binary node, it can be None

        RevlogError.__init__(

            self, b'%s@%s: %s' % (index, pycompat.bytestr(name), message)

        )

    def __bytes__(self):

        return RevlogError.__bytes__(self)

    def __str__(self):

        return RevlogError.__str__(self)

class AmbiguousPrefixLookupError(LookupError):

    pass

class FilteredLookupError(LookupError):

    pass

class ManifestLookupError(LookupError):

    pass

class CommandError(Exception):

    """Exception raised on errors in parsing the command line."""

    def __init__(self, command, message):

        # type: (bytes, bytes) -> None

        self.command = command

        self.message = message

        super(CommandError, self).__init__()

    __bytes__ = _tobytes

class UnknownCommand(Exception):

    """Exception raised if command is not in the command table."""

    def __init__(self, command, all_commands=None):

        # type: (bytes, Optional[List[bytes]]) -> None

        self.command = command

        self.all_commands = all_commands

        super(UnknownCommand, self).__init__()

    __bytes__ = _tobytes

class AmbiguousCommand(Exception):

    """Exception raised if command shortcut matches more than one command."""

    def __init__(self, prefix, matches):

        # type: (bytes, List[bytes]) -> None

        self.prefix = prefix

        self.matches = matches

        super(AmbiguousCommand, self).__init__()

    __bytes__ = _tobytes

class WorkerError(Exception):

    """Exception raised when a worker process dies."""

    def __init__(self, status_code):

        # type: (int) -> None

        self.status_code = status_code

        # Pass status code to superclass just so it becomes part of __bytes__

        super(WorkerError, self).__init__(status_code)

    __bytes__ = _tobytes

class InterventionRequired(Abort):

    """Exception raised when a command requires human intervention."""

    coarse_exit_code = 1

    detailed_exit_code = 240

    def format(self):

        # type: () -> bytes

        from .i18n import _

        message = _(b"%s\n") % self.message

        if self.hint:

            message += _(b"(%s)\n") % self.hint

        return message

class ConflictResolutionRequired(InterventionRequired):

    """Exception raised when a continuable command required merge conflict resolution."""

    def __init__(self, opname):

        # type: (bytes) -> None

        from .i18n import _

        self.opname = opname

        InterventionRequired.__init__(

            self,

            _(

                b"unresolved conflicts (see 'hg resolve', then 'hg %s --continue')"

            )

            % opname,

        )

class InputError(Abort):

    """Indicates that the user made an error in their input.

    Examples: Invalid command, invalid flags, invalid revision.

    """

    detailed_exit_code = 10

class StateError(Abort):

    """Indicates that the operation might work if retried in a different state.

    Examples: Unresolved merge conflicts, unfinished operations.

    """

    detailed_exit_code = 20

class CanceledError(Abort):

    """Indicates that the user canceled the operation.

    Examples: Close commit editor with error status, quit chistedit.

    """

    detailed_exit_code = 250

class SecurityError(Abort):

    """Indicates that some aspect of security failed.

    Examples: Bad server credentials, expired local credentials for network

    filesystem, mismatched GPG signature, DoS protection.

    """

    detailed_exit_code = 150

class HookLoadError(Abort):

    """raised when loading a hook fails, aborting an operation

    Exists to allow more specialized catching."""

class HookAbort(Abort):

    """raised when a validation hook fails, aborting an operation

    Exists to allow more specialized catching."""

    detailed_exit_code = 40

class ConfigError(Abort):

    """Exception raised when parsing config files"""

    detailed_exit_code = 30

    def __init__(self, message, location=None, hint=None):

        # type: (bytes, Optional[bytes], Optional[bytes]) -> None

        super(ConfigError, self).__init__(message, hint=hint)

        self.location = location

    def format(self):

        # type: () -> bytes

        from .i18n import _

        if self.location is not None:

            message = _(b"config error at %s: %s\n") % (

                pycompat.bytestr(self.location),

                self.message,

            )

        else:

            message = _(b"config error: %s\n") % self.message

        if self.hint:

            message += _(b"(%s)\n") % self.hint

        return message

class UpdateAbort(Abort):

    """Raised when an update is aborted for destination issue"""

class MergeDestAbort(Abort):

    """Raised when an update is aborted for destination issues"""

class NoMergeDestAbort(MergeDestAbort):

    """Raised when an update is aborted because there is nothing to merge"""

class ManyMergeDestAbort(MergeDestAbort):

    """Raised when an update is aborted because destination is ambiguous"""

class ResponseExpected(Abort):

    """Raised when an EOF is received for a prompt"""

    def __init__(self):

        from .i18n import _

        Abort.__init__(self, _(b'response expected'))

class RemoteError(Abort):

    """Exception raised when interacting with a remote repo fails"""

    detailed_exit_code = 100

class OutOfBandError(RemoteError):

    """Exception raised when a remote repo reports failure"""

    def __init__(self, message=None, hint=None):

        # type: (Optional[bytes], Optional[bytes]) -> None

        from .i18n import _

        if message:

            # Abort.format() adds a trailing newline

            message = _(b"remote error:\n%s") % message.rstrip(b'\n')

        else:

            message = _(b"remote error")

        super(OutOfBandError, self).__init__(message, hint=hint)

class ParseError(Abort):

    """Raised when parsing config files and {rev,file}sets (msg[, pos])"""

    detailed_exit_code = 10

    def __init__(self, message, location=None, hint=None):

        # type: (bytes, Optional[Union[bytes, int]], Optional[bytes]) -> None

        super(ParseError, self).__init__(message, hint=hint)

        self.location = location

    def format(self):

        # type: () -> bytes

        from .i18n import _

        if self.location is not None:

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

                pycompat.bytestr(self.location),

                self.message,

            )

        else:

            message = _(b"hg: parse error: %s\n") % self.message

        if self.hint:

            message += _(b"(%s)\n") % self.hint

        return message

class PatchError(Exception):

    __bytes__ = _tobytes

class PatchParseError(PatchError):

    __bytes__ = _tobytes

class PatchApplicationError(PatchError):

    __bytes__ = _tobytes

def getsimilar(symbols, value):

    # type: (Iterable[bytes], bytes) -> List[bytes]

    sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio()

    # The cutoff for similarity here is pretty arbitrary. It should

    # probably be investigated and tweaked.

    return [s for s in symbols if sim(s) > 0.6]