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

import re

import stat

from .i18n import _

from .node import (

    addednodeid,

    bin,

    hex,

    modifiednodeid,

    nullid,

    nullrev,

    short,

    wdirid,

    wdirnodes,

)

from . import (

    encoding,

    error,

    fileset,

    match as matchmod,

    mdiff,

    obsolete as obsmod,

    patch,

    phases,

    pycompat,

    repoview,

    revlog,

    scmutil,

    subrepo,

    util,

)

propertycache = util.propertycache

nonascii = re.compile(r'[^\x21-\x7f]').search

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 __new__(cls, repo, changeid='', *args, **kwargs):

        if isinstance(changeid, basectx):

            return changeid

        o = super(basectx, cls).__new__(cls)

        o._repo = repo

        o._rev = nullrev

        o._node = nullid

        return o

    def __str__(self):

        r = short(self.node())

        if pycompat.ispy3:

            return r.decode('ascii')

        return r

    def __bytes__(self):

        return short(self.node())

    def __int__(self):

        return self.rev()

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

        """return match.always if match is none

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

        match operator.

        """

        return match or matchmod.always(self._repo.root, self._repo.getcwd())

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

            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 wdirnodes:

                # 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 subrepo.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 getfileset(self, expr):

        return fileset.getfileset(self, expr)

    def obsolete(self):

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

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

    def extinct(self):

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

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

    def unstable(self):

        """True if the changeset is not obsolete but it's ancestor are"""

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

    def bumped(self):

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

        Only non-public and non-obsolete changesets may be bumped.

        """

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

    def divergent(self):

        """Is a successors of a changeset with multiple possible successors set

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

        """

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

    def troubled(self):

        """True if the changeset is either unstable, bumped or divergent"""

        return self.unstable() or self.bumped() or self.divergent()

    def troubles(self):

        """return the list of troubles affecting this changesets.

        Troubles are returned as strings. possible values are:

        - unstable,

        - bumped,

        - divergent.

        """

        troubles = []

        if self.unstable():

            troubles.append('unstable')

        if self.bumped():

            troubles.append('bumped')

        if self.divergent():

            troubles.append('divergent')

        return troubles

    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 changectx(self._repo, nullrev)

    def _fileinfo(self, path):

        if '_manifest' in self.__dict__:

            try:

                return self._manifest[path], self._manifest.flags(path)

            except KeyError:

                raise error.ManifestLookupError(self._node, path,

                                                _('not found in manifest'))

        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(self._node, path,

                                            _('not found in manifest'))

        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 ''

    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='glob',

              listsubrepos=False, badfn=None):

        if pats is None:

            pats = []

        r = self._repo

        return matchmod.match(r.root, r.getcwd(), pats,

                              include, exclude, default,

                              auditor=r.nofsauditor, ctx=self,

                              listsubrepos=listsubrepos, badfn=badfn)

    def diff(self, ctx2=None, match=None, **opts):

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

        diffopts = patch.diffopts(self._repo.ui, opts)

        return patch.diff(self._repo, ctx2, self, match=match, opts=diffopts)

    def dirs(self):

        return self._manifest.dirs()

    def hasdir(self, dir):

        return self._manifest.hasdir(dir)

    def dirty(self, missing=False, merge=True, branch=True):

        return False

    def status(self, other=None, match=None, listignored=False,

               listclean=False, listunknown=False, listsubrepos=False):

        """return status of files between two nodes or node and working

        directory.

        If other is None, compare this node with working directory.

        returns (modified, added, removed, deleted, unknown, ignored, clean)

        """

        ctx1 = self

        ctx2 = self._repo[other]

        # This next code block is, admittedly, fragile logic that tests for

        # reversing the contexts and wouldn't need to exist if it weren't for

        # the fast (and common) code path of comparing the working directory

        # with its first parent.

        #

        # What we're aiming for here is the ability to call:

        #

        # workingctx.status(parentctx)

        #

        # If we always built the manifest for each context and compared those,

        # then we'd be done. But the special case of the above call means we

        # just copy the manifest of the parent.

        reversed = False

        if (not isinstance(ctx1, changectx)

            and isinstance(ctx2, changectx)):

            reversed = True

            ctx1, ctx2 = ctx2, ctx1

        match = ctx2._matchstatus(ctx1, match)

        r = scmutil.status([], [], [], [], [], [], [])

        r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,

                              listunknown)

        if reversed:

            # Reverse added and removed. Clear deleted, unknown and ignored as

            # these make no sense to reverse.

            r = scmutil.status(r.modified, r.removed, r.added, [], [], [],

                               r.clean)

        if listsubrepos:

            for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):

                try:

                    rev2 = ctx2.subrev(subpath)

                except KeyError:

                    # A subrepo that existed in node1 was deleted between

                    # node1 and node2 (inclusive). Thus, ctx2's substate

                    # won't contain that subpath. The best we can do ignore it.

                    rev2 = None

                submatch = matchmod.subdirmatcher(subpath, match)