largefiles: ignore removal status of files not managed in the target context

Before this patch, "hg status --rev REV" listed largefiles removed in
the working directory up with "R" mark, even if they aren't managed in
the REV. Normal files aren't listed up in such case.

When "lfilesrepo.status" is invoked for "hg status --rev REV", it
treats files on conditions below as "removed" (to avoid manifest full
scan in "ctx.status" ?):

  - marked as "R" in lfdirstate, or

  - files managed in the target revision but unknown in the manifest
    of the working context (= not including "R" files)

But the former can include files not managed in the target context.

To ignore removal status of files not managed in the target context,
this patch drops files unknown in the target revision from "removed"
list.

hgext/largefiles/reposetup.py

@@ -1,470 +1,477 b''
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''setup for largefiles repositories: reposetup'''
 import copy
 import os
 
 from mercurial import error, manifest, match as match_, util
 from mercurial.i18n import _
 from mercurial import localrepo, scmutil
 
 import lfcommands
 import lfutil
 
 def reposetup(ui, repo):
     # wire repositories should be given new wireproto functions
     # by "proto.wirereposetup()" via "hg.wirepeersetupfuncs"
     if not repo.local():
         return
 
     class lfilesrepo(repo.__class__):
         lfstatus = False
         def status_nolfiles(self, *args, **kwargs):
             return super(lfilesrepo, self).status(*args, **kwargs)
 
         # When lfstatus is set, return a context that gives the names
         # of largefiles instead of their corresponding standins and
         # identifies the largefiles as always binary, regardless of
         # their actual contents.
         def __getitem__(self, changeid):
             ctx = super(lfilesrepo, self).__getitem__(changeid)
             if self.lfstatus:
                 class lfilesmanifestdict(manifest.manifestdict):
                     def __contains__(self, filename):
                         orig = super(lfilesmanifestdict, self).__contains__
                         return orig(filename) or orig(lfutil.standin(filename))
                 class lfilesctx(ctx.__class__):
                     def files(self):
                         filenames = super(lfilesctx, self).files()
                         return [lfutil.splitstandin(f) or f for f in filenames]
                     def manifest(self):
                         man1 = super(lfilesctx, self).manifest()
                         man1.__class__ = lfilesmanifestdict
                         return man1
                     def filectx(self, path, fileid=None, filelog=None):
                         orig = super(lfilesctx, self).filectx
                         try:
                             if filelog is not None:
                                 result = orig(path, fileid, filelog)
                             else:
                                 result = orig(path, fileid)
                         except error.LookupError:
                             # Adding a null character will cause Mercurial to
                             # identify this as a binary file.
                             if filelog is not None:
                                 result = orig(lfutil.standin(path), fileid,
                                               filelog)
                             else:
                                 result = orig(lfutil.standin(path), fileid)
                             olddata = result.data
                             result.data = lambda: olddata() + '\0'
                         return result
                 ctx.__class__ = lfilesctx
             return ctx
 
         # Figure out the status of big files and insert them into the
         # appropriate list in the result. Also removes standin files
         # from the listing. Revert to the original status if
         # self.lfstatus is False.
         # XXX large file status is buggy when used on repo proxy.
         # XXX this needs to be investigated.
         @localrepo.unfilteredmethod
         def status(self, node1='.', node2=None, match=None, ignored=False,
                 clean=False, unknown=False, listsubrepos=False):
             listignored, listclean, listunknown = ignored, clean, unknown
             orig = super(lfilesrepo, self).status
             if not self.lfstatus:
                 return orig(node1, node2, match, listignored, listclean,
                             listunknown, listsubrepos)
 
             # some calls in this function rely on the old version of status
             self.lfstatus = False
             ctx1 = self[node1]
             ctx2 = self[node2]
             working = ctx2.rev() is None
             parentworking = working and ctx1 == self['.']
 
             if match is None:
                 match = match_.always(self.root, self.getcwd())
 
             wlock = None
             try:
                 try:
                     # updating the dirstate is optional
                     # so we don't wait on the lock
                     wlock = self.wlock(False)
                 except error.LockError:
                     pass
 
                 # First check if there were files specified on the
                 # command line.  If there were, and none of them were
                 # largefiles, we should just bail here and let super
                 # handle it -- thus gaining a big performance boost.
                 lfdirstate = lfutil.openlfdirstate(ui, self)
                 if match.files() and not match.anypats():
                     for f in lfdirstate:
                         if match(f):
                             break
                     else:
                         return orig(node1, node2, match, listignored, listclean,
                                     listunknown, listsubrepos)
 
                 # Create a copy of match that matches standins instead
                 # of largefiles.
                 def tostandins(files):
                     if not working:
                         return files
                     newfiles = []
                     dirstate = self.dirstate
                     for f in files:
                         sf = lfutil.standin(f)
                         if sf in dirstate:
                             newfiles.append(sf)
                         elif sf in dirstate.dirs():
                             # Directory entries could be regular or
                             # standin, check both
                             newfiles.extend((f, sf))
                         else:
                             newfiles.append(f)
                     return newfiles
 
                 m = copy.copy(match)
                 m._files = tostandins(m._files)
 
                 result = orig(node1, node2, m, ignored, clean, unknown,
                               listsubrepos)
                 if working:
 
                     def sfindirstate(f):
                         sf = lfutil.standin(f)
                         dirstate = self.dirstate
                         return sf in dirstate or sf in dirstate.dirs()
 
                     match._files = [f for f in match._files
                                     if sfindirstate(f)]
                     # Don't waste time getting the ignored and unknown
                     # files from lfdirstate
                     unsure, s = lfdirstate.status(match, [], False, listclean,
                                                   False)
                     (modified, added, removed, clean) = (s.modified, s.added,
                                                          s.removed, s.clean)
                     if parentworking:
                         for lfile in unsure:
                             standin = lfutil.standin(lfile)
                             if standin not in ctx1:
                                 # from second parent
                                 modified.append(lfile)
                             elif ctx1[standin].data().strip() \
                                     != lfutil.hashfile(self.wjoin(lfile)):
                                 modified.append(lfile)
                             else:
                                 if listclean:
                                     clean.append(lfile)
                                 lfdirstate.normal(lfile)
                     else:
                         tocheck = unsure + modified + added + clean
                         modified, added, clean = [], [], []
 
                         for lfile in tocheck:
                             standin = lfutil.standin(lfile)
                             if standin in ctx1:
                                 if ctx1[standin].data().strip() != \
                                         lfutil.hashfile(self.wjoin(lfile)):
                                     modified.append(lfile)
                                 elif listclean:
                                     clean.append(lfile)
                             else:
                                 added.append(lfile)
 
+                        # at this point, 'removed' contains largefiles
+                        # marked as 'R' in the working context.
+                        # then, largefiles not managed also in the target
+                        # context should be excluded from 'removed'.
+                        removed = [lfile for lfile in removed
+                                   if lfutil.standin(lfile) in ctx1]
+
                     # Standins no longer found in lfdirstate has been
                     # removed
                     for standin in ctx1.walk(lfutil.getstandinmatcher(self)):
                         lfile = lfutil.splitstandin(standin)
                         if not match(lfile):
                             continue
                         if lfile not in lfdirstate:
                             removed.append(lfile)
 
                     # Filter result lists
                     result = list(result)
 
                     # Largefiles are not really removed when they're
                     # still in the normal dirstate. Likewise, normal
                     # files are not really removed if they are still in
                     # lfdirstate. This happens in merges where files
                     # change type.
                     removed = [f for f in removed
                                if f not in self.dirstate]
                     result[2] = [f for f in result[2]
                                  if f not in lfdirstate]
 
                     lfiles = set(lfdirstate._map)
                     # Unknown files
                     result[4] = set(result[4]).difference(lfiles)
                     # Ignored files
                     result[5] = set(result[5]).difference(lfiles)
                     # combine normal files and largefiles
                     normals = [[fn for fn in filelist
                                 if not lfutil.isstandin(fn)]
                                for filelist in result]
                     lfstatus = (modified, added, removed, s.deleted, [], [],
                                 clean)
                     result = [sorted(list1 + list2)
                               for (list1, list2) in zip(normals, lfstatus)]
                 else: # not against working directory
                     result = [[lfutil.splitstandin(f) or f for f in items]
                               for items in result]
 
                 if wlock:
                     lfdirstate.write()
 
             finally:
                 if wlock:
                     wlock.release()
 
             self.lfstatus = True
             return scmutil.status(*result)
 
         # As part of committing, copy all of the largefiles into the
         # cache.
         def commitctx(self, *args, **kwargs):
             node = super(lfilesrepo, self).commitctx(*args, **kwargs)
             lfutil.copyalltostore(self, node)
             return node
 
         # Before commit, largefile standins have not had their
         # contents updated to reflect the hash of their largefile.
         # Do that here.
         def commit(self, text="", user=None, date=None, match=None,
                 force=False, editor=False, extra={}):
             orig = super(lfilesrepo, self).commit
 
             wlock = self.wlock()
             try:
                 # Case 0: Automated committing
                 #
                 # While automated committing (like rebase, transplant
                 # and so on), this code path is used to avoid:
                 # (1) updating standins, because standins should
                 #     be already updated at this point
                 # (2) aborting when stadnins are matched by "match",
                 #     because automated committing may specify them directly
                 #
                 if getattr(self, "_isrebasing", False) or \
                         getattr(self, "_istransplanting", False):
                     result = orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
 
                     if result:
                         lfdirstate = lfutil.openlfdirstate(ui, self)
                         for f in self[result].files():
                             if lfutil.isstandin(f):
                                 lfile = lfutil.splitstandin(f)
                                 lfutil.synclfdirstate(self, lfdirstate, lfile,
                                                       False)
                         lfdirstate.write()
 
                     return result
                 # Case 1: user calls commit with no specific files or
                 # include/exclude patterns: refresh and commit all files that
                 # are "dirty".
                 if ((match is None) or
                     (not match.anypats() and not match.files())):
                     # Spend a bit of time here to get a list of files we know
                     # are modified so we can compare only against those.
                     # It can cost a lot of time (several seconds)
                     # otherwise to update all standins if the largefiles are
                     # large.
                     lfdirstate = lfutil.openlfdirstate(ui, self)
                     dirtymatch = match_.always(self.root, self.getcwd())
                     unsure, s = lfdirstate.status(dirtymatch, [], False, False,
                                                   False)
                     modifiedfiles = unsure + s.modified + s.added + s.removed
                     lfiles = lfutil.listlfiles(self)
                     # this only loops through largefiles that exist (not
                     # removed/renamed)
                     for lfile in lfiles:
                         if lfile in modifiedfiles:
                             if os.path.exists(
                                     self.wjoin(lfutil.standin(lfile))):
                                 # this handles the case where a rebase is being
                                 # performed and the working copy is not updated
                                 # yet.
                                 if os.path.exists(self.wjoin(lfile)):
                                     lfutil.updatestandin(self,
                                         lfutil.standin(lfile))
                                     lfdirstate.normal(lfile)
 
                     result = orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
 
                     if result is not None:
                         for lfile in lfdirstate:
                             if lfile in modifiedfiles:
                                 if (not os.path.exists(self.wjoin(
                                    lfutil.standin(lfile)))) or \
                                    (not os.path.exists(self.wjoin(lfile))):
                                     lfdirstate.drop(lfile)
 
                     # This needs to be after commit; otherwise precommit hooks
                     # get the wrong status
                     lfdirstate.write()
                     return result
 
                 lfiles = lfutil.listlfiles(self)
                 match._files = self._subdirlfs(match.files(), lfiles)
 
                 # Case 2: user calls commit with specified patterns: refresh
                 # any matching big files.
                 smatcher = lfutil.composestandinmatcher(self, match)
                 standins = self.dirstate.walk(smatcher, [], False, False)
 
                 # No matching big files: get out of the way and pass control to
                 # the usual commit() method.
                 if not standins:
                     return orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
 
                 # Refresh all matching big files.  It's possible that the
                 # commit will end up failing, in which case the big files will
                 # stay refreshed.  No harm done: the user modified them and
                 # asked to commit them, so sooner or later we're going to
                 # refresh the standins.  Might as well leave them refreshed.
                 lfdirstate = lfutil.openlfdirstate(ui, self)
                 for standin in standins:
                     lfile = lfutil.splitstandin(standin)
                     if lfdirstate[lfile] != 'r':
                         lfutil.updatestandin(self, standin)
                         lfdirstate.normal(lfile)
                     else:
                         lfdirstate.drop(lfile)
 
                 # Cook up a new matcher that only matches regular files or
                 # standins corresponding to the big files requested by the
                 # user.  Have to modify _files to prevent commit() from
                 # complaining "not tracked" for big files.
                 match = copy.copy(match)
                 origmatchfn = match.matchfn
 
                 # Check both the list of largefiles and the list of
                 # standins because if a largefile was removed, it
                 # won't be in the list of largefiles at this point
                 match._files += sorted(standins)
 
                 actualfiles = []
                 for f in match._files:
                     fstandin = lfutil.standin(f)
 
                     # ignore known largefiles and standins
                     if f in lfiles or fstandin in standins:
                         continue
 
                     actualfiles.append(f)
                 match._files = actualfiles
 
                 def matchfn(f):
                     if origmatchfn(f):
                         return f not in lfiles
                     else:
                         return f in standins
 
                 match.matchfn = matchfn
                 result = orig(text=text, user=user, date=date, match=match,
                                 force=force, editor=editor, extra=extra)
                 # This needs to be after commit; otherwise precommit hooks
                 # get the wrong status
                 lfdirstate.write()
                 return result
             finally:
                 wlock.release()
 
         def push(self, remote, force=False, revs=None, newbranch=False):
             if remote.local():
                 missing = set(self.requirements) - remote.local().supported
                 if missing:
                     msg = _("required features are not"
                             " supported in the destination:"
                             " %s") % (', '.join(sorted(missing)))
                     raise util.Abort(msg)
             return super(lfilesrepo, self).push(remote, force=force, revs=revs,
                 newbranch=newbranch)
 
         def _subdirlfs(self, files, lfiles):
             '''
             Adjust matched file list
             If we pass a directory to commit whose only commitable files
             are largefiles, the core commit code aborts before finding
             the largefiles.
             So we do the following:
             For directories that only have largefiles as matches,
             we explicitly add the largefiles to the match list and remove
             the directory.
             In other cases, we leave the match list unmodified.
             '''
             actualfiles = []
             dirs = []
             regulars = []
 
             for f in files:
                 if lfutil.isstandin(f + '/'):
                     raise util.Abort(
                         _('file "%s" is a largefile standin') % f,
                         hint=('commit the largefile itself instead'))
                 # Scan directories
                 if os.path.isdir(self.wjoin(f)):
                     dirs.append(f)
                 else:
                     regulars.append(f)
 
             for f in dirs:
                 matcheddir = False
                 d = self.dirstate.normalize(f) + '/'
                 # Check for matched normal files
                 for mf in regulars:
                     if self.dirstate.normalize(mf).startswith(d):
                         actualfiles.append(f)
                         matcheddir = True
                         break
                 if not matcheddir:
                     # If no normal match, manually append
                     # any matching largefiles
                     for lf in lfiles:
                         if self.dirstate.normalize(lf).startswith(d):
                             actualfiles.append(lf)
                             if not matcheddir:
                                 actualfiles.append(lfutil.standin(f))
                                 matcheddir = True
                 # Nothing in dir, so readd it
                 # and let commit reject it
                 if not matcheddir:
                     actualfiles.append(f)
 
             # Always add normal files
             actualfiles += regulars
             return actualfiles
 
     repo.__class__ = lfilesrepo
 
     def prepushoutgoinghook(local, remote, outgoing):
         if outgoing.missing:
             toupload = set()
             addfunc = lambda fn, lfhash: toupload.add(lfhash)
             lfutil.getlfilestoupload(local, outgoing.missing, addfunc)
             lfcommands.uploadlfiles(ui, local, remote, toupload)
     repo.prepushoutgoinghooks.add("largefiles", prepushoutgoinghook)
 
     def checkrequireslfiles(ui, repo, **kwargs):
         if 'largefiles' not in repo.requirements and util.any(
                 lfutil.shortname+'/' in f[0] for f in repo.store.datafiles()):
             repo.requirements.add('largefiles')
             repo._writerequirements()
 
     ui.setconfig('hooks', 'changegroup.lfiles', checkrequireslfiles,
                  'largefiles')
     ui.setconfig('hooks', 'commit.lfiles', checkrequireslfiles, 'largefiles')

tests/test-largefiles-update.t

@@ -1,546 +1,555 b''
 This file focuses mainly on updating largefiles in the working
 directory (and ".hg/largefiles/dirstate")
 
   $ cat >> $HGRCPATH <<EOF
   > [ui]
   > merge = internal:fail
   > [extensions]
   > largefiles =
   > EOF
 
   $ hg init repo
   $ cd repo
 
   $ echo large1 > large1
   $ echo large2 > large2
   $ hg add --large large1 large2
   $ echo normal1 > normal1
   $ hg add normal1
   $ hg commit -m '#0'
   $ echo 'large1 in #1' > large1
   $ echo 'normal1 in #1' > normal1
   $ hg commit -m '#1'
   $ hg update -q -C 0
   $ echo 'large2 in #2' > large2
   $ hg commit -m '#2'
   created new head
 
 Test that "hg merge" updates largefiles from "other" correctly
 
 (getting largefiles from "other" normally)
 
   $ hg status -A large1
   C large1
   $ cat large1
   large1
   $ cat .hglf/large1
   4669e532d5b2c093a78eca010077e708a071bb64
   $ hg merge --config debug.dirstate.delaywrite=2
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status -A large1
   M large1
   $ cat large1
   large1 in #1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ hg diff -c 1 --nodates .hglf/large1 | grep '^[+-][0-9a-z]'
   -4669e532d5b2c093a78eca010077e708a071bb64
   +58e24f733a964da346e2407a2bee99d9001184f5
 
 (getting largefiles from "other" via conflict prompt)
 
   $ hg update -q -C 2
   $ echo 'large1 in #3' > large1
   $ echo 'normal1 in #3' > normal1
   $ hg commit -m '#3'
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ hg merge --config debug.dirstate.delaywrite=2 --config ui.interactive=True <<EOF
   > o
   > EOF
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal e5bb990443d6a92aaf7223813720f7566c9dd05b or
   take (o)ther 58e24f733a964da346e2407a2bee99d9001184f5? o
   merging normal1
   warning: conflicts during merge.
   merging normal1 incomplete! (edit conflicts, then use 'hg resolve --mark')
   getting changed largefiles
   1 largefiles updated, 0 removed
   0 files updated, 1 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ hg status -A large1
   M large1
   $ cat large1
   large1 in #1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
 
 Test that "hg revert -r REV" updates largefiles from "REV" correctly
 
   $ hg update -q -C 3
   $ hg status -A large1
   C large1
   $ cat large1
   large1 in #3
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ hg diff -c 1 --nodates .hglf/large1 | grep '^[+-][0-9a-z]'
   -4669e532d5b2c093a78eca010077e708a071bb64
   +58e24f733a964da346e2407a2bee99d9001184f5
   $ hg revert --no-backup -r 1 --config debug.dirstate.delaywrite=2 large1
   $ hg status -A large1
   M large1
   $ cat large1
   large1 in #1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
 
 Test that "hg rollback" restores status of largefiles correctly
 
   $ hg update -C -q
   $ hg remove large1
   $ test -f .hglf/large1
   [1]
   $ hg forget large2
   $ test -f .hglf/large2
   [1]
   $ echo largeX > largeX
   $ hg add --large largeX
   $ cat .hglf/largeX
   
   $ hg commit -m 'will be rollback-ed soon'
   $ echo largeY > largeY
   $ hg add --large largeY
 #if windows
   $ hg status -A large1
   large1: * (glob)
 #else
   $ hg status -A large1
   large1: No such file or directory
 #endif
   $ hg status -A large2
   ? large2
   $ hg status -A largeX
   C largeX
   $ hg status -A largeY
   A largeY
   $ hg rollback
   repository tip rolled back to revision 3 (undo commit)
   working directory now based on revision 3
   $ hg status -A large1
   R large1
   $ test -f .hglf/large1
   [1]
   $ hg status -A large2
   R large2
   $ test -f .hglf/large2
   [1]
   $ hg status -A largeX
   A largeX
   $ cat .hglf/largeX
   
   $ hg status -A largeY
   ? largeY
   $ test -f .hglf/largeY
   [1]
 
 Test that "hg rollback" restores standins correctly
 
   $ hg commit -m 'will be rollback-ed soon'
   $ hg update -q -C 2
   $ cat large1
   large1
   $ cat .hglf/large1
   4669e532d5b2c093a78eca010077e708a071bb64
   $ cat large2
   large2 in #2
   $ cat .hglf/large2
   3cfce6277e7668985707b6887ce56f9f62f6ccd9
 
   $ hg rollback -q -f
   $ cat large1
   large1
   $ cat .hglf/large1
   4669e532d5b2c093a78eca010077e708a071bb64
   $ cat large2
   large2 in #2
   $ cat .hglf/large2
   3cfce6277e7668985707b6887ce56f9f62f6ccd9
 
 (rollback the parent of the working directory, when the parent of it
 is not branch-tip)
 
   $ hg update -q -C 1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ cat .hglf/large2
   1deebade43c8c498a3c8daddac0244dc55d1331d
 
   $ echo normalX > normalX
   $ hg add normalX
   $ hg commit -m 'will be rollback-ed soon'
   $ hg rollback -q
 
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ cat .hglf/large2
   1deebade43c8c498a3c8daddac0244dc55d1331d
 
 Test that "hg status" shows status of largefiles correctly just after
 automated commit like rebase/transplant
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > rebase =
   > strip =
   > transplant =
   > EOF
   $ hg update -q -C 1
   $ hg remove large1
   $ echo largeX > largeX
   $ hg add --large largeX
   $ hg commit -m '#4'
 
   $ hg rebase -s 1 -d 2 --keep
 #if windows
   $ hg status -A large1
   large1: * (glob)
 #else
   $ hg status -A large1
   large1: No such file or directory
 #endif
   $ hg status -A largeX
   C largeX
   $ hg strip -q 5
 
   $ hg update -q -C 2
   $ hg transplant -q 1 4
 #if windows
   $ hg status -A large1
   large1: * (glob)
 #else
   $ hg status -A large1
   large1: No such file or directory
 #endif
   $ hg status -A largeX
   C largeX
   $ hg strip -q 5
 
   $ hg update -q -C 2
   $ hg transplant -q --merge 1 --merge 4
 #if windows
   $ hg status -A large1
   large1: * (glob)
 #else
   $ hg status -A large1
   large1: No such file or directory
 #endif
   $ hg status -A largeX
   C largeX
   $ hg strip -q 5
 
 Test that linear merge can detect modification (and conflict) correctly
 
 (linear merge without conflict)
 
   $ echo 'large2 for linear merge (no conflict)' > large2
   $ hg update 3 --config debug.dirstate.delaywrite=2
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -A large2
   M large2
   $ cat large2
   large2 for linear merge (no conflict)
   $ cat .hglf/large2
   9c4bf8f1b33536d6e5f89447e10620cfe52ea710
 
 (linear merge with conflict, choosing "other")
 
   $ hg update -q -C 2
   $ echo 'large1 for linear merge (conflict)' > large1
   $ hg update 3 --config ui.interactive=True <<EOF
   > o
   > EOF
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? o
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ hg status -A large1
   C large1
   $ cat large1
   large1 in #3
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
 
 (linear merge with conflict, choosing "local")
 
   $ hg update -q -C 2
   $ echo 'large1 for linear merge (conflict)' > large1
   $ hg update 3 --config debug.dirstate.delaywrite=2
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ hg status -A large1
   M large1
   $ cat large1
   large1 for linear merge (conflict)
   $ cat .hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
 
 Test a linear merge to a revision containing same-name normal file
 
   $ hg update -q -C 3
   $ hg remove large2
   $ echo 'large2 as normal file' > large2
   $ hg add large2
   $ echo 'large3 as normal file' > large3
   $ hg add large3
   $ hg commit -m '#5'
   $ hg manifest
   .hglf/large1
   large2
   large3
   normal1
 
 (modified largefile is already switched to normal)
 
   $ hg update -q -C 2
   $ echo 'modified large2 for linear merge' > large2
   $ hg update -q 5
   local changed .hglf/large2 which remote deleted
   use (c)hanged version or (d)elete? c
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   $ hg debugdirstate --nodates | grep large2
   a   0         -1 .hglf/large2
   r   0          0 large2
   $ hg status -A large2
   A large2
   $ cat large2
   modified large2 for linear merge
 
 (added largefile is already committed as normal)
 
   $ hg update -q -C 2
   $ echo 'large3 as large file for linear merge' > large3
   $ hg add --large large3
   $ hg update -q 5
   remote turned local largefile large3 into a normal file
   keep (l)argefile or use (n)ormal file? l
   $ hg debugdirstate --nodates | grep large3
   a   0         -1 .hglf/large3
   r   0          0 large3
   $ hg status -A large3
   A large3
   $ cat large3
   large3 as large file for linear merge
   $ rm -f large3 .hglf/large3
 
 Test that the internal linear merging works correctly
 (both heads are stripped to keep pairing of revision number and commit log)
 
   $ hg update -q -C 2
   $ hg strip 3 4
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/9530e27857f7-backup.hg (glob)
   $ mv .hg/strip-backup/9530e27857f7-backup.hg $TESTTMP
 
 (internal linear merging at "hg pull --update")
 
   $ echo 'large1 for linear merge (conflict)' > large1
   $ echo 'large2 for linear merge (conflict with normal file)' > large2
   $ hg pull --update --config debug.dirstate.delaywrite=2 $TESTTMP/9530e27857f7-backup.hg
   pulling from $TESTTMP/9530e27857f7-backup.hg (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 5 files
   local changed .hglf/large2 which remote deleted
   use (c)hanged version or (d)elete? c
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   2 files updated, 1 files merged, 0 files removed, 0 files unresolved
 
   $ hg status -A large1
   M large1
   $ cat large1
   large1 for linear merge (conflict)
   $ cat .hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
   $ hg status -A large2
   A large2
   $ cat large2
   large2 for linear merge (conflict with normal file)
   $ cat .hglf/large2
   d7591fe9be0f6227d90bddf3e4f52ff41fc1f544
 
 (internal linear merging at "hg unbundle --update")
 
   $ hg update -q -C 2
   $ hg rollback -q
 
   $ echo 'large1 for linear merge (conflict)' > large1
   $ echo 'large2 for linear merge (conflict with normal file)' > large2
   $ hg unbundle --update --config debug.dirstate.delaywrite=2 $TESTTMP/9530e27857f7-backup.hg
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 5 files
   local changed .hglf/large2 which remote deleted
   use (c)hanged version or (d)elete? c
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   2 files updated, 1 files merged, 0 files removed, 0 files unresolved
 
   $ hg status -A large1
   M large1
   $ cat large1
   large1 for linear merge (conflict)
   $ cat .hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
   $ hg status -A large2
   A large2
   $ cat large2
   large2 for linear merge (conflict with normal file)
   $ cat .hglf/large2
   d7591fe9be0f6227d90bddf3e4f52ff41fc1f544
 
 (internal linear merging in subrepo at "hg update")
 
   $ cd ..
   $ hg init subparent
   $ cd subparent
 
   $ hg clone -q -u 2 ../repo sub
   $ cat > .hgsub <<EOF
   > sub = sub
   > EOF
   $ hg add .hgsub
   $ hg commit -m '#0@parent'
   $ cat .hgsubstate
   f74e50bd9e5594b7cf1e6c5cbab86ddd25f3ca2f sub
   $ hg -R sub update -q
   $ hg commit -m '#1@parent'
   $ cat .hgsubstate
   d65e59e952a9638e2ce863b41a420ca723dd3e8d sub
   $ hg update -q 0
 
   $ echo 'large1 for linear merge (conflict)' > sub/large1
   $ echo 'large2 for linear merge (conflict with normal file)' > sub/large2
   $ hg update --config ui.interactive=True --config debug.dirstate.delaywrite=2 <<EOF
   > m
   > r
   > c
   > l
   > l
   > EOF
    subrepository sub diverged (local revision: f74e50bd9e55, remote revision: d65e59e952a9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for sub differ (in checked out version)
   use (l)ocal source (f74e50bd9e55) or (r)emote source (d65e59e952a9)? r
   local changed .hglf/large2 which remote deleted
   use (c)hanged version or (d)elete? c
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   2 files updated, 1 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R sub status -A sub/large1
   M sub/large1
   $ cat sub/large1
   large1 for linear merge (conflict)
   $ cat sub/.hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
   $ hg -R sub status -A sub/large2
   A sub/large2
   $ cat sub/large2
   large2 for linear merge (conflict with normal file)
   $ cat sub/.hglf/large2
   d7591fe9be0f6227d90bddf3e4f52ff41fc1f544
 
   $ cd ..
   $ cd repo
 
 Test that rebase updates largefiles in the working directory even if
 it is aborted by conflict.
 
   $ hg update -q -C 3
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ cat large1
   large1 in #3
   $ hg rebase -s 1 -d 3 --keep --config ui.interactive=True <<EOF
   > o
   > EOF
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal e5bb990443d6a92aaf7223813720f7566c9dd05b or
   take (o)ther 58e24f733a964da346e2407a2bee99d9001184f5? o
   merging normal1
   warning: conflicts during merge.
   merging normal1 incomplete! (edit conflicts, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ cat large1
   large1 in #1
 
   $ hg rebase -q --abort
   rebase aborted
 
 Test that transplant updates largefiles, of which standins are safely
 changed, even if it is aborted by conflict of other.
 
   $ hg update -q -C 5
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ cat large1
   large1 in #3
   $ hg diff -c 4 .hglf/largeX | grep '^[+-][0-9a-z]'
   +fa44618ea25181aff4f48b70428294790cec9f61
   $ hg transplant 4
   applying 07d6153b5c04
   patching file .hglf/large1
   Hunk #1 FAILED at 0
   1 out of 1 hunks FAILED -- saving rejects to file .hglf/large1.rej
   patch failed to apply
   abort: fix up the merge and run hg transplant --continue
   [255]
   $ hg status -A large1
   C large1
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ cat large1
   large1 in #3
   $ hg status -A largeX
   A largeX
   $ cat .hglf/largeX
   fa44618ea25181aff4f48b70428294790cec9f61
   $ cat largeX
   largeX
 
+Test that "hg status" doesn't show removal of largefiles not managed
+in the target context.
+
+  $ hg update -q -C 4
+  $ hg remove largeX
+  $ hg status -A largeX
+  R largeX
+  $ hg status -A --rev '.^1' largeX
+
   $ cd ..