# 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 util, ignore, osutil, parsers, encoding

import struct, os, stat, errno

import cStringIO

_format = ">cllll"

propertycache = util.propertycache

def _finddirs(path):

    pos = path.rfind('/')

    while pos != -1:

        yield path[:pos]

        pos = path.rfind('/', 0, pos)

def _incdirs(dirs, path):

    for base in _finddirs(path):

        if base in dirs:

            dirs[base] += 1

            return

        dirs[base] = 1

def _decdirs(dirs, path):

    for base in _finddirs(path):

        if dirs[base] > 1:

            dirs[base] -= 1

            return

        del dirs[base]

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._ui = ui

    @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 in self._map:

            f[os.path.normcase(name)] = name

        return f

    @propertycache

    def _branch(self):

        try:

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

        except IOError:

            return "default"

    @propertycache

    def _pl(self):

        try:

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

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

        dirs = {}

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

            if s[0] != 'r':

                _incdirs(dirs, f)

        return dirs

    @propertycache

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

        if self._checklink:

            if self._checkexec:

                def f(x):

                    p = self._join(x)

                    if os.path.islink(p):

                        return 'l'

                    if util.is_exec(p):

                        return 'x'

                    return ''

                return f

            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.is_exec(self._join(x)):

                    return 'x'

                return ''

            return f

        return fallback

    def getcwd(self):

        cwd = os.getcwd()

        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.normpath(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 parents(self):

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

    def branch(self):

        return encoding.tolocal(self._branch)

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

        self._dirty = self._dirtypl = True

        self._pl = p1, p2

    def setbranch(self, branch):

        if branch in ['tip', '.', 'null']:

            raise util.Abort(_('the name \'%s\' is reserved') % branch)

        self._branch = encoding.fromlocal(branch)

        self._opener("branch", "w").write(self._branch + '\n')

    def _read(self):

        self._map = {}

        self._copymap = {}

        try:

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

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

            return

        if not st:

            return

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

        if not self._dirtypl:

            self._pl = p

    def invalidate(self):

            if a in self.__dict__:

                delattr(self, a)

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

            _decdirs(self._dirs, f)

    def _addpath(self, f, check=False):

        oldstate = self[f]

        if check or oldstate == "r":

            if '\r' in f or '\n' in f:

                raise util.Abort(

                    _("'\\n' and '\\r' disallowed in filenames: %r") % f)

            if f in self._dirs:

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

            # shadows

            for d in _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__:

            _incdirs(self._dirs, f)

    def normal(self, f):

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

        self._dirty = True

        self._addpath(f)

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

        self._map[f] = ('n', s.st_mode, s.st_size, int(s.st_mtime))

        if f in self._copymap:

            del self._copymap[f]

    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._dirty = True

        self._addpath(f)

        self._map[f] = ('n', 0, -1, -1)

        if f in self._copymap:

            del self._copymap[f]

    def otherparent(self, f):

        '''Mark as coming from the other parent, always dirty.'''

        if self._pl[1] == nullid:

            raise util.Abort(_("setting %r to other parent "

                               "only allowed in merges") % f)

        self._dirty = True

        self._addpath(f)

        self._map[f] = ('n', 0, -2, -1)

        if f in self._copymap:

            del self._copymap[f]

    def add(self, f):

        '''Mark a file added.'''

        self._dirty = True

        self._addpath(f, True)

        self._map[f] = ('a', 0, -1, -1)

        if f in self._copymap:

            del self._copymap[f]

    def remove(self, f):

        '''Mark a file removed.'''

        self._dirty = True

        self._droppath(f)

        size = 0

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

            # backup the previous state

            entry = self._map[f]

            if entry[0] == 'm': # merge

                size = -1

            elif entry[0] == 'n' and entry[2] == -2: # other parent

                size = -2

        self._map[f] = ('r', 0, size, 0)

        if size == 0 and f in self._copymap:

            del self._copymap[f]

    def merge(self, f):

        '''Mark a file merged.'''

        self._dirty = True

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

        self._addpath(f)

        self._map[f] = ('m', s.st_mode, s.st_size, int(s.st_mtime))

        if f in self._copymap:

            del self._copymap[f]

    def forget(self, f):

        '''Forget a file.'''

        self._dirty = True

        try:

            self._droppath(f)

            del self._map[f]

        except KeyError:

            self._ui.warn(_("not in dirstate: %s\n") % f)