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

import re

from node import nullid, nullrev, wdirid, 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

# Phony node value to stand-in for new files in some uses of

# manifests. Manifests support 21-byte hashes for nodes which are

# dirty in the working copy.

_newnode = '!' * 21

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

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

        """

        return self.manifest().matches(match)

    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 = [], []

        removed = []

        clean = []

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

        deletedset = set(deleted)

        d = mf1.diff(mf2, 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 node2 != _newnode:

                # The file was not a new file in mf2, so an entry

                # from diff is really a difference.

                modified.append(fn)

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

                # node2 was newnode, but the working file doesn't

                # match the one in mf1.

                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]

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

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

        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 a subrepo for the stored revision of path, never wdir()'''

        return subrepo.subrepo(self, path)

    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=[], include=None, exclude=None, default='glob',

              listsubrepos=False, badfn=None):

        r = self._repo

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

                              include, exclude, default,

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

        for l in r:

            l.sort()

        return r

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

               editor=None, extra=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)

    if extra is None:

        extra = {}

    if branch:

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

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

                          date, extra, editor)

    return ctx