# parsers.py - Python implementation of parsers.c

#

# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others

#

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

import struct

import zlib

from ..node import (

    nullrev,

    sha1nodeconstants,

)

from ..thirdparty import attr

from .. import (

    error,

    pycompat,

    revlogutils,

    util,

)

from ..revlogutils import nodemap as nodemaputil

from ..revlogutils import constants as revlog_constants

stringio = pycompat.bytesio

_pack = struct.pack

_unpack = struct.unpack

_compress = zlib.compress

_decompress = zlib.decompress

# a special value used internally for `size` if the file come from the other parent

FROM_P2 = -2

# a special value used internally for `size` if the file is modified/merged/added

NONNORMAL = -1

# a special value used internally for `time` if the time is ambigeous

AMBIGUOUS_TIME = -1

# Bits of the `flags` byte inside a node in the file format

DIRSTATE_V2_WDIR_TRACKED = 1 << 0

DIRSTATE_V2_P1_TRACKED = 1 << 1

DIRSTATE_V2_P2_INFO = 1 << 2

DIRSTATE_V2_MODE_EXEC_PERM = 1 << 3

DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 4

DIRSTATE_V2_HAS_FALLBACK_EXEC = 1 << 5

DIRSTATE_V2_FALLBACK_EXEC = 1 << 6

DIRSTATE_V2_HAS_FALLBACK_SYMLINK = 1 << 7

DIRSTATE_V2_FALLBACK_SYMLINK = 1 << 8

DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED = 1 << 9

DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 10

DIRSTATE_V2_HAS_MTIME = 1 << 11

DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS = 1 << 12

DIRSTATE_V2_DIRECTORY = 1 << 13

DIRSTATE_V2_ALL_UNKNOWN_RECORDED = 1 << 14

DIRSTATE_V2_ALL_IGNORED_RECORDED = 1 << 15

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

class DirstateItem(object):

    """represent a dirstate entry

    It hold multiple attributes

    # about file tracking

    - wc_tracked: is the file tracked by the working copy

    - p1_tracked: is the file tracked in working copy first parent

    - p2_info: the file has been involved in some merge operation. Either

               because it was actually merged, or because the p2 version was

               ahead, or because some rename moved it there. In either case

               `hg status` will want it displayed as modified.

    # about the file state expected from p1 manifest:

    - mode: the file mode in p1

    - size: the file size in p1

    These value can be set to None, which mean we don't have a meaningful value

    to compare with. Either because we don't really care about them as there

    `status` is known without having to look at the disk or because we don't

    know these right now and a full comparison will be needed to find out if

    the file is clean.

    # about the file state on disk last time we saw it:

    - mtime: the last known clean mtime for the file.

    This value can be set to None if no cachable state exist. Either because we

    do not care (see previous section) or because we could not cache something

    yet.

    """

    _wc_tracked = attr.ib()

    _p1_tracked = attr.ib()

    _p2_info = attr.ib()

    _mode = attr.ib()

    _size = attr.ib()

    _mtime_s = attr.ib()

    _mtime_ns = attr.ib()

    _fallback_exec = attr.ib()

    _fallback_symlink = attr.ib()

    _mtime_second_ambiguous = attr.ib()

    def __init__(

        self,

        wc_tracked=False,

        p1_tracked=False,

        p2_info=False,

        has_meaningful_data=True,

        has_meaningful_mtime=True,

        parentfiledata=None,

        fallback_exec=None,

        fallback_symlink=None,

    ):

        self._wc_tracked = wc_tracked

        self._p1_tracked = p1_tracked

        self._p2_info = p2_info

        self._fallback_exec = fallback_exec

        self._fallback_symlink = fallback_symlink

        self._mode = None

        self._size = None

        self._mtime_s = None

        self._mtime_ns = None

        self._mtime_second_ambiguous = False

        if parentfiledata is None:

            has_meaningful_mtime = False

            has_meaningful_data = False

        elif parentfiledata[2] is None:

            has_meaningful_mtime = False

        if has_meaningful_data:

            self._mode = parentfiledata[0]

            self._size = parentfiledata[1]

        if has_meaningful_mtime:

            (

                self._mtime_s,

                self._mtime_ns,

                self._mtime_second_ambiguous,

            ) = parentfiledata[2]

    @classmethod

    def from_v2_data(cls, flags, size, mtime_s, mtime_ns):

        """Build a new DirstateItem object from V2 data"""

        has_mode_size = bool(flags & DIRSTATE_V2_HAS_MODE_AND_SIZE)

        has_meaningful_mtime = bool(flags & DIRSTATE_V2_HAS_MTIME)

        if flags & DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS:

            # The current code is not able to do the more subtle comparison that the

            # MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime

            has_meaningful_mtime = False

        mode = None

        if flags & +DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED:

            # we do not have support for this flag in the code yet,

            # force a lookup for this file.

            has_mode_size = False

            has_meaningful_mtime = False

        fallback_exec = None

        if flags & DIRSTATE_V2_HAS_FALLBACK_EXEC:

            fallback_exec = flags & DIRSTATE_V2_FALLBACK_EXEC

        fallback_symlink = None

        if flags & DIRSTATE_V2_HAS_FALLBACK_SYMLINK:

            fallback_symlink = flags & DIRSTATE_V2_FALLBACK_SYMLINK

        if has_mode_size:

            assert stat.S_IXUSR == 0o100

            if flags & DIRSTATE_V2_MODE_EXEC_PERM:

                mode = 0o755

            else:

                mode = 0o644

            if flags & DIRSTATE_V2_MODE_IS_SYMLINK:

                mode |= stat.S_IFLNK

            else:

                mode |= stat.S_IFREG

        return cls(

            wc_tracked=bool(flags & DIRSTATE_V2_WDIR_TRACKED),

            p1_tracked=bool(flags & DIRSTATE_V2_P1_TRACKED),

            p2_info=bool(flags & DIRSTATE_V2_P2_INFO),

            has_meaningful_data=has_mode_size,

            has_meaningful_mtime=has_meaningful_mtime,

            parentfiledata=(mode, size, (mtime_s, mtime_ns, False)),

            fallback_exec=fallback_exec,

            fallback_symlink=fallback_symlink,

        )

    @classmethod

    def from_v1_data(cls, state, mode, size, mtime):

        """Build a new DirstateItem object from V1 data

        Since the dirstate-v1 format is frozen, the signature of this function

        is not expected to change, unlike the __init__ one.

        """

        if state == b'm':

            return cls(wc_tracked=True, p1_tracked=True, p2_info=True)

        elif state == b'a':

            return cls(wc_tracked=True)

        elif state == b'r':

            if size == NONNORMAL:

                p1_tracked = True

                p2_info = True

            elif size == FROM_P2:

                p1_tracked = False

                p2_info = True

            else:

                p1_tracked = True

                p2_info = False

            return cls(p1_tracked=p1_tracked, p2_info=p2_info)

        elif state == b'n':

            if size == FROM_P2:

                return cls(wc_tracked=True, p2_info=True)

            elif size == NONNORMAL:

                return cls(wc_tracked=True, p1_tracked=True)

            elif mtime == AMBIGUOUS_TIME:

                return cls(

                    wc_tracked=True,

                    p1_tracked=True,

                    has_meaningful_mtime=False,

                    parentfiledata=(mode, size, (42, 0, False)),

                )

            else:

                return cls(

                    wc_tracked=True,

                    p1_tracked=True,

                    parentfiledata=(mode, size, (mtime, 0, False)),

                )

        else:

            raise RuntimeError(b'unknown state: %s' % state)

    def set_possibly_dirty(self):

        """Mark a file as "possibly dirty"

        This means the next status call will have to actually check its content

        to make sure it is correct.

        """

        self._mtime_s = None

        self._mtime_ns = None

    def set_clean(self, mode, size, mtime):

        """mark a file as "clean" cancelling potential "possibly dirty call"

        Note: this function is a descendant of `dirstate.normal` and is

        currently expected to be call on "normal" entry only. There are not

        reason for this to not change in the future as long as the ccode is

        updated to preserve the proper state of the non-normal files.

        """

        self._wc_tracked = True

        self._p1_tracked = True

        self._mode = mode

        self._size = size

        self._mtime_s, self._mtime_ns, self._mtime_second_ambiguous = mtime

    def set_tracked(self):

        """mark a file as tracked in the working copy

        This will ultimately be called by command like `hg add`.

        """

        self._wc_tracked = True

        # `set_tracked` is replacing various `normallookup` call. So we mark

        # the files as needing lookup

        #

        # Consider dropping this in the future in favor of something less broad.

        self._mtime_s = None

        self._mtime_ns = None

    def set_untracked(self):

        """mark a file as untracked in the working copy

        This will ultimately be called by command like `hg remove`.

        """

        self._wc_tracked = False

        self._mode = None

        self._size = None

        self._mtime_s = None

        self._mtime_ns = None

    def drop_merge_data(self):

        """remove all "merge-only" from a DirstateItem

        This is to be call by the dirstatemap code when the second parent is dropped

        """

        if self._p2_info:

            self._p2_info = False

            self._mode = None

            self._size = None

            self._mtime_s = None

            self._mtime_ns = None

    @property

    def mode(self):

        return self.v1_mode()

    @property

    def size(self):

        return self.v1_size()

    @property

    def mtime(self):

        return self.v1_mtime()

    def mtime_likely_equal_to(self, other_mtime):

        self_sec = self._mtime_s

        if self_sec is None:

            return False

        self_ns = self._mtime_ns

        other_sec, other_ns, second_ambiguous = other_mtime

        if self_sec != other_sec:

            # seconds are different theses mtime are definitly not equal

            return False

        elif other_ns == 0 or self_ns == 0:

            # at least one side as no nano-seconds information

            if self._mtime_second_ambiguous:

                # We cannot trust the mtime in this case

                return False

            else:

                # the "seconds" value was reliable on its own. We are good to go.

                return True

        else:

            # We have nano second information, let us use them !

            return self_ns == other_ns

    @property

    def state(self):

        """

        States are:

          n  normal

          m  needs merging

          r  marked for removal

          a  marked for addition

        XXX This "state" is a bit obscure and mostly a direct expression of the

        dirstatev1 format. It would make sense to ultimately deprecate it in

        favor of the more "semantic" attributes.

        """

        if not self.any_tracked:

            return b'?'

        return self.v1_state()

    @property

    def has_fallback_exec(self):

        """True if "fallback" information are available for the "exec" bit

        Fallback information can be stored in the dirstate to keep track of

        filesystem attribute tracked by Mercurial when the underlying file

        system or operating system does not support that property, (e.g.

        Windows).

        Not all version of the dirstate on-disk storage support preserving this

        information.

        """

        return self._fallback_exec is not None

    @property

    def fallback_exec(self):

        """ "fallback" information for the executable bit

        True if the file should be considered executable when we cannot get

        this information from the files system. False if it should be

        considered non-executable.

        See has_fallback_exec for details."""

        return self._fallback_exec

    @fallback_exec.setter

    def set_fallback_exec(self, value):

        """control "fallback" executable bit

        Set to:

        - True if the file should be considered executable,

        - False if the file should be considered non-executable,

        - None if we do not have valid fallback data.

        See has_fallback_exec for details."""

        if value is None:

            self._fallback_exec = None

        else:

            self._fallback_exec = bool(value)

    @property

    def has_fallback_symlink(self):

        """True if "fallback" information are available for symlink status

        Fallback information can be stored in the dirstate to keep track of

        filesystem attribute tracked by Mercurial when the underlying file

        system or operating system does not support that property, (e.g.

        Windows).

        Not all version of the dirstate on-disk storage support preserving this

        information."""

        return self._fallback_symlink is not None

    @property

    def fallback_symlink(self):

        """ "fallback" information for symlink status

        True if the file should be considered executable when we cannot get

        this information from the files system. False if it should be

        considered non-executable.

        See has_fallback_exec for details."""

        return self._fallback_symlink

    @fallback_symlink.setter