comparison mercurial/dirstate.py @ 5487:7a64931e2d76

Fix file-changed-to-dir and dir-to-file commits (issue660).

Allow adding to dirstate files that clash with previously existing
but marked for removal. Protect from reintroducing clashes by revert.

This change doesn't address related issues with update. Current
workaround is to do "clean" update by manually removing conflicting
files/dirs from working directory.

5486:48c22c719f8c

                if err.errno != errno.ENOENT: raise
            return self._pl
        elif name == '_dirs':
            self._dirs = {}
            for f in self._map:
                self._incpath(f)
            return self._dirs
        elif name == '_ignore':
            files = [self._join('.hgignore')]
            for name, path in self._ui.configitems("ui"):
                if name == 'ignore' or name.startswith('ignore.'):

            raise util.Abort(_('directory %r already in dirstate') % f)
        for c in strutil.rfindall(f, '/'):
            d = f[:c]
            if d in self._dirs:
                break
            if d in self._map:
                raise util.Abort(_('file %r in dirstate clashes with %r') %
                                 (d, f))
        self._incpath(f)

    def normal(self, f):
        'mark a file normal and clean'
        self._dirty = True
        s = os.lstat(self._join(f))
        self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0)
        if self._copymap.has_key(f):
            del self._copymap[f]

    def normallookup(self, f):
        'mark a file normal, but possibly dirty'
        self._dirty = True
        self._map[f] = ('n', 0, -1, -1, 0)
        if f in self._copymap:
            del self._copymap[f]

    def normaldirty(self, f):
        'mark a file normal, but dirty'
        self._dirty = True
        self._map[f] = ('n', 0, -2, -1, 0)
        if f in self._copymap:
            del self._copymap[f]

    def add(self, f):
        'mark a file added'
        self._dirty = True
        self._incpathcheck(f)
        self._map[f] = ('a', 0, -1, -1, 0)
        if f in self._copymap:
            del self._copymap[f]

    def remove(self, f):
        'mark a file removed'
        self._dirty = True
        self._map[f] = ('r', 0, 0, 0, 0)
        self._decpath(f)
        if 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._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime, 0)
        if f in self._copymap:
            del self._copymap[f]

    def forget(self, f):
        'forget a file'
        self._dirty = True
        try:
            del self._map[f]
            self._decpath(f)
        except KeyError:
            self._ui.warn(_("not in dirstate: %s!\n") % f)

    def clear(self):
        self._map = {}
        self._copymap = {}
        self._pl = [nullid, nullid]
        self._dirty = True

    def rebuild(self, parent, files):

                nonexistent = True
                if not st:
                    try:
                        st = lstat(_join(fn))
                    except OSError, inst:
                        if inst.errno != errno.ENOENT:
                            raise
                        st = None
                    # We need to re-check that it is a valid file
                    if st and self._supported(fn, st.st_mode):
                        nonexistent = False

5487:7a64931e2d76

                if err.errno != errno.ENOENT: raise
            return self._pl
        elif name == '_dirs':
            self._dirs = {}
            for f in self._map:
                if self[f] != 'r':
                    self._incpath(f)
            return self._dirs
        elif name == '_ignore':
            files = [self._join('.hgignore')]
            for name, path in self._ui.configitems("ui"):
                if name == 'ignore' or name.startswith('ignore.'):

            raise util.Abort(_('directory %r already in dirstate') % f)
        for c in strutil.rfindall(f, '/'):
            d = f[:c]
            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))
        self._incpath(f)

    def _changepath(self, f, newstate):
        # handle upcoming path changes
        oldstate = self[f]
        if oldstate not in "?r" and newstate in "?r":
            self._decpath(f)
            return
        if oldstate in "?r" and newstate not in "?r":
            self._incpathcheck(f)
            return

    def normal(self, f):
        'mark a file normal and clean'
        self._dirty = True
        self._changepath(f, 'n')
        s = os.lstat(self._join(f))
        self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0)
        if self._copymap.has_key(f):
            del self._copymap[f]

    def normallookup(self, f):
        'mark a file normal, but possibly dirty'
        self._dirty = True
        self._changepath(f, 'n')
        self._map[f] = ('n', 0, -1, -1, 0)
        if f in self._copymap:
            del self._copymap[f]

    def normaldirty(self, f):
        'mark a file normal, but dirty'
        self._dirty = True
        self._changepath(f, 'n')
        self._map[f] = ('n', 0, -2, -1, 0)
        if f in self._copymap:
            del self._copymap[f]

    def add(self, f):
        'mark a file added'
        self._dirty = True
        self._changepath(f, 'a')
        self._map[f] = ('a', 0, -1, -1, 0)
        if f in self._copymap:
            del self._copymap[f]

    def remove(self, f):
        'mark a file removed'
        self._dirty = True
        self._changepath(f, 'r')
        self._map[f] = ('r', 0, 0, 0, 0)
        if 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._changepath(f, 'm')
        self._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime, 0)
        if f in self._copymap:
            del self._copymap[f]

    def forget(self, f):
        'forget a file'
        self._dirty = True
        try:
            self._changepath(f, '?')
            del self._map[f]
        except KeyError:
            self._ui.warn(_("not in dirstate: %s!\n") % f)

    def clear(self):
        self._map = {}
        if "_dirs" in self.__dict__:
            delattr(self, "_dirs");
        self._copymap = {}
        self._pl = [nullid, nullid]
        self._dirty = True

    def rebuild(self, parent, files):

                nonexistent = True
                if not st:
                    try:
                        st = lstat(_join(fn))
                    except OSError, inst:
                        if inst.errno not in (errno.ENOENT, errno.ENOTDIR):
                            raise
                        st = None
                    # We need to re-check that it is a valid file
                    if st and self._supported(fn, st.st_mode):
                        nonexistent = False