# 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

from i18n import _

import ancestor, bdiff, error, util, subrepo, patch

import os, errno, stat

propertycache = util.propertycache

class changectx(object):

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

    changeset convenient."""

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

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

        if changeid == '':

            changeid = '.'

        self._repo = repo

        if isinstance(changeid, (long, int)):

            self._rev = changeid

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

        else:

            self._node = self._repo.lookup(changeid)

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

    def __str__(self):

        return short(self.node())

    def __int__(self):

        return self.rev()

    def __repr__(self):

        return "<changectx %s>" % str(self)

    def __hash__(self):

        try:

            return hash(self._rev)

        except AttributeError:

            return id(self)

    def __eq__(self, other):

        try:

            return self._rev == other._rev

        except AttributeError:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __nonzero__(self):

        return self._rev != nullrev

    @propertycache

    def _changeset(self):

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

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

    @propertycache

    def substate(self):

        return subrepo.state(self)

    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 changeset(self):

        return self._changeset

    def manifest(self):

        return self._manifest

    def manifestnode(self):

        return self._changeset[0]

    def rev(self):

        return self._rev

    def node(self):

        return self._node

    def hex(self):

        return hex(self._node)

    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 self._changeset[5].get("branch")

    def extra(self):

        return self._changeset[5]

    def tags(self):

        return self._repo.nodetags(self._node)

    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 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 _fileinfo(self, path):

        if '_manifest' in self.__dict__:

            try:

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

            except KeyError:

                raise error.LookupError(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.LookupError(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 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 == None:

            n2 = c2._parents[0]._node

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

        return changectx(self._repo, n)

    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:

            for ffn in fset:

                # match if the file is the exact name or a directory

                if ffn == fn or fn.startswith("%s/" % ffn):

                    fset.remove(ffn)

                    break

            if match(fn):

                yield fn

        for fn in sorted(fset):

            if match.bad(fn, 'No such file in rev ' + str(self)) and match(fn):

                yield fn

    def sub(self, path):

        return subrepo.subrepo(self, path)

    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 and not isinstance(ctx2, changectx):

            ctx2 = self._repo[ctx2]

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

        return patch.diff(self._repo, ctx2.node(), self.node(),

                          match=match, opts=diffopts)

class filectx(object):

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

       filerevision convenient."""

    def __init__(self, repo, path, changeid=None, fileid=None,

                 filelog=None, changectx=None):

        """changeid can be a changeset revision, node, or tag.

           fileid can be a file revision or node."""

        self._repo = repo

        self._path = path

        assert (changeid is not None

                or fileid is not None

                or changectx is not None), \

                ("bad args: changeid=%r, fileid=%r, changectx=%r"

                 % (changeid, fileid, changectx))

        if filelog:

            self._filelog = filelog

        if changeid is not None:

            self._changeid = changeid

        if changectx is not None:

            self._changectx = changectx

        if fileid is not None:

            self._fileid = fileid

    @propertycache

    def _changectx(self):

        return changectx(self._repo, self._changeid)

    @propertycache

    def _filelog(self):

        return self._repo.file(self._path)

    @propertycache

    def _changeid(self):

        if '_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(), short(self.node()))

    def __repr__(self):

        return "<filectx %s>" % str(self)

    def __hash__(self):

        try:

            return hash((self._path, self._filenode))

        except AttributeError:

            return id(self)

    def __eq__(self, other):

        try:

            return (self._path == other._path

                    and self._filenode == other._filenode)

        except AttributeError:

            return False

    def __ne__(self, other):

        return not (self == other)

    def filectx(self, fileid):

        '''opens an arbitrary revision of the file without

        opening a new filelog'''

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

                       filelog=self._filelog)

    def filerev(self):

        return self._filerev

    def filenode(self):

        return self._filenode

    def flags(self):

        return self._changectx.flags(self._path)

    def filelog(self):

        return self._filelog

    def rev(self):

        if '_changectx' in self.__dict__:

            return self._changectx.rev()

        if '_changeid' in self.__dict__:

            return self._changectx.rev()

        return self._filelog.linkrev(self._filerev)

    def linkrev(self):

        return self._filelog.linkrev(self._filerev)

    def node(self):

        return self._changectx.node()

    def hex(self):

        return hex(self.node())

    def user(self):

        return self._changectx.user()

    def date(self):

        return self._changectx.date()

    def files(self):

        return self._changectx.files()

    def description(self):

        return self._changectx.description()

    def branch(self):

        return self._changectx.branch()

    def extra(self):

        return self._changectx.extra()

    def manifest(self):

        return self._changectx.manifest()

    def changectx(self):

        return self._changectx

    def data(self):

        return self._filelog.read(self._filenode)

    def path(self):

        return self._path

    def size(self):

        return self._filelog.size(self._filerev)

        """

    def renamed(self):

        """check if file was actually renamed in this changeset revision

        If rename logged in file revision, we report copy for changeset only

        if file revisions linkrev points back to the changeset in question

        or both changeset parents contain different file revisions.

        """

        renamed = self._filelog.renamed(self._filenode)