# context.py - changeset and file context objects for mercurial

#

# Copyright 2006, 2007 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 filecmp

import os

import stat

from .i18n import _

from .node import (

    addednodeid,

    hex,

    modifiednodeid,

    nullid,

    nullrev,

    short,

    wdirfilenodeids,

    wdirhex,

)

from .pycompat import (

    getattr,

    open,

)

from . import (

    dagop,

    encoding,

    error,

    fileset,

    match as matchmod,

    mergestate as mergestatemod,

    metadata,

    obsolete as obsmod,

    patch,

    pathutil,

    phases,

    pycompat,

    repoview,

    scmutil,

    sparse,

    subrepo,

    subrepoutil,

    util,

)

from .utils import (

    dateutil,

    stringutil,

)

propertycache = util.propertycache

class basectx(object):

    """A basectx object represents the common logic for its children:

    changectx: read-only context that is already present in the repo,

    workingctx: a context that represents the working directory and can

                be committed,

    memctx: a context that represents changes in-memory and can also

            be committed."""

    def __init__(self, repo):

        self._repo = repo

    def __bytes__(self):

        return short(self.node())

    __str__ = encoding.strmethod(__bytes__)

    def __repr__(self):

        return "<%s %s>" % (type(self).__name__, str(self))

    def __eq__(self, other):

        try:

            return type(self) == type(other) and self._rev == other._rev

        except AttributeError:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __contains__(self, key):

        return key in self._manifest

    def __getitem__(self, key):

        return self.filectx(key)

    def __iter__(self):

        return iter(self._manifest)

    def _buildstatusmanifest(self, status):

        """Builds a manifest that includes the given status results, if this is

        a working copy context. For non-working copy contexts, it just returns

        the normal manifest."""

        return self.manifest()

    def _matchstatus(self, other, match):

        """This internal method provides a way for child objects to override the

        match operator.

        """

        return match

    def _buildstatus(

        self, other, s, match, listignored, listclean, listunknown

    ):

        """build a status with respect to another context"""

        # Load earliest manifest first for caching reasons. More specifically,

        # if you have revisions 1000 and 1001, 1001 is probably stored as a

        # delta against 1000. Thus, if you read 1000 first, we'll reconstruct

        # 1000 and cache it so that when you read 1001, we just need to apply a

        # delta to what's in the cache. So that's one full reconstruction + one

        # delta application.

        mf2 = None

        if self.rev() is not None and self.rev() < other.rev():

            mf2 = self._buildstatusmanifest(s)

        mf1 = other._buildstatusmanifest(s)

        if mf2 is None:

            mf2 = self._buildstatusmanifest(s)

        modified, added = [], []

        removed = []

        clean = []

        deleted, unknown, ignored = s.deleted, s.unknown, s.ignored

        deletedset = set(deleted)

        d = mf1.diff(mf2, match=match, clean=listclean)

        for fn, value in pycompat.iteritems(d):

            if fn in deletedset:

                continue

            if value is None:

                clean.append(fn)

                continue

            (node1, flag1), (node2, flag2) = value

            if node1 is None:

                added.append(fn)

            elif node2 is None:

                removed.append(fn)

            elif flag1 != flag2:

                modified.append(fn)

            elif node2 not in wdirfilenodeids:

                # When comparing files between two commits, we save time by

                # not comparing the file contents when the nodeids differ.

                # Note that this means we incorrectly report a reverted change

                # to a file as a modification.

                modified.append(fn)

            elif self[fn].cmp(other[fn]):

                modified.append(fn)

            else:

                clean.append(fn)

        if removed:

            # need to filter files if they are already reported as removed

            unknown = [

                fn

                for fn in unknown

                if fn not in mf1 and (not match or match(fn))

            ]

            ignored = [

                fn

                for fn in ignored

                if fn not in mf1 and (not match or match(fn))

            ]

            # if they're deleted, don't report them as removed

            removed = [fn for fn in removed if fn not in deletedset]

        return scmutil.status(

            modified, added, removed, deleted, unknown, ignored, clean

        )

    @propertycache

    def substate(self):

        return subrepoutil.state(self, self._repo.ui)

    def subrev(self, subpath):

        return self.substate[subpath][1]

    def rev(self):

        return self._rev

    def node(self):

        return self._node

    def hex(self):

        return hex(self.node())

    def manifest(self):

        return self._manifest

    def manifestctx(self):

        return self._manifestctx

    def repo(self):

        return self._repo

    def phasestr(self):

        return phases.phasenames[self.phase()]

    def mutable(self):

        return self.phase() > phases.public

    def matchfileset(self, cwd, expr, badfn=None):

        return fileset.match(self, cwd, expr, badfn=badfn)

    def obsolete(self):

        """True if the changeset is obsolete"""

        return self.rev() in obsmod.getrevs(self._repo, b'obsolete')

    def extinct(self):

        """True if the changeset is extinct"""

        return self.rev() in obsmod.getrevs(self._repo, b'extinct')

    def orphan(self):

        """True if the changeset is not obsolete, but its ancestor is"""

        return self.rev() in obsmod.getrevs(self._repo, b'orphan')

    def phasedivergent(self):

        """True if the changeset tries to be a successor of a public changeset

        Only non-public and non-obsolete changesets may be phase-divergent.

        """

        return self.rev() in obsmod.getrevs(self._repo, b'phasedivergent')

    def contentdivergent(self):

        """Is a successor of a changeset with multiple possible successor sets

        Only non-public and non-obsolete changesets may be content-divergent.

        """

        return self.rev() in obsmod.getrevs(self._repo, b'contentdivergent')

    def isunstable(self):

        """True if the changeset is either orphan, phase-divergent or

        content-divergent"""

        return self.orphan() or self.phasedivergent() or self.contentdivergent()

    def instabilities(self):

        """return the list of instabilities affecting this changeset.

        Instabilities are returned as strings. possible values are:

        - orphan,

        - phase-divergent,

        - content-divergent.

        """

        instabilities = []

        if self.orphan():

            instabilities.append(b'orphan')

        if self.phasedivergent():

            instabilities.append(b'phase-divergent')

        if self.contentdivergent():

            instabilities.append(b'content-divergent')

        return instabilities

    def parents(self):

        """return contexts for each parent changeset"""

        return self._parents

    def p1(self):

        return self._parents[0]

    def p2(self):

        parents = self._parents

        if len(parents) == 2:

            return parents[1]

        return self._repo[nullrev]

    def _fileinfo(self, path):

        if '_manifest' in self.__dict__:

            try:

                return self._manifest.find(path)

            except KeyError:

                raise error.ManifestLookupError(

                )

        if '_manifestdelta' in self.__dict__ or path in self.files():

            if path in self._manifestdelta:

                return (

                    self._manifestdelta[path],

                    self._manifestdelta.flags(path),

                )

        mfl = self._repo.manifestlog

        try:

            node, flag = mfl[self._changeset.manifest].find(path)

        except KeyError:

            raise error.ManifestLookupError(

            )

        return node, flag

    def filenode(self, path):

        return self._fileinfo(path)[0]

    def flags(self, path):

        try:

            return self._fileinfo(path)[1]

        except error.LookupError:

            return b''

    @propertycache

    def _copies(self):

        return metadata.computechangesetcopies(self)

    def p1copies(self):

        return self._copies[0]

    def p2copies(self):

        return self._copies[1]

    def sub(self, path, allowcreate=True):

        '''return a subrepo for the stored revision of path, never wdir()'''

        return subrepo.subrepo(self, path, allowcreate=allowcreate)

    def nullsub(self, path, pctx):

        return subrepo.nullsubrepo(self, path, pctx)

    def workingsub(self, path):

        '''return a subrepo for the stored revision, or wdir if this is a wdir

        context.

        '''

        return subrepo.subrepo(self, path, allowwdir=True)

    def match(

        self,

        pats=None,

        include=None,

        exclude=None,

        default=b'glob',

        listsubrepos=False,

        badfn=None,

        cwd=None,

    ):

        r = self._repo

        if not cwd:

            cwd = r.getcwd()

        return matchmod.match(

            r.root,

            cwd,

            pats,

            include,

            exclude,

            default,

            auditor=r.nofsauditor,

            ctx=self,

            listsubrepos=listsubrepos,

            badfn=badfn,

        )

    def diff(

        self,

        ctx2=None,

        match=None,

        changes=None,

        opts=None,

        losedatafn=None,

        pathfn=None,

        copy=None,

        copysourcematch=None,

        hunksfilterfn=None,

    ):

        """Returns a diff generator for the given contexts and matcher"""

        if ctx2 is None:

            ctx2 = self.p1()

        if ctx2 is not None:

            ctx2 = self._repo[ctx2]

        return patch.diff(

            self._repo,

            ctx2,

            self,

            match=match,

            changes=changes,

            opts=opts,

            losedatafn=losedatafn,

            pathfn=pathfn,

            copy=copy,

            copysourcematch=copysourcematch,

            hunksfilterfn=hunksfilterfn,

        )

    def dirs(self):

        return self._manifest.dirs()

    def hasdir(self, dir):

        return self._manifest.hasdir(dir)

    def status(