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

        """

    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.

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

            self.manifest()

        mf1 = other._manifestmatches(match, s)

        mf2 = self._manifestmatches(match, s)

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

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

        deletedset = set(deleted)

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

        for fn, mf2node in mf2.iteritems():

            if fn in mf1:

                if (fn not in deletedset 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 deletedset:

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

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

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

        return r

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

               editor=None):

    def getfilectx(repo, memctx, path):

        data, mode, copied = store.getfile(path)

        if data is None:

            return None

        islink, isexec = mode

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

            changeid = '.'

        self._repo = repo

        try:

            if isinstance(changeid, int):

                self._node = repo.changelog.node(changeid)

                self._rev = changeid

                return

            if isinstance(changeid, long):

                changeid = str(changeid)

            if changeid == '.':

                self._node = repo.dirstate.p1()

                self._rev = repo.changelog.rev(self._node)

                return

            if changeid == 'null':

                self._node = nullid

                self._rev = nullrev

                return

            if changeid == 'tip':

                self._node = repo.changelog.tip()

                self._rev = repo.changelog.rev(self._node)

                return