# 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, gc

propertycache = util.propertycache

filecache = scmutil.filecache

_rangemask = 0x7fffffff

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

        self._rootdir = os.path.join(root, '')

        self._dirty = False

        self._dirtypl = False

        self._lastnormaltime = 0

        self._ui = ui

        self._filecache = {}

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

        f = {}

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

            if s[0] != 'r':

                f[util.normcase(name)] = name

        for name in self._dirs:

            f[util.normcase(name)] = name

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

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

                files.append(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()

        """

        self._dirty = self._dirtypl = True

        oldp2 = self._pl[1]

        self._pl = p1, p2

        copies = {}

        if oldp2 != nullid and p2 == nullid:

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

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

                if s[0] == 'm':

                    if f in self._copymap:

                        copies[f] = self._copymap[f]

                    self.normallookup(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.

        gcenabled = gc.isenabled()

        gc.disable()

        try:

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

        finally:

            if gcenabled:

                gc.enable()

        if not self._dirtypl:

            self._pl = p

    def invalidate(self):

        for a in ("_map", "_copymap", "_foldmap", "_branch", "_pl", "_dirs",

                "_ignore"):

            if a in self.__dict__:

                delattr(self, a)

        self._lastnormaltime = 0

        self._dirty = False

    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)

            # shadows

            for d in scmutil.finddirs(f):

                if d in self._dirs:

                    break

                if d in self._map and self[d] != 'r':

                    raise util.Abort(

                        _('file %r in dirstate clashes with %r') % (d, f))

        if oldstate in "?r" and "_dirs" in self.__dict__:

            self._dirs.addpath(f)

        self._dirty = True

        self._map[f] = (state, mode, size, mtime)

    def normal(self, f):

        '''Mark a file normal and clean.'''

        s = os.lstat(self._join(f))

        mtime = int(s.st_mtime)

        self._addpath(f, 'n', s.st_mode,

                      s.st_size & _rangemask, mtime & _rangemask)

        if f in self._copymap:

            del self._copymap[f]

        if mtime > self._lastnormaltime:

            # Remember the most recent modification timeslot for status(),

            # to make sure we won't miss future size-preserving file content

            # modifications that happen within the same timeslot.

            self._lastnormaltime = mtime

    def normallookup(self, f):

        '''Mark a file normal, but possibly dirty.'''

        if self._pl[1] != nullid and f in self._map:

            # if there is a merge going on and the file was either

            # in state 'm' (-1) or coming from other parent (-2) before

            # being removed, restore that state.

            entry = self._map[f]

            if entry[0] == 'r' and entry[2] in (-1, -2):

                source = self._copymap.get(f)

                if entry[2] == -1:

                    self.merge(f)

                elif entry[2] == -2:

                    self.otherparent(f)

                if source:

                    self.copy(source, f)

                return

            if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2:

                return

        self._addpath(f, 'n', 0, -1, -1)

        if f in self._copymap: