status: put added files that have disappeared in the deleted list

This gives the user an indication that something went wrong with this file:

$ hg add foo
$ rm foo
$ hg status foo
! foo

Fixes issue212.

mercurial/dirstate.py

@@ -1,595 +1,595 b''
 """
 dirstate.py - working directory tracking for mercurial
 
 Copyright 2005-2007 Matt Mackall <[e-mail]>
 
 This software may be used and distributed according to the terms
 of the GNU General Public License, incorporated herein by reference.
 """
 
 from node import *
 from i18n import _
 import struct, os, time, bisect, stat, strutil, util, re, errno, ignore
 import cStringIO, osutil
 
 _unknown = ('?', 0, 0, 0)
 _format = ">cllll"
 
 class dirstate(object):
 
     def __init__(self, opener, ui, root):
         self._opener = opener
         self._root = root
         self._dirty = False
         self._dirtypl = False
         self._ui = ui
 
     def __getattr__(self, name):
         if name == '_map':
             self._read()
             return self._map
         elif name == '_copymap':
             self._read()
             return self._copymap
         elif name == '_branch':
             try:
                 self._branch = (self._opener("branch").read().strip()
                                 or "default")
             except IOError:
                 self._branch = "default"
             return self._branch
         elif name == '_pl':
             self._pl = [nullid, nullid]
             try:
                 st = self._opener("dirstate").read(40)
                 if len(st) == 40:
                     self._pl = st[:20], st[20:40]
             except IOError, err:
                 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.'):
                     files.append(os.path.expanduser(path))
             self._ignore = ignore.ignore(self._root, files, self._ui.warn)
             return self._ignore
         elif name == '_slash':
             self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/'
             return self._slash
         else:
             raise AttributeError, name
 
     def _join(self, f):
         return os.path.join(self._root, f)
 
     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):
         ''' current states:
         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):
         a = self._map.keys()
         a.sort()
         for x in a:
             yield x
 
     def parents(self):
         return self._pl
 
     def branch(self):
         return self._branch
 
     def setparents(self, p1, p2=nullid):
         self._dirty = self._dirtypl = True
         self._pl = p1, p2
 
     def setbranch(self, branch):
         self._branch = branch
         self._opener("branch", "w").write(branch + '\n')
 
     def _read(self):
         self._map = {}
         self._copymap = {}
         if not self._dirtypl:
             self._pl = [nullid, nullid]
         try:
             st = self._opener("dirstate").read()
         except IOError, err:
             if err.errno != errno.ENOENT: raise
             return
         if not st:
             return
 
         if not self._dirtypl:
             self._pl = [st[:20], st[20: 40]]
 
         # deref fields so they will be local in loop
         dmap = self._map
         copymap = self._copymap
         unpack = struct.unpack
         e_size = struct.calcsize(_format)
         pos1 = 40
         l = len(st)
 
         # the inner loop
         while pos1 < l:
             pos2 = pos1 + e_size
             e = unpack(">cllll", st[pos1:pos2]) # a literal here is faster
             pos1 = pos2 + e[4]
             f = st[pos2:pos1]
             if '\0' in f:
                 f, c = f.split('\0')
                 copymap[f] = c
             dmap[f] = e # we hold onto e[4] because making a subtuple is slow
 
     def invalidate(self):
         for a in "_map _copymap _branch _pl _dirs _ignore".split():
             if a in self.__dict__:
                 delattr(self, a)
         self._dirty = False
 
     def copy(self, source, dest):
         self._dirty = True
         self._copymap[dest] = source
 
     def copied(self, file):
         return self._copymap.get(file, None)
 
     def copies(self):
         return self._copymap
 
     def _incpath(self, path):
         c = path.rfind('/')
         if c >= 0:
             dirs = self._dirs
             base = path[:c]
             if base not in dirs:
                 self._incpath(base)
                 dirs[base] = 1
             else:
                 dirs[base] += 1
 
     def _decpath(self, path):
         c = path.rfind('/')
         if c >= 0:
             base = path[:c]
             dirs = self._dirs
             if dirs[base] == 1:
                 del dirs[base]
                 self._decpath(base)
             else:
                 dirs[base] -= 1
 
     def _incpathcheck(self, f):
         if '\r' in f or '\n' in f:
             raise util.Abort(_("'\\n' and '\\r' disallowed in filenames"))
         # shadows
         if f in self._dirs:
             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, relaxed=False):
         # handle upcoming path changes
         oldstate = self[f]
         if oldstate not in "?r" and newstate in "?r":
             if "_dirs" in self.__dict__:
                 self._decpath(f)
             return
         if oldstate in "?r" and newstate not in "?r":
             if relaxed and oldstate == '?':
                 # XXX
                 # in relaxed mode we assume the caller knows
                 # what it is doing, workaround for updating
                 # dir-to-file revisions
                 if "_dirs" in self.__dict__:
                     self._incpath(f)
                 return
             self._incpathcheck(f)
             return
 
     def normal(self, f):
         'mark a file normal and clean'
         self._dirty = True
         self._changepath(f, 'n', True)
         s = os.lstat(self._join(f))
         self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0)
         if f in self._copymap:
             del self._copymap[f]
 
     def normallookup(self, f):
         'mark a file normal, but possibly dirty'
         self._dirty = True
         self._changepath(f, 'n', 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._changepath(f, 'n', 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._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', True)
         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):
         self.clear()
         for f in files:
             if files.execf(f):
                 self._map[f] = ('n', 0777, -1, 0, 0)
             else:
                 self._map[f] = ('n', 0666, -1, 0, 0)
         self._pl = (parent, nullid)
         self._dirty = True
 
     def write(self):
         if not self._dirty:
             return
         cs = cStringIO.StringIO()
         copymap = self._copymap
         pack = struct.pack
         write = cs.write
         write("".join(self._pl))
         for f, e in self._map.iteritems():
             if f in copymap:
                 f = "%s\0%s" % (f, copymap[f])
             e = pack(_format, e[0], e[1], e[2], e[3], len(f))
             write(e)
             write(f)
         st = self._opener("dirstate", "w", atomictemp=True)
         st.write(cs.getvalue())
         st.rename()
         self._dirty = self._dirtypl = False
 
     def _filter(self, files):
         ret = {}
         unknown = []
 
         for x in files:
             if x == '.':
                 return self._map.copy()
             if x not in self._map:
                 unknown.append(x)
             else:
                 ret[x] = self._map[x]
 
         if not unknown:
             return ret
 
         b = self._map.keys()
         b.sort()
         blen = len(b)
 
         for x in unknown:
             bs = bisect.bisect(b, "%s%s" % (x, '/'))
             while bs < blen:
                 s = b[bs]
                 if len(s) > len(x) and s.startswith(x):
                     ret[s] = self._map[s]
                 else:
                     break
                 bs += 1
         return ret
 
     def _supported(self, f, mode, verbose=False):
         if stat.S_ISREG(mode) or stat.S_ISLNK(mode):
             return True
         if verbose:
             kind = 'unknown'
             if stat.S_ISCHR(mode): kind = _('character device')
             elif stat.S_ISBLK(mode): kind = _('block device')
             elif stat.S_ISFIFO(mode): kind = _('fifo')
             elif stat.S_ISSOCK(mode): kind = _('socket')
             elif stat.S_ISDIR(mode): kind = _('directory')
             self._ui.warn(_('%s: unsupported file type (type is %s)\n')
                           % (self.pathto(f), kind))
         return False
 
     def _dirignore(self, f):
         if self._ignore(f):
             return True
         for c in strutil.findall(f, '/'):
             if self._ignore(f[:c]):
                 return True
         return False
 
     def walk(self, files=None, match=util.always, badmatch=None):
         # filter out the stat
         for src, f, st in self.statwalk(files, match, badmatch=badmatch):
             yield src, f
 
     def statwalk(self, files=None, match=util.always, ignored=False,
                  badmatch=None, directories=False):
         '''
         walk recursively through the directory tree, finding all files
         matched by the match function
 
         results are yielded in a tuple (src, filename, st), where src
         is one of:
         'f' the file was found in the directory tree
         'd' the file is a directory of the tree
         'm' the file was only in the dirstate and not in the tree
         'b' file was not found and matched badmatch
 
         and st is the stat result if the file was found in the directory.
         '''
 
         # walk all files by default
         if not files:
             files = ['.']
             dc = self._map.copy()
         else:
             files = util.unique(files)
             dc = self._filter(files)
 
         def imatch(file_):
             if file_ not in dc and self._ignore(file_):
                 return False
             return match(file_)
 
         ignore = self._ignore
         dirignore = self._dirignore
         if ignored:
             imatch = match
             ignore = util.never
             dirignore = util.never
 
         # self._root may end with a path separator when self._root == '/'
         common_prefix_len = len(self._root)
         if not util.endswithsep(self._root):
             common_prefix_len += 1
 
         normpath = util.normpath
         listdir = osutil.listdir
         lstat = os.lstat
         bisect_left = bisect.bisect_left
         isdir = os.path.isdir
         pconvert = util.pconvert
         join = os.path.join
         s_isdir = stat.S_ISDIR
         supported = self._supported
         _join = self._join
         known = {'.hg': 1}
 
         # recursion free walker, faster than os.walk.
         def findfiles(s):
             work = [s]
             wadd = work.append
             found = []
             add = found.append
             if directories:
                 add((normpath(s[common_prefix_len:]), 'd', lstat(s)))
             while work:
                 top = work.pop()
                 entries = listdir(top, stat=True)
                 # nd is the top of the repository dir tree
                 nd = normpath(top[common_prefix_len:])
                 if nd == '.':
                     nd = ''
                 else:
                     # do not recurse into a repo contained in this
                     # one. use bisect to find .hg directory so speed
                     # is good on big directory.
                     names = [e[0] for e in entries]
                     hg = bisect_left(names, '.hg')
                     if hg < len(names) and names[hg] == '.hg':
                         if isdir(join(top, '.hg')):
                             continue
                 for f, kind, st in entries:
                     np = pconvert(join(nd, f))
                     if np in known:
                         continue
                     known[np] = 1
                     p = join(top, f)
                     # don't trip over symlinks
                     if kind == stat.S_IFDIR:
                         if not ignore(np):
                             wadd(p)
                             if directories:
                                 add((np, 'd', st))
                         if np in dc and match(np):
                             add((np, 'm', st))
                     elif imatch(np):
                         if supported(np, st.st_mode):
                             add((np, 'f', st))
                         elif np in dc:
                             add((np, 'm', st))
             found.sort()
             return found
 
         # step one, find all files that match our criteria
         files.sort()
         for ff in files:
             nf = normpath(ff)
             f = _join(ff)
             try:
                 st = lstat(f)
             except OSError, inst:
                 found = False
                 for fn in dc:
                     if nf == fn or (fn.startswith(nf) and fn[len(nf)] == '/'):
                         found = True
                         break
                 if not found:
                     if inst.errno != errno.ENOENT or not badmatch:
                         self._ui.warn('%s: %s\n' %
                                       (self.pathto(ff), inst.strerror))
                     elif badmatch and badmatch(ff) and imatch(nf):
                         yield 'b', ff, None
                 continue
             if s_isdir(st.st_mode):
                 if not dirignore(nf):
                     for f, src, st in findfiles(f):
                         yield src, f, st
             else:
                 if nf in known:
                     continue
                 known[nf] = 1
                 if match(nf):
                     if supported(ff, st.st_mode, verbose=True):
                         yield 'f', nf, st
                     elif ff in dc:
                         yield 'm', nf, st
 
         # step two run through anything left in the dc hash and yield
         # if we haven't already seen it
         ks = dc.keys()
         ks.sort()
         for k in ks:
             if k in known:
                 continue
             known[k] = 1
             if imatch(k):
                 yield 'm', k, None
 
     def status(self, files, match, list_ignored, list_clean):
         lookup, modified, added, unknown, ignored = [], [], [], [], []
         removed, deleted, clean = [], [], []
 
         files = files or []
         _join = self._join
         lstat = os.lstat
         cmap = self._copymap
         dmap = self._map
         ladd = lookup.append
         madd = modified.append
         aadd = added.append
         uadd = unknown.append
         iadd = ignored.append
         radd = removed.append
         dadd = deleted.append
         cadd = clean.append
 
         for src, fn, st in self.statwalk(files, match, ignored=list_ignored):
             if fn in dmap:
                 type_, mode, size, time, foo = dmap[fn]
             else:
                 if (list_ignored or fn in files) and self._dirignore(fn):
                     if list_ignored:
                         iadd(fn)
                 else:
                     uadd(fn)
                 continue
             if src == 'm':
                 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
                 # XXX: what to do with file no longer present in the fs
                 # who are not removed in the dirstate ?
-                if nonexistent and type_ in "nm":
+                if nonexistent and type_ in "nma":
                     dadd(fn)
                     continue
             # check the common case first
             if type_ == 'n':
                 if not st:
                     st = lstat(_join(fn))
                 if (size >= 0 and (size != st.st_size
                                    or (mode ^ st.st_mode) & 0100)
                     or size == -2
                     or fn in self._copymap):
                     madd(fn)
                 elif time != int(st.st_mtime):
                     ladd(fn)
                 elif list_clean:
                     cadd(fn)
             elif type_ == 'm':
                 madd(fn)
             elif type_ == 'a':
                 aadd(fn)
             elif type_ == 'r':
                 radd(fn)
 
         return (lookup, modified, added, removed, deleted, unknown, ignored,
                 clean)

tests/test-commit

@@ -1,92 +1,93 b''
 #!/bin/sh
 
 cleanpath()
 {
     sed -e "s:/.*\(/test/.*\):...\1:"
 }
 
 echo % commit date test
 hg init test
 cd test
 echo foo > foo
 hg add foo
 HGEDITOR=true hg commit -m ""
 hg commit -d '0 0' -m commit-1
 echo foo >> foo
 hg commit -d '1 4444444' -m commit-3
 hg commit -d '1	15.1' -m commit-4
 hg commit -d 'foo bar' -m commit-5
 hg commit -d ' 1 4444' -m commit-6
 hg commit -d '111111111111 0' -m commit-7
 
-echo % partial commit test
+echo % commit added file that has been deleted
 echo bar > bar
 hg add bar
 rm bar
 hg commit -d "1000000 0" -m commit-8 2>&1 | cleanpath
+hg commit -d "1000000 0" -m commit-8 bar 2>&1 | cleanpath
 
 hg -q revert -a --no-backup
 
 mkdir dir
 echo boo > dir/file
 hg add
 hg -v commit -d '0 0' -m commit-9 dir
 
 echo > dir.file
 hg add
 hg commit -d '0 0' -m commit-10 dir dir.file 2>&1 | cleanpath
 
 echo >> dir/file
 mkdir bleh
 mkdir dir2
 cd bleh
 hg commit -d '0 0' -m commit-11 . 2>&1 | cleanpath
 hg commit -d '0 0' -m commit-12 ../dir ../dir2 2>&1 | cleanpath
 hg -v commit -d '0 0' -m commit-13 ../dir
 cd ..
 
 hg commit -d '0 0' -m commit-14 does-not-exist 2>&1 | cleanpath
 ln -s foo baz
 hg commit -d '0 0' -m commit-15 baz 2>&1 | cleanpath
 touch quux
 hg commit -d '0 0' -m commit-16 quux 2>&1 | cleanpath
 echo >> dir/file
 hg -v commit -d '0 0' -m commit-17 dir/file
 cd ..
 
 echo % partial subdir commit test
 hg init test2
 cd test2
 mkdir foo
 echo foo > foo/foo
 mkdir bar
 echo bar > bar/bar
 hg add
 hg ci -d '1000000 0' -u test -m commit-subdir-1 foo
 hg ci -d '1000001 0' -u test -m commit-subdir-2 bar
 echo % subdir log 1
 hg log -v foo
 echo % subdir log 2
 hg log -v bar
 echo % full log
 hg log -v
 cd ..
 
 echo % dot and subdir commit test
 hg init test3
 cd test3
 mkdir foo
 echo foo content > foo/plain-file
 hg add foo/plain-file
 hg ci -d '1000000 0' -u test -m commit-foo-subdir foo
 echo modified foo content > foo/plain-file
 hg ci -d '2000000 0' -u test -m commit-foo-dot .
 echo % full log
 hg log -v
 echo % subdir log
 cd foo
 hg log .
 cd ..
 cd ..
 
 exit 0

tests/test-commit.out

@@ -1,100 +1,100 b''
 % commit date test
 transaction abort!
 rollback completed
 abort: empty commit message
 transaction abort!
 rollback completed
 abort: impossible time zone offset: 4444444
 transaction abort!
 rollback completed
 abort: invalid date: '1\t15.1' 
 transaction abort!
 rollback completed
 abort: invalid date: 'foo bar' 
 nothing changed
-% partial commit test
-trouble committing bar!
-abort: No such file or directory: .../test/bar
+% commit added file that has been deleted
+nothing changed
+abort: file .../test/bar not found!
 adding dir/file
 dir/file
 adding dir.file
 abort: no match under directory .../test/dir!
 abort: no match under directory .../test/bleh!
 abort: no match under directory .../test/dir2!
 dir/file
 does-not-exist: No such file or directory
 abort: file .../test/does-not-exist not found!
 abort: file .../test/baz not tracked!
 abort: file .../test/quux not tracked!
 dir/file
 % partial subdir commit test
 adding bar/bar
 adding foo/foo
 % subdir log 1
 changeset:   0:6ef3cb06bb80
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 files:       foo/foo
 description:
 commit-subdir-1
 
 
 % subdir log 2
 changeset:   1:f2e51572cf5a
 tag:         tip
 user:        test
 date:        Mon Jan 12 13:46:41 1970 +0000
 files:       bar/bar
 description:
 commit-subdir-2
 
 
 % full log
 changeset:   1:f2e51572cf5a
 tag:         tip
 user:        test
 date:        Mon Jan 12 13:46:41 1970 +0000
 files:       bar/bar
 description:
 commit-subdir-2
 
 
 changeset:   0:6ef3cb06bb80
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 files:       foo/foo
 description:
 commit-subdir-1
 
 
 % dot and subdir commit test
 % full log
 changeset:   1:d9180e04fa8a
 tag:         tip
 user:        test
 date:        Sat Jan 24 03:33:20 1970 +0000
 files:       foo/plain-file
 description:
 commit-foo-dot
 
 
 changeset:   0:80b572aaf098
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 files:       foo/plain-file
 description:
 commit-foo-subdir
 
 
 % subdir log
 changeset:   1:d9180e04fa8a
 tag:         tip
 user:        test
 date:        Sat Jan 24 03:33:20 1970 +0000
 summary:     commit-foo-dot
 
 changeset:   0:80b572aaf098
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     commit-foo-subdir
 

tests/test-revert

@@ -1,151 +1,151 b''
 #!/bin/sh
 
 hg init repo
 cd repo
 echo 123 > a
 echo 123 > c
 echo 123 > e
 hg add a c e
 hg commit -m "first" -d "1000000 0" a c e
 echo 123 > b
 echo %% should show b unknown
 hg status
 echo 12 > c
 echo %% should show b unknown and c modified
 hg status
 hg add b
 echo %% should show b added and c modified
 hg status
 hg rm a
 echo %% should show a removed, b added and c modified
 hg status
 hg revert a
 echo %% should show b added, copy saved, and c modified
 hg status
 hg revert b
 echo %% should show b unknown, and c modified
 hg status
 hg revert --no-backup c
 echo %% should show unknown: b
 hg status
 hg add b
 echo %% should show b added
 hg status b
 rm b
-echo %% should show b added
+echo %% should show b deleted
 hg status b
 hg revert -v b
 echo %% should not find b
 hg status b
 echo %% should show a c e
 ls
 echo %% should verbosely save backup to e.orig
 echo z > e
 hg revert --all -v
 echo %% should say no changes needed
 hg revert a
 echo %% should say file not managed
 echo q > q
 hg revert q
 rm q
 echo %% should say file not found
 hg revert notfound
 touch d
 hg add d
 hg rm a
 hg commit -m "second" -d "1000000 0"
 echo z > z
 hg add z
 hg st
 echo %% should add a, remove d, forget z
 hg revert --all -r0
 echo %% should forget a, undelete d
 hg revert --all -rtip
 rm a *.orig
 echo %% should silently add a
 hg revert -r0 a
 hg st a
 hg rm d
 hg st d
 echo %% should silently keep d removed
 hg revert -r0 d
 hg st d
 
 hg update -C
 chmod +x c
 hg revert --all
 echo %% should print non-executable
 test -x c || echo non-executable
 
 chmod +x c
 hg commit -d '1000001 0' -m exe
 
 chmod -x c
 hg revert --all
 echo %% should print executable
 test -x c && echo executable
 
 cd ..
 
 echo %% issue 241
 hg init a
 cd a
 echo a >> a
 hg commit -A -d '1 0' -m a
 echo a >> a
 hg commit -d '2 0' -m a
 hg update 0
 mkdir b
 echo b > b/b
 
 echo % should fail - no arguments
 hg revert -rtip
 
 echo % should succeed
 hg revert --all -rtip
 
 echo %% issue332
 hg ci -A -m b -d '1000001 0'
 echo foobar > b/b
 mkdir newdir
 echo foo > newdir/newfile
 hg add newdir/newfile
 hg revert b newdir
 echo foobar > b/b
 hg revert .
 
 echo % reverting a rename target should revert the source
 hg mv a newa
 hg revert newa
 hg st a newa
 
 cd ..
 
 hg init ignored
 cd ignored
 echo '^ignored$' > .hgignore
 echo '^ignoreddir$' >> .hgignore
 echo '^removed$' >> .hgignore
 
 mkdir ignoreddir
 touch ignoreddir/file
 touch ignoreddir/removed
 touch ignored
 touch removed
 echo '%% 4 ignored files (we will add/commit everything)'
 hg st -A -X .hgignore
 hg ci -qAm 'add files' ignored ignoreddir/file ignoreddir/removed removed
 
 echo >> ignored
 echo >> ignoreddir/file
 hg rm removed ignoreddir/removed
 echo '%% should revert ignored* and undelete *removed'
 hg revert -a --no-backup
 hg st -mardi
 
 hg up -qC
 echo >> ignored
 hg rm removed
 echo %% should silently revert the named files
 hg revert --no-backup ignored removed
 hg st -mardi

tests/test-revert.out

@@ -1,86 +1,86 b''
 %% should show b unknown
 ? b
 %% should show b unknown and c modified
 M c
 ? b
 %% should show b added and c modified
 M c
 A b
 %% should show a removed, b added and c modified
 M c
 A b
 R a
 %% should show b added, copy saved, and c modified
 M c
 A b
 %% should show b unknown, and c modified
 M c
 ? b
 %% should show unknown: b
 ? b
 %% should show b added
 A b
-%% should show b added
-A b
+%% should show b deleted
+! b
 forgetting b
 %% should not find b
 b: No such file or directory
 %% should show a c e
 a
 c
 e
 %% should verbosely save backup to e.orig
 saving current version of e as e.orig
 reverting e
 %% should say no changes needed
 no changes needed to a
 %% should say file not managed
 file not managed: q
 %% should say file not found
 notfound: No such file in rev 095eacd0c0d7
 A z
 ? e.orig
 %% should add a, remove d, forget z
 adding a
 removing d
 forgetting z
 %% should forget a, undelete d
 forgetting a
 undeleting d
 %% should silently add a
 A a
 R d
 %% should silently keep d removed
 R d
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 reverting c
 %% should print non-executable
 non-executable
 reverting c
 %% should print executable
 executable
 %% issue 241
 adding a
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 % should fail - no arguments
 abort: no files or directories specified; use --all to revert the whole repo
 % should succeed
 reverting a
 %% issue332
 adding b/b
 reverting b/b
 forgetting newdir/newfile
 reverting b/b
 % reverting a rename target should revert the source
 ? newa
 %% 4 ignored files (we will add/commit everything)
 I ignored
 I ignoreddir/file
 I ignoreddir/removed
 I removed
 %% should revert ignored* and undelete *removed
 reverting ignored
 reverting ignoreddir/file
 undeleting ignoreddir/removed
 undeleting removed
 %% should silently revert the named files