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

import match as matchmod

import os, errno, stat

import obsolete as obsmod

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

            self._rev = changeid

            self._node = repo.changelog.node(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._rev = len(repo.changelog) - 1

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

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

            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

            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 __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.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]

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

        return phases.phasenames[self.phase()]

    def mutable(self):

        return self.phase() > phases.public

    def hidden(self):

        return self._rev in self._repo.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 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 _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 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

    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)

    @propertycache

    def _dirs(self):

        dirs = set()

        for f in self._manifest:

            pos = f.rfind('/')

            while pos != -1:

                f = f[:pos]

                if f in dirs:

                    break # dirs already contains this and above

                dirs.add(f)

                pos = f.rfind('/')

        return dirs

    def dirs(self):

        return self._dirs

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