# 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, scmutil, subrepo, patch, encoding

import match as matchmod

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, self._repo.ui)

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

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

        return self._rev in self._repo.changelog.hiddenrevs

    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 is 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 %s') % self) and match(fn):

                yield fn

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