# 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 ancestor, mdiff, error, util, scmutil, subrepo, patch, encoding, phases

import match as matchmod

import os, errno, stat

import obsolete as obsmod

import repoview

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

    @propertycache

    def substate(self):

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

    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 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.node(), self.node(),

                          match=match, opts=diffopts)

    @propertycache

    def _dirs(self):

        return scmutil.dirs(self._manifest)

    def dirs(self):

        return self._dirs

    def dirty(self):

        return False

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(path, data, islink=islink, isexec=isexec,

                                  copied=copied)

    extra = {}

    if branch:

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

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

                          date, extra)

    if editor:

        ctx._text = editor(repo, ctx, [])

    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

        if isinstance(changeid, int):

            try:

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

            except IndexError:

                raise error.RepoLookupError(

                    _("unknown revision '%s'") % 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

        if len(changeid) == 20:

            try:

                self._node = changeid

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

                return

            except LookupError:

                pass

        try:

            r = int(changeid)

            if str(r) != changeid:

                raise ValueError

            l = len(repo.changelog)

            if r < 0:

                r += l

            if r < 0 or r >= l:

                raise ValueError

            self._rev = r

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

            return

        except (ValueError, OverflowError, IndexError):

            pass

        if len(changeid) == 40:

            try:

                self._node = bin(changeid)

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

                return

            except (TypeError, LookupError):

                pass

        if changeid in repo._bookmarks:

            self._node = repo._bookmarks[changeid]

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

            return

        if changeid in repo._tagscache.tags:

            self._node = repo._tagscache.tags[changeid]

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

            return

        try:

            self._node = repo.branchtip(changeid)

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

            return

        except error.RepoLookupError:

            pass

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

        if self._node is not None:

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

            return

        # lookup failed

        # check if it might have come from damaged dirstate

        #

        # XXX we could avoid the unfiltered if we had a recognizable exception

        # for filtered changeset access

        if changeid in repo.unfiltered().dirstate.parents():

            raise error.Abort(_("working directory has unknown parent '%s'!")

                              % short(changeid))

        try:

            if len(changeid) == 20:

                changeid = hex(changeid)

        except TypeError:

            pass

        raise error.RepoLookupError(

            _("unknown revision '%s'") % changeid)

    def __hash__(self):

        try:

            return hash(self._rev)

        except AttributeError:

            return id(self)

    def __nonzero__(self):

        return self._rev != nullrev

    @propertycache

    def _changeset(self):

        return self._repo.changelog.read(self.rev())

    @propertycache

    def _manifest(self):

        return self._repo.manifest.read(self._changeset[0])

    @propertycache

    def _manifestdelta(self):

        return self._repo.manifest.readdelta(self._changeset[0])

    @propertycache

    def _parents(self):

        p = self._repo.changelog.parentrevs(self._rev)

        if p[1] == nullrev:

            p = p[:-1]

        return [changectx(self._repo, x) for x in p]

    def changeset(self):

        return self._changeset

    def manifestnode(self):

        return self._changeset[0]

    def user(self):

        return self._changeset[1]

    def date(self):

        return self._changeset[2]

    def files(self):

        return self._changeset[3]

    def description(self):

        return self._changeset[4]

    def branch(self):

        return encoding.tolocal(self._changeset[5].get("branch"))

    def closesbranch(self):

        return 'close' in self._changeset[5]

    def extra(self):

        return self._changeset[5]

    def tags(self):

        return self._repo.nodetags(self._node)

    def bookmarks(self):

        return self._repo.nodebookmarks(self._node)

    def phase(self):

        return self._repo._phasecache.phase(self._repo, self._rev)

    def hidden(self):

        return self._rev in repoview.filterrevs(self._repo, 'visible')

    def children(self):

        """return contexts for each child changeset"""

        c = self._repo.changelog.children(self._node)

        return [changectx(self._repo, x) for x in c]

    def ancestors(self):

        for a in self._repo.changelog.ancestors([self._rev]):

            yield changectx(self._repo, a)

    def descendants(self):

        for d in self._repo.changelog.descendants([self._rev]):

            yield changectx(self._repo, d)

    def filectx(self, path, fileid=None, filelog=None):

        """get a file context from this changeset"""

        if fileid is None:

            fileid = self.filenode(path)

        return filectx(self._repo, path, fileid=fileid,

                       changectx=self, filelog=filelog)

    def ancestor(self, c2):

        """

        return the ancestor context of self and c2

        """

        # deal with workingctxs

        n2 = c2._node

        if n2 is None:

            n2 = c2._parents[0]._node

        n = self._repo.changelog.ancestor(self._node, n2)

        return changectx(self._repo, n)

    def descendant(self, other):

        """True if other is descendant of this changeset"""

        return self._repo.changelog.descendant(self._rev, other._rev)

    def walk(self, match):

        fset = set(match.files())

        # for dirstate.walk, files=['.'] means "walk the whole tree".

        # follow that here, too

        fset.discard('.')

        for fn in self:

            if fn in fset:

                # specified pattern is the exact name

                fset.remove(fn)

            if match(fn):

                yield fn

        for fn in sorted(fset):

            if fn in self._dirs:

                # specified pattern is a directory

                continue

            if match.bad(fn, _('no such file in rev %s') % self) and match(fn):

                yield fn

class basefilectx(object):

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

    filectx: read-only access to a filerevision that is already present

             in the repo,

    workingfilectx: a filecontext that represents files from the working

                    directory,

    memfilectx: a filecontext that represents files in-memory."""

    def __new__(cls, repo, path, *args, **kwargs):

        return super(basefilectx, cls).__new__(cls)

    @propertycache

    def _filelog(self):

        return self._repo.file(self._path)

    @propertycache

    def _changeid(self):

        if '_changeid' in self.__dict__:

            return self._changeid

        elif '_changectx' in self.__dict__:

            return self._changectx.rev()

        else:

            return self._filelog.linkrev(self._filerev)

    @propertycache

    def _filenode(self):

        if '_fileid' in self.__dict__:

            return self._filelog.lookup(self._fileid)

        else:

            return self._changectx.filenode(self._path)

    @propertycache

    def _filerev(self):

        return self._filelog.rev(self._filenode)

    @propertycache

    def _repopath(self):

        return self._path

    def __nonzero__(self):

        try:

            self._filenode

            return True

        except error.LookupError:

            # file is missing

            return False

    def __str__(self):

        return "%s@%s" % (self.path(), self._changectx)

    def __repr__(self):

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

    def __hash__(self):