# dirstate.py - working directory tracking for mercurial

#

# Copyright 2005-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

from i18n import _

import scmutil, util, ignore, osutil, parsers, encoding, pathutil

import os, stat, errno

propertycache = util.propertycache

filecache = scmutil.filecache

_rangemask = 0x7fffffff

dirstatetuple = parsers.dirstatetuple

class repocache(filecache):

    """filecache for files in .hg/"""

    def join(self, obj, fname):

        return obj._opener.join(fname)

class rootcache(filecache):

    """filecache for files in the repository root"""

    def join(self, obj, fname):

        return obj._join(fname)

class dirstate(object):

    def __init__(self, opener, ui, root, validate):

        '''Create a new dirstate object.

        opener is an open()-like callable that can be used to open the

        dirstate file; root is the root of the directory tracked by

        the dirstate.

        '''

        self._opener = opener

        self._validate = validate

        self._root = root

        # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is

        # UNC path pointing to root share (issue4557)

        if root.endswith(os.sep):

            self._rootdir = root

        else:

            self._rootdir = root + os.sep

        self._dirty = False

        self._dirtypl = False

        self._lastnormaltime = 0

        self._ui = ui

        self._filecache = {}

        self._parentwriters = 0

    def beginparentchange(self):

        '''Marks the beginning of a set of changes that involve changing

        the dirstate parents. If there is an exception during this time,

        the dirstate will not be written when the wlock is released. This

        prevents writing an incoherent dirstate where the parent doesn't

        match the contents.

        '''

        self._parentwriters += 1

    def endparentchange(self):

        '''Marks the end of a set of changes that involve changing the

        dirstate parents. Once all parent changes have been marked done,

        the wlock will be free to write the dirstate on release.

        '''

        if self._parentwriters > 0:

            self._parentwriters -= 1

    def pendingparentchange(self):

        '''Returns true if the dirstate is in the middle of a set of changes

        that modify the dirstate parent.

        '''

        return self._parentwriters > 0

    @propertycache

    def _map(self):

        '''Return the dirstate contents as a map from filename to

        (state, mode, size, time).'''

        self._read()

        return self._map

    @propertycache

    def _copymap(self):

        self._read()

        return self._copymap

    @propertycache

    def _filefoldmap(self):

        try:

            makefilefoldmap = parsers.make_file_foldmap

        except AttributeError:

            pass

        else:

            return makefilefoldmap(self._map, util.normcasespec,

                                   util.normcasefallback)

        f = {}

        normcase = util.normcase

        for name, s in self._map.iteritems():

            if s[0] != 'r':

                f[normcase(name)] = name

        f['.'] = '.' # prevents useless util.fspath() invocation

        return f

    @propertycache

    def _dirfoldmap(self):

        f = {}

        normcase = util.normcase

        for name in self._dirs:

            f[normcase(name)] = name

        return f

    @repocache('branch')

    def _branch(self):

        try:

            return self._opener.read("branch").strip() or "default"

        except IOError, inst:

            if inst.errno != errno.ENOENT:

                raise

            return "default"

    @propertycache

    def _pl(self):

        try:

            fp = self._opener("dirstate")

            st = fp.read(40)

            fp.close()

            l = len(st)

            if l == 40:

                return st[:20], st[20:40]

            elif l > 0 and l < 40:

                raise util.Abort(_('working directory state appears damaged!'))

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

        return [nullid, nullid]

    @propertycache

    def _dirs(self):

        return scmutil.dirs(self._map, 'r')

    def dirs(self):

        return self._dirs

    @rootcache('.hgignore')

    def _ignore(self):

        files = [self._join('.hgignore')]

        for name, path in self._ui.configitems("ui"):

            if name == 'ignore' or name.startswith('ignore.'):

                # we need to use os.path.join here rather than self._join

                # because path is arbitrary and user-specified

                files.append(os.path.join(self._rootdir, util.expandpath(path)))

        return ignore.ignore(self._root, files, self._ui.warn)

    @propertycache

    def _slash(self):

        return self._ui.configbool('ui', 'slash') and os.sep != '/'

    @propertycache

    def _checklink(self):

        return util.checklink(self._root)

    @propertycache

    def _checkexec(self):

        return util.checkexec(self._root)

    @propertycache

    def _checkcase(self):

        return not util.checkcase(self._join('.hg'))

    def _join(self, f):

        # much faster than os.path.join()

        # it's safe because f is always a relative path

        return self._rootdir + f

    def flagfunc(self, buildfallback):

        if self._checklink and self._checkexec:

            def f(x):

                try:

                    st = os.lstat(self._join(x))

                    if util.statislink(st):

                        return 'l'

                    if util.statisexec(st):

                        return 'x'

                except OSError:

                    pass

                return ''

            return f

        fallback = buildfallback()

        if self._checklink:

            def f(x):

                if os.path.islink(self._join(x)):

                    return 'l'

                if 'x' in fallback(x):

                    return 'x'

                return ''

            return f

        if self._checkexec:

            def f(x):

                if 'l' in fallback(x):

                    return 'l'

                if util.isexec(self._join(x)):

                    return 'x'

                return ''

            return f

        else:

            return fallback

    @propertycache

    def _cwd(self):

        return os.getcwd()

    def getcwd(self):

        cwd = self._cwd

        if cwd == self._root:

            return ''

        # self._root ends with a path separator if self._root is '/' or 'C:\'

        rootsep = self._root

        if not util.endswithsep(rootsep):

            rootsep += os.sep

        if cwd.startswith(rootsep):

            return cwd[len(rootsep):]

        else:

            # we're outside the repo. return an absolute path.

            return cwd

    def pathto(self, f, cwd=None):

        if cwd is None:

            cwd = self.getcwd()

        path = util.pathto(self._root, cwd, f)

        if self._slash:

            return util.pconvert(path)

        return path

    def __getitem__(self, key):

        '''Return the current state of key (a filename) in the dirstate.

        States are:

          n  normal

          m  needs merging

          r  marked for removal

          a  marked for addition

          ?  not tracked

        '''

        return self._map.get(key, ("?",))[0]

    def __contains__(self, key):

        return key in self._map

    def __iter__(self):

        for x in sorted(self._map):

            yield x

    def iteritems(self):

        return self._map.iteritems()

    def parents(self):

        return [self._validate(p) for p in self._pl]

    def p1(self):

        return self._validate(self._pl[0])

    def p2(self):

        return self._validate(self._pl[1])

    def branch(self):

        return encoding.tolocal(self._branch)

    def setparents(self, p1, p2=nullid):

        """Set dirstate parents to p1 and p2.

        When moving from two parents to one, 'm' merged entries a

        adjusted to normal and previous copy records discarded and

        returned by the call.

        See localrepo.setparents()

        """

        if self._parentwriters == 0:

            raise ValueError("cannot set dirstate parent without "

                             "calling dirstate.beginparentchange")

        self._dirty = self._dirtypl = True

        oldp2 = self._pl[1]

        self._pl = p1, p2

        copies = {}

        if oldp2 != nullid and p2 == nullid:

            for f, s in self._map.iteritems():

                # Discard 'm' markers when moving away from a merge state

                if s[0] == 'm':

                    if f in self._copymap:

                        copies[f] = self._copymap[f]

                    self.normallookup(f)

                # Also fix up otherparent markers

                elif s[0] == 'n' and s[2] == -2:

                    if f in self._copymap:

                        copies[f] = self._copymap[f]

                    self.add(f)

        return copies

    def setbranch(self, branch):

        self._branch = encoding.fromlocal(branch)

        f = self._opener('branch', 'w', atomictemp=True)

        try:

            f.write(self._branch + '\n')

            f.close()

            # make sure filecache has the correct stat info for _branch after

            # replacing the underlying file

            ce = self._filecache['_branch']

            if ce:

                ce.refresh()

        except: # re-raises

            f.discard()

            raise

    def _read(self):

        self._map = {}

        self._copymap = {}

        try:

            st = self._opener.read("dirstate")

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

            return

        if not st:

            return

        # Python's garbage collector triggers a GC each time a certain number

        # of container objects (the number being defined by

        # gc.get_threshold()) are allocated. parse_dirstate creates a tuple

        # for each file in the dirstate. The C version then immediately marks

        # them as not to be tracked by the collector. However, this has no

        # effect on when GCs are triggered, only on what objects the GC looks

        # into. This means that O(number of files) GCs are unavoidable.

        # Depending on when in the process's lifetime the dirstate is parsed,

        # this can get very expensive. As a workaround, disable GC while

        # parsing the dirstate.

        #

        # (we cannot decorate the function directly since it is in a C module)

        parse_dirstate = util.nogc(parsers.parse_dirstate)

        p = parse_dirstate(self._map, self._copymap, st)

        if not self._dirtypl:

            self._pl = p

    def invalidate(self):

        for a in ("_map", "_copymap", "_filefoldmap", "_dirfoldmap", "_branch",

                  "_pl", "_dirs", "_ignore"):

            if a in self.__dict__:

                delattr(self, a)

        self._lastnormaltime = 0

        self._dirty = False

        self._parentwriters = 0

    def copy(self, source, dest):

        """Mark dest as a copy of source. Unmark dest if source is None."""

        if source == dest:

            return

        self._dirty = True

        if source is not None:

            self._copymap[dest] = source

        elif dest in self._copymap:

            del self._copymap[dest]

    def copied(self, file):

        return self._copymap.get(file, None)

    def copies(self):

        return self._copymap

    def _droppath(self, f):

        if self[f] not in "?r" and "_dirs" in self.__dict__:

            self._dirs.delpath(f)

    def _addpath(self, f, state, mode, size, mtime):

        oldstate = self[f]

        if state == 'a' or oldstate == 'r':

            scmutil.checkfilename(f)

            if f in self._dirs:

                raise util.Abort(_('directory %r already in dirstate') % f)