# 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 node import nullid, nullrev, short, hex, bin

from i18n import _

import mdiff, error, util, scmutil, subrepo, patch, encoding, phases

import match as matchmod

import os, errno, stat

import obsolete as obsmod

import repoview

import fileset

import revlog

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

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

        for f in sorted(self._manifest):

            yield f

    def _manifestmatches(self, match, s):

        """generate a new manifest filtered by the match argument

        This method is for internal use only and mainly exists to provide an

        object oriented way for other contexts to customize the manifest

        generation.

        """

        if match.always():

            return self.manifest().copy()

        files = match.files()

        if (match.matchfn == match.exact or

            (not match.anypats() and util.all(fn in self for fn in files))):

            return self.manifest().intersectfiles(files)

        mf = self.manifest().copy()

        for fn in mf.keys():

            if not match(fn):

                del mf[fn]

        return mf

    def _matchstatus(self, other, s, match, listignored, listclean,

                     listunknown):

        """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 _prestatus(self, other, s, match, listignored, listclean, listunknown):

        """provide a hook to allow child objects to preprocess status results

        For example, this allows other contexts, such as workingctx, to query

        the dirstate before comparing the manifests.

        """

        # load earliest manifest first for caching reasons

        if self.rev() < other.rev():

            self.manifest()

        return s

    def _poststatus(self, other, s, match, listignored, listclean, listunknown):

        """provide a hook to allow child objects to postprocess status results

        For example, this allows other contexts, such as workingctx, to filter

        suspect symlinks in the case of FAT32 and NTFS filesytems.

        """

        return s

    def _buildstatus(self, other, s, match, listignored, listclean,

                     listunknown):

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

        mf1 = other._manifestmatches(match, s)

        mf2 = self._manifestmatches(match, s)

        modified, added, clean = [], [], []

        deleted, unknown, ignored = s[3], s[4], s[5]

        withflags = mf1.withflags() | mf2.withflags()

        for fn, mf2node in mf2.iteritems():

            if fn in mf1:

                if (fn not in deleted and

                    ((fn in withflags and mf1.flags(fn) != mf2.flags(fn)) or

                     (mf1[fn] != mf2node and

                      (mf2node or self[fn].cmp(other[fn]))))):

                    modified.append(fn)

                elif listclean:

                    clean.append(fn)

                del mf1[fn]

            elif fn not in deleted:

                added.append(fn)

        removed = mf1.keys()

        if removed:

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

            unknown = [fn for fn in unknown if fn not in mf1]

            ignored = [fn for fn in ignored if fn not in mf1]

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

        if len(self._parents) == 2:

            return self._parents[1]

        return changectx(self._repo, -1)

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

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

        if not node:

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

        return subrepo.subrepo(self, path)

    def match(self, pats=[], include=None, exclude=None, default='glob'):

        r = self._repo

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

                              include, exclude, default,

                              auditor=r.auditor, ctx=self)

    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)

    @propertycache

    def _dirs(self):

        return scmutil.dirs(self._manifest)

    def dirs(self):

        return self._dirs

    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

        r = [[], [], [], [], [], [], []]

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

                                  listunknown)

        r = ctx2._prestatus(ctx1, r, match, listignored, listclean, listunknown)

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

                              listunknown)

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

                             listunknown)

        if reversed:

            # reverse added and removed

            r[1], r[2] = r[2], r[1]

        if listsubrepos:

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

                rev2 = ctx2.subrev(subpath)

                try:

                    submatch = matchmod.narrowmatcher(subpath, match)

                    s = sub.status(rev2, match=submatch, ignored=listignored,

                                   clean=listclean, unknown=listunknown,

                                   listsubrepos=True)

                    for rfiles, sfiles in zip(r, s):

                        rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)

                except error.LookupError:

                    self._repo.ui.status(_("skipping missing "

                                           "subrepository: %s\n") % subpath)

        for l in r:

            l.sort()

        # we return a tuple to signify that this list isn't changing

        return tuple(r)

def makememctx(repo, parents, text, user, date, branch, files, store,

               editor=None):

    def getfilectx(repo, memctx, path):

        data, (islink, isexec), copied = store.getfile(path)

        return memfilectx(repo, path, data, islink=islink, isexec=isexec,

                                  copied=copied, memctx=memctx)

    extra = {}

    if branch:

        extra['branch'] = encoding.fromlocal(branch)

    ctx =  memctx(repo, parents, text, files, getfilectx, user,

                          date, extra, editor)

    return ctx

class changectx(basectx):

    """A changecontext object makes access to data related to a particular

    changeset convenient. It represents a read-only context already present in

    the repo."""

    def __init__(self, repo, changeid=''):

        """changeid is a revision number, node, or tag"""

        # since basectx.__new__ already took care of copying the object, we

        # don't need to do anything in __init__, so we just exit here

        if isinstance(changeid, basectx):

            return

        if changeid == '':