subrepo: add dirtyreason to centralize composing dirty reason message

This patch newly adds "dirtyreason()" to centralize composing dirty
reason message like "uncommitted changes in subrepository 'xxxx'".

There are 3 similar messages below, and this patch is a part of
preparations for unifying them into (1), too.

  1. uncommitted changes in subrepository 'XXXX'
  2. uncommitted changes in subrepository XXXX
  3. uncommitted changes in subrepo XXXX

This patch chooses adding new method "dirtyreason()" instead of making
"dirty()" return "reason string", because:

  - some of existing "dirty()" implementation is too complicated to do
    so simply, and

  - ill-mannered 3rd party subrepo classes, of which "dirty()" doesn't
    return "reason string", cause meaningless message (even though it
    is rare case)

mercurial/localrepo.py

@@ -1,1923 +1,1923 b''
 # localrepo.py - read/write repository class 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 version 2 or any later version.
 from node import hex, nullid, short
 from i18n import _
 import urllib
 import peer, changegroup, subrepo, pushkey, obsolete, repoview
 import changelog, dirstate, filelog, manifest, context, bookmarks, phases
 import lock as lockmod
 import transaction, store, encoding, exchange, bundle2
 import scmutil, util, extensions, hook, error, revset
 import match as matchmod
 import merge as mergemod
 import tags as tagsmod
 from lock import release
 import weakref, errno, os, time, inspect
 import branchmap, pathutil
 import namespaces
 propertycache = util.propertycache
 filecache = scmutil.filecache
 
 class repofilecache(filecache):
     """All filecache usage on repo are done for logic that should be unfiltered
     """
 
     def __get__(self, repo, type=None):
         return super(repofilecache, self).__get__(repo.unfiltered(), type)
     def __set__(self, repo, value):
         return super(repofilecache, self).__set__(repo.unfiltered(), value)
     def __delete__(self, repo):
         return super(repofilecache, self).__delete__(repo.unfiltered())
 
 class storecache(repofilecache):
     """filecache for files in the store"""
     def join(self, obj, fname):
         return obj.sjoin(fname)
 
 class unfilteredpropertycache(propertycache):
     """propertycache that apply to unfiltered repo only"""
 
     def __get__(self, repo, type=None):
         unfi = repo.unfiltered()
         if unfi is repo:
             return super(unfilteredpropertycache, self).__get__(unfi)
         return getattr(unfi, self.name)
 
 class filteredpropertycache(propertycache):
     """propertycache that must take filtering in account"""
 
     def cachevalue(self, obj, value):
         object.__setattr__(obj, self.name, value)
 
 
 def hasunfilteredcache(repo, name):
     """check if a repo has an unfilteredpropertycache value for <name>"""
     return name in vars(repo.unfiltered())
 
 def unfilteredmethod(orig):
     """decorate method that always need to be run on unfiltered version"""
     def wrapper(repo, *args, **kwargs):
         return orig(repo.unfiltered(), *args, **kwargs)
     return wrapper
 
 moderncaps = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
                   'unbundle'))
 legacycaps = moderncaps.union(set(['changegroupsubset']))
 
 class localpeer(peer.peerrepository):
     '''peer for a local repo; reflects only the most recent API'''
 
     def __init__(self, repo, caps=moderncaps):
         peer.peerrepository.__init__(self)
         self._repo = repo.filtered('served')
         self.ui = repo.ui
         self._caps = repo._restrictcapabilities(caps)
         self.requirements = repo.requirements
         self.supportedformats = repo.supportedformats
 
     def close(self):
         self._repo.close()
 
     def _capabilities(self):
         return self._caps
 
     def local(self):
         return self._repo
 
     def canpush(self):
         return True
 
     def url(self):
         return self._repo.url()
 
     def lookup(self, key):
         return self._repo.lookup(key)
 
     def branchmap(self):
         return self._repo.branchmap()
 
     def heads(self):
         return self._repo.heads()
 
     def known(self, nodes):
         return self._repo.known(nodes)
 
     def getbundle(self, source, heads=None, common=None, bundlecaps=None,
                   format='HG10', **kwargs):
         cg = exchange.getbundle(self._repo, source, heads=heads,
                                 common=common, bundlecaps=bundlecaps, **kwargs)
         if bundlecaps is not None and 'HG2Y' in bundlecaps:
             # When requesting a bundle2, getbundle returns a stream to make the
             # wire level function happier. We need to build a proper object
             # from it in local peer.
             cg = bundle2.unbundle20(self.ui, cg)
         return cg
 
     # TODO We might want to move the next two calls into legacypeer and add
     # unbundle instead.
 
     def unbundle(self, cg, heads, url):
         """apply a bundle on a repo
 
         This function handles the repo locking itself."""
         try:
             cg = exchange.readbundle(self.ui, cg, None)
             ret = exchange.unbundle(self._repo, cg, heads, 'push', url)
             if util.safehasattr(ret, 'getchunks'):
                 # This is a bundle20 object, turn it into an unbundler.
                 # This little dance should be dropped eventually when the API
                 # is finally improved.
                 stream = util.chunkbuffer(ret.getchunks())
                 ret = bundle2.unbundle20(self.ui, stream)
             return ret
         except error.PushRaced, exc:
             raise error.ResponseError(_('push failed:'), str(exc))
 
     def lock(self):
         return self._repo.lock()
 
     def addchangegroup(self, cg, source, url):
         return changegroup.addchangegroup(self._repo, cg, source, url)
 
     def pushkey(self, namespace, key, old, new):
         return self._repo.pushkey(namespace, key, old, new)
 
     def listkeys(self, namespace):
         return self._repo.listkeys(namespace)
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         '''used to test argument passing over the wire'''
         return "%s %s %s %s %s" % (one, two, three, four, five)
 
 class locallegacypeer(localpeer):
     '''peer extension which implements legacy methods too; used for tests with
     restricted capabilities'''
 
     def __init__(self, repo):
         localpeer.__init__(self, repo, caps=legacycaps)
 
     def branches(self, nodes):
         return self._repo.branches(nodes)
 
     def between(self, pairs):
         return self._repo.between(pairs)
 
     def changegroup(self, basenodes, source):
         return changegroup.changegroup(self._repo, basenodes, source)
 
     def changegroupsubset(self, bases, heads, source):
         return changegroup.changegroupsubset(self._repo, bases, heads, source)
 
 class localrepository(object):
 
     supportedformats = set(('revlogv1', 'generaldelta'))
     _basesupported = supportedformats | set(('store', 'fncache', 'shared',
                                              'dotencode'))
     openerreqs = set(('revlogv1', 'generaldelta'))
     requirements = ['revlogv1']
     filtername = None
 
     # a list of (ui, featureset) functions.
     # only functions defined in module of enabled extensions are invoked
     featuresetupfuncs = set()
 
     def _baserequirements(self, create):
         return self.requirements[:]
 
     def __init__(self, baseui, path=None, create=False):
         self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)
         self.wopener = self.wvfs
         self.root = self.wvfs.base
         self.path = self.wvfs.join(".hg")
         self.origroot = path
         self.auditor = pathutil.pathauditor(self.root, self._checknested)
         self.vfs = scmutil.vfs(self.path)
         self.opener = self.vfs
         self.baseui = baseui
         self.ui = baseui.copy()
         self.ui.copy = baseui.copy # prevent copying repo configuration
         # A list of callback to shape the phase if no data were found.
         # Callback are in the form: func(repo, roots) --> processed root.
         # This list it to be filled by extension during repo setup
         self._phasedefaults = []
         try:
             self.ui.readconfig(self.join("hgrc"), self.root)
             extensions.loadall(self.ui)
         except IOError:
             pass
 
         if self.featuresetupfuncs:
             self.supported = set(self._basesupported) # use private copy
             extmods = set(m.__name__ for n, m
                           in extensions.extensions(self.ui))
             for setupfunc in self.featuresetupfuncs:
                 if setupfunc.__module__ in extmods:
                     setupfunc(self.ui, self.supported)
         else:
             self.supported = self._basesupported
 
         if not self.vfs.isdir():
             if create:
                 if not self.wvfs.exists():
                     self.wvfs.makedirs()
                 self.vfs.makedir(notindexed=True)
                 requirements = self._baserequirements(create)
                 if self.ui.configbool('format', 'usestore', True):
                     self.vfs.mkdir("store")
                     requirements.append("store")
                     if self.ui.configbool('format', 'usefncache', True):
                         requirements.append("fncache")
                         if self.ui.configbool('format', 'dotencode', True):
                             requirements.append('dotencode')
                     # create an invalid changelog
                     self.vfs.append(
                         "00changelog.i",
                         '\0\0\0\2' # represents revlogv2
                         ' dummy changelog to prevent using the old repo layout'
                     )
                 if self.ui.configbool('format', 'generaldelta', False):
                     requirements.append("generaldelta")
                 requirements = set(requirements)
             else:
                 raise error.RepoError(_("repository %s not found") % path)
         elif create:
             raise error.RepoError(_("repository %s already exists") % path)
         else:
             try:
                 requirements = scmutil.readrequires(self.vfs, self.supported)
             except IOError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
                 requirements = set()
 
         self.sharedpath = self.path
         try:
             vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),
                               realpath=True)
             s = vfs.base
             if not vfs.exists():
                 raise error.RepoError(
                     _('.hg/sharedpath points to nonexistent directory %s') % s)
             self.sharedpath = s
         except IOError, inst:
             if inst.errno != errno.ENOENT:
                 raise
 
         self.store = store.store(requirements, self.sharedpath, scmutil.vfs)
         self.spath = self.store.path
         self.svfs = self.store.vfs
         self.sopener = self.svfs
         self.sjoin = self.store.join
         self.vfs.createmode = self.store.createmode
         self._applyrequirements(requirements)
         if create:
             self._writerequirements()
 
 
         self._branchcaches = {}
         self._revbranchcache = None
         self.filterpats = {}
         self._datafilters = {}
         self._transref = self._lockref = self._wlockref = None
 
         # A cache for various files under .hg/ that tracks file changes,
         # (used by the filecache decorator)
         #
         # Maps a property name to its util.filecacheentry
         self._filecache = {}
 
         # hold sets of revision to be filtered
         # should be cleared when something might have changed the filter value:
         # - new changesets,
         # - phase change,
         # - new obsolescence marker,
         # - working directory parent change,
         # - bookmark changes
         self.filteredrevcache = {}
 
         # generic mapping between names and nodes
         self.names = namespaces.namespaces()
 
     def close(self):
         self._writecaches()
 
     def _writecaches(self):
         if self._revbranchcache:
             self._revbranchcache.write()
 
     def _restrictcapabilities(self, caps):
         # bundle2 is not ready for prime time, drop it unless explicitly
         # required by the tests (or some brave tester)
         if self.ui.configbool('experimental', 'bundle2-exp', False):
             caps = set(caps)
             capsblob = bundle2.encodecaps(bundle2.getrepocaps(self))
             caps.add('bundle2-exp=' + urllib.quote(capsblob))
         return caps
 
     def _applyrequirements(self, requirements):
         self.requirements = requirements
         self.svfs.options = dict((r, 1) for r in requirements
                                            if r in self.openerreqs)
         chunkcachesize = self.ui.configint('format', 'chunkcachesize')
         if chunkcachesize is not None:
             self.svfs.options['chunkcachesize'] = chunkcachesize
         maxchainlen = self.ui.configint('format', 'maxchainlen')
         if maxchainlen is not None:
             self.svfs.options['maxchainlen'] = maxchainlen
         manifestcachesize = self.ui.configint('format', 'manifestcachesize')
         if manifestcachesize is not None:
             self.svfs.options['manifestcachesize'] = manifestcachesize
         usetreemanifest = self.ui.configbool('experimental', 'treemanifest')
         if usetreemanifest is not None:
             self.svfs.options['usetreemanifest'] = usetreemanifest
 
     def _writerequirements(self):
         reqfile = self.vfs("requires", "w")
         for r in sorted(self.requirements):
             reqfile.write("%s\n" % r)
         reqfile.close()
 
     def _checknested(self, path):
         """Determine if path is a legal nested repository."""
         if not path.startswith(self.root):
             return False
         subpath = path[len(self.root) + 1:]
         normsubpath = util.pconvert(subpath)
 
         # XXX: Checking against the current working copy is wrong in
         # the sense that it can reject things like
         #
         #   $ hg cat -r 10 sub/x.txt
         #
         # if sub/ is no longer a subrepository in the working copy
         # parent revision.
         #
         # However, it can of course also allow things that would have
         # been rejected before, such as the above cat command if sub/
         # is a subrepository now, but was a normal directory before.
         # The old path auditor would have rejected by mistake since it
         # panics when it sees sub/.hg/.
         #
         # All in all, checking against the working copy seems sensible
         # since we want to prevent access to nested repositories on
         # the filesystem *now*.
         ctx = self[None]
         parts = util.splitpath(subpath)
         while parts:
             prefix = '/'.join(parts)
             if prefix in ctx.substate:
                 if prefix == normsubpath:
                     return True
                 else:
                     sub = ctx.sub(prefix)
                     return sub.checknested(subpath[len(prefix) + 1:])
             else:
                 parts.pop()
         return False
 
     def peer(self):
         return localpeer(self) # not cached to avoid reference cycle
 
     def unfiltered(self):
         """Return unfiltered version of the repository
 
         Intended to be overwritten by filtered repo."""
         return self
 
     def filtered(self, name):
         """Return a filtered version of a repository"""
         # build a new class with the mixin and the current class
         # (possibly subclass of the repo)
         class proxycls(repoview.repoview, self.unfiltered().__class__):
             pass
         return proxycls(self, name)
 
     @repofilecache('bookmarks')
     def _bookmarks(self):
         return bookmarks.bmstore(self)
 
     @repofilecache('bookmarks.current')
     def _bookmarkcurrent(self):
         return bookmarks.readcurrent(self)
 
     def bookmarkheads(self, bookmark):
         name = bookmark.split('@', 1)[0]
         heads = []
         for mark, n in self._bookmarks.iteritems():
             if mark.split('@', 1)[0] == name:
                 heads.append(n)
         return heads
 
     @storecache('phaseroots')
     def _phasecache(self):
         return phases.phasecache(self, self._phasedefaults)
 
     @storecache('obsstore')
     def obsstore(self):
         # read default format for new obsstore.
         defaultformat = self.ui.configint('format', 'obsstore-version', None)
         # rely on obsstore class default when possible.
         kwargs = {}
         if defaultformat is not None:
             kwargs['defaultformat'] = defaultformat
         readonly = not obsolete.isenabled(self, obsolete.createmarkersopt)
         store = obsolete.obsstore(self.svfs, readonly=readonly,
                                   **kwargs)
         if store and readonly:
             self.ui.warn(
                 _('obsolete feature not enabled but %i markers found!\n')
                 % len(list(store)))
         return store
 
     @storecache('00changelog.i')
     def changelog(self):
         c = changelog.changelog(self.svfs)
         if 'HG_PENDING' in os.environ:
             p = os.environ['HG_PENDING']
             if p.startswith(self.root):
                 c.readpending('00changelog.i.a')
         return c
 
     @storecache('00manifest.i')
     def manifest(self):
         return manifest.manifest(self.svfs)
 
     @repofilecache('dirstate')
     def dirstate(self):
         warned = [0]
         def validate(node):
             try:
                 self.changelog.rev(node)
                 return node
             except error.LookupError:
                 if not warned[0]:
                     warned[0] = True
                     self.ui.warn(_("warning: ignoring unknown"
                                    " working parent %s!\n") % short(node))
                 return nullid
 
         return dirstate.dirstate(self.vfs, self.ui, self.root, validate)
 
     def __getitem__(self, changeid):
         if changeid is None:
             return context.workingctx(self)
         if isinstance(changeid, slice):
             return [context.changectx(self, i)
                     for i in xrange(*changeid.indices(len(self)))
                     if i not in self.changelog.filteredrevs]
         return context.changectx(self, changeid)
 
     def __contains__(self, changeid):
         try:
             self[changeid]
             return True
         except error.RepoLookupError:
             return False
 
     def __nonzero__(self):
         return True
 
     def __len__(self):
         return len(self.changelog)
 
     def __iter__(self):
         return iter(self.changelog)
 
     def revs(self, expr, *args):
         '''Return a list of revisions matching the given revset'''
         expr = revset.formatspec(expr, *args)
         m = revset.match(None, expr)
         return m(self)
 
     def set(self, expr, *args):
         '''
         Yield a context for each matching revision, after doing arg
         replacement via revset.formatspec
         '''
         for r in self.revs(expr, *args):
             yield self[r]
 
     def url(self):
         return 'file:' + self.root
 
     def hook(self, name, throw=False, **args):
         """Call a hook, passing this repo instance.
 
         This a convenience method to aid invoking hooks. Extensions likely
         won't call this unless they have registered a custom hook or are
         replacing code that is expected to call a hook.
         """
         return hook.hook(self.ui, self, name, throw, **args)
 
     @unfilteredmethod
     def _tag(self, names, node, message, local, user, date, extra={},
              editor=False):
         if isinstance(names, str):
             names = (names,)
 
         branches = self.branchmap()
         for name in names:
             self.hook('pretag', throw=True, node=hex(node), tag=name,
                       local=local)
             if name in branches:
                 self.ui.warn(_("warning: tag %s conflicts with existing"
                 " branch name\n") % name)
 
         def writetags(fp, names, munge, prevtags):
             fp.seek(0, 2)
             if prevtags and prevtags[-1] != '\n':
                 fp.write('\n')
             for name in names:
                 if munge:
                     m = munge(name)
                 else:
                     m = name
 
                 if (self._tagscache.tagtypes and
                     name in self._tagscache.tagtypes):
                     old = self.tags().get(name, nullid)
                     fp.write('%s %s\n' % (hex(old), m))
                 fp.write('%s %s\n' % (hex(node), m))
             fp.close()
 
         prevtags = ''
         if local:
             try:
                 fp = self.vfs('localtags', 'r+')
             except IOError:
                 fp = self.vfs('localtags', 'a')
             else:
                 prevtags = fp.read()
 
             # local tags are stored in the current charset
             writetags(fp, names, None, prevtags)
             for name in names:
                 self.hook('tag', node=hex(node), tag=name, local=local)
             return
 
         try:
             fp = self.wfile('.hgtags', 'rb+')
         except IOError, e:
             if e.errno != errno.ENOENT:
                 raise
             fp = self.wfile('.hgtags', 'ab')
         else:
             prevtags = fp.read()
 
         # committed tags are stored in UTF-8
         writetags(fp, names, encoding.fromlocal, prevtags)
 
         fp.close()
 
         self.invalidatecaches()
 
         if '.hgtags' not in self.dirstate:
             self[None].add(['.hgtags'])
 
         m = matchmod.exact(self.root, '', ['.hgtags'])
         tagnode = self.commit(message, user, date, extra=extra, match=m,
                               editor=editor)
 
         for name in names:
             self.hook('tag', node=hex(node), tag=name, local=local)
 
         return tagnode
 
     def tag(self, names, node, message, local, user, date, editor=False):
         '''tag a revision with one or more symbolic names.
 
         names is a list of strings or, when adding a single tag, names may be a
         string.
 
         if local is True, the tags are stored in a per-repository file.
         otherwise, they are stored in the .hgtags file, and a new
         changeset is committed with the change.
 
         keyword arguments:
 
         local: whether to store tags in non-version-controlled file
         (default False)
 
         message: commit message to use if committing
 
         user: name of user to use if committing
 
         date: date tuple to use if committing'''
 
         if not local:
             m = matchmod.exact(self.root, '', ['.hgtags'])
             if util.any(self.status(match=m, unknown=True, ignored=True)):
                 raise util.Abort(_('working copy of .hgtags is changed'),
                                  hint=_('please commit .hgtags manually'))
 
         self.tags() # instantiate the cache
         self._tag(names, node, message, local, user, date, editor=editor)
 
     @filteredpropertycache
     def _tagscache(self):
         '''Returns a tagscache object that contains various tags related
         caches.'''
 
         # This simplifies its cache management by having one decorated
         # function (this one) and the rest simply fetch things from it.
         class tagscache(object):
             def __init__(self):
                 # These two define the set of tags for this repository. tags
                 # maps tag name to node; tagtypes maps tag name to 'global' or
                 # 'local'. (Global tags are defined by .hgtags across all
                 # heads, and local tags are defined in .hg/localtags.)
                 # They constitute the in-memory cache of tags.
                 self.tags = self.tagtypes = None
 
                 self.nodetagscache = self.tagslist = None
 
         cache = tagscache()
         cache.tags, cache.tagtypes = self._findtags()
 
         return cache
 
     def tags(self):
         '''return a mapping of tag to node'''
         t = {}
         if self.changelog.filteredrevs:
             tags, tt = self._findtags()
         else:
             tags = self._tagscache.tags
         for k, v in tags.iteritems():
             try:
                 # ignore tags to unknown nodes
                 self.changelog.rev(v)
                 t[k] = v
             except (error.LookupError, ValueError):
                 pass
         return t
 
     def _findtags(self):
         '''Do the hard work of finding tags.  Return a pair of dicts
         (tags, tagtypes) where tags maps tag name to node, and tagtypes
         maps tag name to a string like \'global\' or \'local\'.
         Subclasses or extensions are free to add their own tags, but
         should be aware that the returned dicts will be retained for the
         duration of the localrepo object.'''
 
         # XXX what tagtype should subclasses/extensions use?  Currently
         # mq and bookmarks add tags, but do not set the tagtype at all.
         # Should each extension invent its own tag type?  Should there
         # be one tagtype for all such "virtual" tags?  Or is the status
         # quo fine?
 
         alltags = {}                    # map tag name to (node, hist)
         tagtypes = {}
 
         tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
         tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
 
         # Build the return dicts.  Have to re-encode tag names because
         # the tags module always uses UTF-8 (in order not to lose info
         # writing to the cache), but the rest of Mercurial wants them in
         # local encoding.
         tags = {}
         for (name, (node, hist)) in alltags.iteritems():
             if node != nullid:
                 tags[encoding.tolocal(name)] = node
         tags['tip'] = self.changelog.tip()
         tagtypes = dict([(encoding.tolocal(name), value)
                          for (name, value) in tagtypes.iteritems()])
         return (tags, tagtypes)
 
     def tagtype(self, tagname):
         '''
         return the type of the given tag. result can be:
 
         'local'  : a local tag
         'global' : a global tag
         None     : tag does not exist
         '''
 
         return self._tagscache.tagtypes.get(tagname)
 
     def tagslist(self):
         '''return a list of tags ordered by revision'''
         if not self._tagscache.tagslist:
             l = []
             for t, n in self.tags().iteritems():
                 l.append((self.changelog.rev(n), t, n))
             self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
 
         return self._tagscache.tagslist
 
     def nodetags(self, node):
         '''return the tags associated with a node'''
         if not self._tagscache.nodetagscache:
             nodetagscache = {}
             for t, n in self._tagscache.tags.iteritems():
                 nodetagscache.setdefault(n, []).append(t)
             for tags in nodetagscache.itervalues():
                 tags.sort()
             self._tagscache.nodetagscache = nodetagscache
         return self._tagscache.nodetagscache.get(node, [])
 
     def nodebookmarks(self, node):
         marks = []
         for bookmark, n in self._bookmarks.iteritems():
             if n == node:
                 marks.append(bookmark)
         return sorted(marks)
 
     def branchmap(self):
         '''returns a dictionary {branch: [branchheads]} with branchheads
         ordered by increasing revision number'''
         branchmap.updatecache(self)
         return self._branchcaches[self.filtername]
 
     @unfilteredmethod
     def revbranchcache(self):
         if not self._revbranchcache:
             self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
         return self._revbranchcache
 
     def branchtip(self, branch, ignoremissing=False):
         '''return the tip node for a given branch
 
         If ignoremissing is True, then this method will not raise an error.
         This is helpful for callers that only expect None for a missing branch
         (e.g. namespace).
 
         '''
         try:
             return self.branchmap().branchtip(branch)
         except KeyError:
             if not ignoremissing:
                 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
             else:
                 pass
 
     def lookup(self, key):
         return self[key].node()
 
     def lookupbranch(self, key, remote=None):
         repo = remote or self
         if key in repo.branchmap():
             return key
 
         repo = (remote and remote.local()) and remote or self
         return repo[key].branch()
 
     def known(self, nodes):
         nm = self.changelog.nodemap
         pc = self._phasecache
         result = []
         for n in nodes:
             r = nm.get(n)
             resp = not (r is None or pc.phase(self, r) >= phases.secret)
             result.append(resp)
         return result
 
     def local(self):
         return self
 
     def cancopy(self):
         # so statichttprepo's override of local() works
         if not self.local():
             return False
         if not self.ui.configbool('phases', 'publish', True):
             return True
         # if publishing we can't copy if there is filtered content
         return not self.filtered('visible').changelog.filteredrevs
 
     def shared(self):
         '''the type of shared repository (None if not shared)'''
         if self.sharedpath != self.path:
             return 'store'
         return None
 
     def join(self, f, *insidef):
         return self.vfs.join(os.path.join(f, *insidef))
 
     def wjoin(self, f, *insidef):
         return self.vfs.reljoin(self.root, f, *insidef)
 
     def file(self, f):
         if f[0] == '/':
             f = f[1:]
         return filelog.filelog(self.svfs, f)
 
     def changectx(self, changeid):
         return self[changeid]
 
     def parents(self, changeid=None):
         '''get list of changectxs for parents of changeid'''
         return self[changeid].parents()
 
     def setparents(self, p1, p2=nullid):
         self.dirstate.beginparentchange()
         copies = self.dirstate.setparents(p1, p2)
         pctx = self[p1]
         if copies:
             # Adjust copy records, the dirstate cannot do it, it
             # requires access to parents manifests. Preserve them
             # only for entries added to first parent.
             for f in copies:
                 if f not in pctx and copies[f] in pctx:
                     self.dirstate.copy(copies[f], f)
         if p2 == nullid:
             for f, s in sorted(self.dirstate.copies().items()):
                 if f not in pctx and s not in pctx:
                     self.dirstate.copy(None, f)
         self.dirstate.endparentchange()
 
     def filectx(self, path, changeid=None, fileid=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         return context.filectx(self, path, changeid, fileid)
 
     def getcwd(self):
         return self.dirstate.getcwd()
 
     def pathto(self, f, cwd=None):
         return self.dirstate.pathto(f, cwd)
 
     def wfile(self, f, mode='r'):
         return self.wvfs(f, mode)
 
     def _link(self, f):
         return self.wvfs.islink(f)
 
     def _loadfilter(self, filter):
         if filter not in self.filterpats:
             l = []
             for pat, cmd in self.ui.configitems(filter):
                 if cmd == '!':
                     continue
                 mf = matchmod.match(self.root, '', [pat])
                 fn = None
                 params = cmd
                 for name, filterfn in self._datafilters.iteritems():
                     if cmd.startswith(name):
                         fn = filterfn
                         params = cmd[len(name):].lstrip()
                         break
                 if not fn:
                     fn = lambda s, c, **kwargs: util.filter(s, c)
                 # Wrap old filters not supporting keyword arguments
                 if not inspect.getargspec(fn)[2]:
                     oldfn = fn
                     fn = lambda s, c, **kwargs: oldfn(s, c)
                 l.append((mf, fn, params))
             self.filterpats[filter] = l
         return self.filterpats[filter]
 
     def _filter(self, filterpats, filename, data):
         for mf, fn, cmd in filterpats:
             if mf(filename):
                 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
                 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
                 break
 
         return data
 
     @unfilteredpropertycache
     def _encodefilterpats(self):
         return self._loadfilter('encode')
 
     @unfilteredpropertycache
     def _decodefilterpats(self):
         return self._loadfilter('decode')
 
     def adddatafilter(self, name, filter):
         self._datafilters[name] = filter
 
     def wread(self, filename):
         if self._link(filename):
             data = self.wvfs.readlink(filename)
         else:
             data = self.wvfs.read(filename)
         return self._filter(self._encodefilterpats, filename, data)
 
     def wwrite(self, filename, data, flags):
         data = self._filter(self._decodefilterpats, filename, data)
         if 'l' in flags:
             self.wvfs.symlink(data, filename)
         else:
             self.wvfs.write(filename, data)
             if 'x' in flags:
                 self.wvfs.setflags(filename, False, True)
 
     def wwritedata(self, filename, data):
         return self._filter(self._decodefilterpats, filename, data)
 
     def currenttransaction(self):
         """return the current transaction or None if non exists"""
         if self._transref:
             tr = self._transref()
         else:
             tr = None
 
         if tr and tr.running():
             return tr
         return None
 
     def transaction(self, desc, report=None):
         if (self.ui.configbool('devel', 'all')
                 or self.ui.configbool('devel', 'check-locks')):
             l = self._lockref and self._lockref()
             if l is None or not l.held:
                 msg = 'transaction with no lock\n'
                 if self.ui.tracebackflag:
                     util.debugstacktrace(msg, 1)
                 else:
                     self.ui.write_err(msg)
         tr = self.currenttransaction()
         if tr is not None:
             return tr.nest()
 
         # abort here if the journal already exists
         if self.svfs.exists("journal"):
             raise error.RepoError(
                 _("abandoned transaction found"),
                 hint=_("run 'hg recover' to clean up transaction"))
 
         self.hook('pretxnopen', throw=True, txnname=desc)
 
         self._writejournal(desc)
         renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
         if report:
             rp = report
         else:
             rp = self.ui.warn
         vfsmap = {'plain': self.vfs} # root of .hg/
         # we must avoid cyclic reference between repo and transaction.
         reporef = weakref.ref(self)
         def validate(tr):
             """will run pre-closing hooks"""
             pending = lambda: tr.writepending() and self.root or ""
             reporef().hook('pretxnclose', throw=True, pending=pending,
                            xnname=desc)
 
         tr = transaction.transaction(rp, self.sopener, vfsmap,
                                      "journal",
                                      "undo",
                                      aftertrans(renames),
                                      self.store.createmode,
                                      validator=validate)
         # note: writing the fncache only during finalize mean that the file is
         # outdated when running hooks. As fncache is used for streaming clone,
         # this is not expected to break anything that happen during the hooks.
         tr.addfinalize('flush-fncache', self.store.write)
         def txnclosehook(tr2):
             """To be run if transaction is successful, will schedule a hook run
             """
             def hook():
                 reporef().hook('txnclose', throw=False, txnname=desc,
                                **tr2.hookargs)
             reporef()._afterlock(hook)
         tr.addfinalize('txnclose-hook', txnclosehook)
         self._transref = weakref.ref(tr)
         return tr
 
     def _journalfiles(self):
         return ((self.svfs, 'journal'),
                 (self.vfs, 'journal.dirstate'),
                 (self.vfs, 'journal.branch'),
                 (self.vfs, 'journal.desc'),
                 (self.vfs, 'journal.bookmarks'),
                 (self.svfs, 'journal.phaseroots'))
 
     def undofiles(self):
         return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
 
     def _writejournal(self, desc):
         self.vfs.write("journal.dirstate",
                           self.vfs.tryread("dirstate"))
         self.vfs.write("journal.branch",
                           encoding.fromlocal(self.dirstate.branch()))
         self.vfs.write("journal.desc",
                           "%d\n%s\n" % (len(self), desc))
         self.vfs.write("journal.bookmarks",
                           self.vfs.tryread("bookmarks"))
         self.svfs.write("journal.phaseroots",
                            self.svfs.tryread("phaseroots"))
 
     def recover(self):
         lock = self.lock()
         try:
             if self.svfs.exists("journal"):
                 self.ui.status(_("rolling back interrupted transaction\n"))
                 vfsmap = {'': self.svfs,
                           'plain': self.vfs,}
                 transaction.rollback(self.svfs, vfsmap, "journal",
                                      self.ui.warn)
                 self.invalidate()
                 return True
             else:
                 self.ui.warn(_("no interrupted transaction available\n"))
                 return False
         finally:
             lock.release()
 
     def rollback(self, dryrun=False, force=False):
         wlock = lock = None
         try:
             wlock = self.wlock()
             lock = self.lock()
             if self.svfs.exists("undo"):
                 return self._rollback(dryrun, force)
             else:
                 self.ui.warn(_("no rollback information available\n"))
                 return 1
         finally:
             release(lock, wlock)
 
     @unfilteredmethod # Until we get smarter cache management
     def _rollback(self, dryrun, force):
         ui = self.ui
         try:
             args = self.vfs.read('undo.desc').splitlines()
             (oldlen, desc, detail) = (int(args[0]), args[1], None)
             if len(args) >= 3:
                 detail = args[2]
             oldtip = oldlen - 1
 
             if detail and ui.verbose:
                 msg = (_('repository tip rolled back to revision %s'
                          ' (undo %s: %s)\n')
                        % (oldtip, desc, detail))
             else:
                 msg = (_('repository tip rolled back to revision %s'
                          ' (undo %s)\n')
                        % (oldtip, desc))
         except IOError:
             msg = _('rolling back unknown transaction\n')
             desc = None
 
         if not force and self['.'] != self['tip'] and desc == 'commit':
             raise util.Abort(
                 _('rollback of last commit while not checked out '
                   'may lose data'), hint=_('use -f to force'))
 
         ui.status(msg)
         if dryrun:
             return 0
 
         parents = self.dirstate.parents()
         self.destroying()
         vfsmap = {'plain': self.vfs, '': self.svfs}
         transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn)
         if self.vfs.exists('undo.bookmarks'):
             self.vfs.rename('undo.bookmarks', 'bookmarks')
         if self.svfs.exists('undo.phaseroots'):
             self.svfs.rename('undo.phaseroots', 'phaseroots')
         self.invalidate()
 
         parentgone = (parents[0] not in self.changelog.nodemap or
                       parents[1] not in self.changelog.nodemap)
         if parentgone:
             self.vfs.rename('undo.dirstate', 'dirstate')
             try:
                 branch = self.vfs.read('undo.branch')
                 self.dirstate.setbranch(encoding.tolocal(branch))
             except IOError:
                 ui.warn(_('named branch could not be reset: '
                           'current branch is still \'%s\'\n')
                         % self.dirstate.branch())
 
             self.dirstate.invalidate()
             parents = tuple([p.rev() for p in self.parents()])
             if len(parents) > 1:
                 ui.status(_('working directory now based on '
                             'revisions %d and %d\n') % parents)
             else:
                 ui.status(_('working directory now based on '
                             'revision %d\n') % parents)
         # TODO: if we know which new heads may result from this rollback, pass
         # them to destroy(), which will prevent the branchhead cache from being
         # invalidated.
         self.destroyed()
         return 0
 
     def invalidatecaches(self):
 
         if '_tagscache' in vars(self):
             # can't use delattr on proxy
             del self.__dict__['_tagscache']
 
         self.unfiltered()._branchcaches.clear()
         self.invalidatevolatilesets()
 
     def invalidatevolatilesets(self):
         self.filteredrevcache.clear()
         obsolete.clearobscaches(self)
 
     def invalidatedirstate(self):
         '''Invalidates the dirstate, causing the next call to dirstate
         to check if it was modified since the last time it was read,
         rereading it if it has.
 
         This is different to dirstate.invalidate() that it doesn't always
         rereads the dirstate. Use dirstate.invalidate() if you want to
         explicitly read the dirstate again (i.e. restoring it to a previous
         known good state).'''
         if hasunfilteredcache(self, 'dirstate'):
             for k in self.dirstate._filecache:
                 try:
                     delattr(self.dirstate, k)
                 except AttributeError:
                     pass
             delattr(self.unfiltered(), 'dirstate')
 
     def invalidate(self):
         unfiltered = self.unfiltered() # all file caches are stored unfiltered
         for k in self._filecache:
             # dirstate is invalidated separately in invalidatedirstate()
             if k == 'dirstate':
                 continue
 
             try:
                 delattr(unfiltered, k)
             except AttributeError:
                 pass
         self.invalidatecaches()
         self.store.invalidatecaches()
 
     def invalidateall(self):
         '''Fully invalidates both store and non-store parts, causing the
         subsequent operation to reread any outside changes.'''
         # extension should hook this to invalidate its caches
         self.invalidate()
         self.invalidatedirstate()
 
     def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc):
         try:
             l = lockmod.lock(vfs, lockname, 0, releasefn, desc=desc)
         except error.LockHeld, inst:
             if not wait:
                 raise
             self.ui.warn(_("waiting for lock on %s held by %r\n") %
                          (desc, inst.locker))
             # default to 600 seconds timeout
             l = lockmod.lock(vfs, lockname,
                              int(self.ui.config("ui", "timeout", "600")),
                              releasefn, desc=desc)
             self.ui.warn(_("got lock after %s seconds\n") % l.delay)
         if acquirefn:
             acquirefn()
         return l
 
     def _afterlock(self, callback):
         """add a callback to the current repository lock.
 
         The callback will be executed on lock release."""
         l = self._lockref and self._lockref()
         if l:
             l.postrelease.append(callback)
         else:
             callback()
 
     def lock(self, wait=True):
         '''Lock the repository store (.hg/store) and return a weak reference
         to the lock. Use this before modifying the store (e.g. committing or
         stripping). If you are opening a transaction, get a lock as well.)'''
         l = self._lockref and self._lockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         def unlock():
             for k, ce in self._filecache.items():
                 if k == 'dirstate' or k not in self.__dict__:
                     continue
                 ce.refresh()
 
         l = self._lock(self.svfs, "lock", wait, unlock,
                        self.invalidate, _('repository %s') % self.origroot)
         self._lockref = weakref.ref(l)
         return l
 
     def wlock(self, wait=True):
         '''Lock the non-store parts of the repository (everything under
         .hg except .hg/store) and return a weak reference to the lock.
         Use this before modifying files in .hg.'''
         if (self.ui.configbool('devel', 'all')
                 or self.ui.configbool('devel', 'check-locks')):
             l = self._lockref and self._lockref()
             if l is not None and l.held:
                 msg = '"lock" taken before "wlock"\n'
                 if self.ui.tracebackflag:
                     util.debugstacktrace(msg, 1)
                 else:
                     self.ui.write_err(msg)
         l = self._wlockref and self._wlockref()
         if l is not None and l.held:
             l.lock()
             return l
 
         def unlock():
             if self.dirstate.pendingparentchange():
                 self.dirstate.invalidate()
             else:
                 self.dirstate.write()
 
             self._filecache['dirstate'].refresh()
 
         l = self._lock(self.vfs, "wlock", wait, unlock,
                        self.invalidatedirstate, _('working directory of %s') %
                        self.origroot)
         self._wlockref = weakref.ref(l)
         return l
 
     def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
         """
         commit an individual file as part of a larger transaction
         """
 
         fname = fctx.path()
         fparent1 = manifest1.get(fname, nullid)
         fparent2 = manifest2.get(fname, nullid)
         if isinstance(fctx, context.filectx):
             node = fctx.filenode()
             if node in [fparent1, fparent2]:
                 self.ui.debug('reusing %s filelog entry\n' % fname)
                 return node
 
         flog = self.file(fname)
         meta = {}
         copy = fctx.renamed()
         if copy and copy[0] != fname:
             # Mark the new revision of this file as a copy of another
             # file.  This copy data will effectively act as a parent
             # of this new revision.  If this is a merge, the first
             # parent will be the nullid (meaning "look up the copy data")
             # and the second one will be the other parent.  For example:
             #
             # 0 --- 1 --- 3   rev1 changes file foo
             #   \       /     rev2 renames foo to bar and changes it
             #    \- 2 -/      rev3 should have bar with all changes and
             #                      should record that bar descends from
             #                      bar in rev2 and foo in rev1
             #
             # this allows this merge to succeed:
             #
             # 0 --- 1 --- 3   rev4 reverts the content change from rev2
             #   \       /     merging rev3 and rev4 should use bar@rev2
             #    \- 2 --- 4        as the merge base
             #
 
             cfname = copy[0]
             crev = manifest1.get(cfname)
             newfparent = fparent2
 
             if manifest2: # branch merge
                 if fparent2 == nullid or crev is None: # copied on remote side
                     if cfname in manifest2:
                         crev = manifest2[cfname]
                         newfparent = fparent1
 
             # Here, we used to search backwards through history to try to find
             # where the file copy came from if the source of a copy was not in
             # the parent directory. However, this doesn't actually make sense to
             # do (what does a copy from something not in your working copy even
             # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
             # the user that copy information was dropped, so if they didn't
             # expect this outcome it can be fixed, but this is the correct
             # behavior in this circumstance.
 
             if crev:
                 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
                 meta["copy"] = cfname
                 meta["copyrev"] = hex(crev)
                 fparent1, fparent2 = nullid, newfparent
             else:
                 self.ui.warn(_("warning: can't find ancestor for '%s' "
                                "copied from '%s'!\n") % (fname, cfname))
 
         elif fparent1 == nullid:
             fparent1, fparent2 = fparent2, nullid
         elif fparent2 != nullid:
             # is one parent an ancestor of the other?
             fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
             if fparent1 in fparentancestors:
                 fparent1, fparent2 = fparent2, nullid
             elif fparent2 in fparentancestors:
                 fparent2 = nullid
 
         # is the file changed?
         text = fctx.data()
         if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
             changelist.append(fname)
             return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
         # are just the flags changed during merge?
         elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
             changelist.append(fname)
 
         return fparent1
 
     @unfilteredmethod
     def commit(self, text="", user=None, date=None, match=None, force=False,
                editor=False, extra={}):
         """Add a new revision to current repository.
 
         Revision information is gathered from the working directory,
         match can be used to filter the committed files. If editor is
         supplied, it is called to get a commit message.
         """
 
         def fail(f, msg):
             raise util.Abort('%s: %s' % (f, msg))
 
         if not match:
             match = matchmod.always(self.root, '')
 
         if not force:
             vdirs = []
             match.explicitdir = vdirs.append
             match.bad = fail
 
         wlock = self.wlock()
         try:
             wctx = self[None]
             merge = len(wctx.parents()) > 1
 
             if not force and merge and not match.always():
                 raise util.Abort(_('cannot partially commit a merge '
                                    '(do not specify files or patterns)'))
 
             status = self.status(match=match, clean=force)
             if force:
                 status.modified.extend(status.clean) # mq may commit clean files
 
             # check subrepos
             subs = []
             commitsubs = set()
             newstate = wctx.substate.copy()
             # only manage subrepos and .hgsubstate if .hgsub is present
             if '.hgsub' in wctx:
                 # we'll decide whether to track this ourselves, thanks
                 for c in status.modified, status.added, status.removed:
                     if '.hgsubstate' in c:
                         c.remove('.hgsubstate')
 
                 # compare current state to last committed state
                 # build new substate based on last committed state
                 oldstate = wctx.p1().substate
                 for s in sorted(newstate.keys()):
                     if not match(s):
                         # ignore working copy, use old state if present
                         if s in oldstate:
                             newstate[s] = oldstate[s]
                             continue
                         if not force:
                             raise util.Abort(
                                 _("commit with new subrepo %s excluded") % s)
-                    if wctx.sub(s).dirty(True):
+                    dirtyreason = wctx.sub(s).dirtyreason(True)
+                    if dirtyreason:
                         if not self.ui.configbool('ui', 'commitsubrepos'):
-                            raise util.Abort(
-                                _("uncommitted changes in subrepo %s") % s,
+                            raise util.Abort(dirtyreason,
                                 hint=_("use --subrepos for recursive commit"))
                         subs.append(s)
                         commitsubs.add(s)
                     else:
                         bs = wctx.sub(s).basestate()
                         newstate[s] = (newstate[s][0], bs, newstate[s][2])
                         if oldstate.get(s, (None, None, None))[1] != bs:
                             subs.append(s)
 
                 # check for removed subrepos
                 for p in wctx.parents():
                     r = [s for s in p.substate if s not in newstate]
                     subs += [s for s in r if match(s)]
                 if subs:
                     if (not match('.hgsub') and
                         '.hgsub' in (wctx.modified() + wctx.added())):
                         raise util.Abort(
                             _("can't commit subrepos without .hgsub"))
                     status.modified.insert(0, '.hgsubstate')
 
             elif '.hgsub' in status.removed:
                 # clean up .hgsubstate when .hgsub is removed
                 if ('.hgsubstate' in wctx and
                     '.hgsubstate' not in (status.modified + status.added +
                                           status.removed)):
                     status.removed.insert(0, '.hgsubstate')
 
             # make sure all explicit patterns are matched
             if not force and match.files():
                 matched = set(status.modified + status.added + status.removed)
 
                 for f in match.files():
                     f = self.dirstate.normalize(f)
                     if f == '.' or f in matched or f in wctx.substate:
                         continue
                     if f in status.deleted:
                         fail(f, _('file not found!'))
                     if f in vdirs: # visited directory
                         d = f + '/'
                         for mf in matched:
                             if mf.startswith(d):
                                 break
                         else:
                             fail(f, _("no match under directory!"))
                     elif f not in self.dirstate:
                         fail(f, _("file not tracked!"))
 
             cctx = context.workingcommitctx(self, status,
                                             text, user, date, extra)
 
             if (not force and not extra.get("close") and not merge
                 and not cctx.files()
                 and wctx.branch() == wctx.p1().branch()):
                 return None
 
             if merge and cctx.deleted():
                 raise util.Abort(_("cannot commit merge with missing files"))
 
             ms = mergemod.mergestate(self)
             for f in status.modified:
                 if f in ms and ms[f] == 'u':
                     raise util.Abort(_('unresolved merge conflicts '
                                        '(see "hg help resolve")'))
 
             if editor:
                 cctx._text = editor(self, cctx, subs)
             edited = (text != cctx._text)
 
             # Save commit message in case this transaction gets rolled back
             # (e.g. by a pretxncommit hook).  Leave the content alone on
             # the assumption that the user will use the same editor again.
             msgfn = self.savecommitmessage(cctx._text)
 
             # commit subs and write new state
             if subs:
                 for s in sorted(commitsubs):
                     sub = wctx.sub(s)
                     self.ui.status(_('committing subrepository %s\n') %
                         subrepo.subrelpath(sub))
                     sr = sub.commit(cctx._text, user, date)
                     newstate[s] = (newstate[s][0], sr)
                 subrepo.writestate(self, newstate)
 
             p1, p2 = self.dirstate.parents()
             hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
             try:
                 self.hook("precommit", throw=True, parent1=hookp1,
                           parent2=hookp2)
                 ret = self.commitctx(cctx, True)
             except: # re-raises
                 if edited:
                     self.ui.write(
                         _('note: commit message saved in %s\n') % msgfn)
                 raise
 
             # update bookmarks, dirstate and mergestate
             bookmarks.update(self, [p1, p2], ret)
             cctx.markcommitted(ret)
             ms.reset()
         finally:
             wlock.release()
 
         def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
             # hack for command that use a temporary commit (eg: histedit)
             # temporary commit got stripped before hook release
             if node in self:
                 self.hook("commit", node=node, parent1=parent1,
                           parent2=parent2)
         self._afterlock(commithook)
         return ret
 
     @unfilteredmethod
     def commitctx(self, ctx, error=False):
         """Add a new revision to current repository.
         Revision information is passed via the context argument.
         """
 
         tr = None
         p1, p2 = ctx.p1(), ctx.p2()
         user = ctx.user()
 
         lock = self.lock()
         try:
             tr = self.transaction("commit")
             trp = weakref.proxy(tr)
 
             if ctx.files():
                 m1 = p1.manifest()
                 m2 = p2.manifest()
                 m = m1.copy()
 
                 # check in files
                 added = []
                 changed = []
                 removed = list(ctx.removed())
                 linkrev = len(self)
                 self.ui.note(_("committing files:\n"))
                 for f in sorted(ctx.modified() + ctx.added()):
                     self.ui.note(f + "\n")
                     try:
                         fctx = ctx[f]
                         if fctx is None:
                             removed.append(f)
                         else:
                             added.append(f)
                             m[f] = self._filecommit(fctx, m1, m2, linkrev,
                                                     trp, changed)
                             m.setflag(f, fctx.flags())
                     except OSError, inst:
                         self.ui.warn(_("trouble committing %s!\n") % f)
                         raise
                     except IOError, inst:
                         errcode = getattr(inst, 'errno', errno.ENOENT)
                         if error or errcode and errcode != errno.ENOENT:
                             self.ui.warn(_("trouble committing %s!\n") % f)
                         raise
 
                 # update manifest
                 self.ui.note(_("committing manifest\n"))
                 removed = [f for f in sorted(removed) if f in m1 or f in m2]
                 drop = [f for f in removed if f in m]
                 for f in drop:
                     del m[f]
                 mn = self.manifest.add(m, trp, linkrev,
                                        p1.manifestnode(), p2.manifestnode(),
                                        added, drop)
                 files = changed + removed
             else:
                 mn = p1.manifestnode()
                 files = []
 
             # update changelog
             self.ui.note(_("committing changelog\n"))
             self.changelog.delayupdate(tr)
             n = self.changelog.add(mn, files, ctx.description(),
                                    trp, p1.node(), p2.node(),
                                    user, ctx.date(), ctx.extra().copy())
             p = lambda: tr.writepending() and self.root or ""
             xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
             self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
                       parent2=xp2, pending=p)
             # set the new commit is proper phase
             targetphase = subrepo.newcommitphase(self.ui, ctx)
             if targetphase:
                 # retract boundary do not alter parent changeset.
                 # if a parent have higher the resulting phase will
                 # be compliant anyway
                 #
                 # if minimal phase was 0 we don't need to retract anything
                 phases.retractboundary(self, tr, targetphase, [n])
             tr.close()
             branchmap.updatecache(self.filtered('served'))
             return n
         finally:
             if tr:
                 tr.release()
             lock.release()
 
     @unfilteredmethod
     def destroying(self):
         '''Inform the repository that nodes are about to be destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done before destroying history.
 
         This is mostly useful for saving state that is in memory and waiting
         to be flushed when the current lock is released. Because a call to
         destroyed is imminent, the repo will be invalidated causing those
         changes to stay in memory (waiting for the next unlock), or vanish
         completely.
         '''
         # When using the same lock to commit and strip, the phasecache is left
         # dirty after committing. Then when we strip, the repo is invalidated,
         # causing those changes to disappear.
         if '_phasecache' in vars(self):
             self._phasecache.write()
 
     @unfilteredmethod
     def destroyed(self):
         '''Inform the repository that nodes have been destroyed.
         Intended for use by strip and rollback, so there's a common
         place for anything that has to be done after destroying history.
         '''
         # When one tries to:
         # 1) destroy nodes thus calling this method (e.g. strip)
         # 2) use phasecache somewhere (e.g. commit)
         #
         # then 2) will fail because the phasecache contains nodes that were
         # removed. We can either remove phasecache from the filecache,
         # causing it to reload next time it is accessed, or simply filter
         # the removed nodes now and write the updated cache.
         self._phasecache.filterunknown(self)
         self._phasecache.write()
 
         # update the 'served' branch cache to help read only server process
         # Thanks to branchcache collaboration this is done from the nearest
         # filtered subset and it is expected to be fast.
         branchmap.updatecache(self.filtered('served'))
 
         # Ensure the persistent tag cache is updated.  Doing it now
         # means that the tag cache only has to worry about destroyed
         # heads immediately after a strip/rollback.  That in turn
         # guarantees that "cachetip == currenttip" (comparing both rev
         # and node) always means no nodes have been added or destroyed.
 
         # XXX this is suboptimal when qrefresh'ing: we strip the current
         # head, refresh the tag cache, then immediately add a new head.
         # But I think doing it this way is necessary for the "instant
         # tag cache retrieval" case to work.
         self.invalidate()
 
     def walk(self, match, node=None):
         '''
         walk recursively through the directory tree or a given
         changeset, finding all files matched by the match
         function
         '''
         return self[node].walk(match)
 
     def status(self, node1='.', node2=None, match=None,
                ignored=False, clean=False, unknown=False,
                listsubrepos=False):
         '''a convenience method that calls node1.status(node2)'''
         return self[node1].status(node2, match, ignored, clean, unknown,
                                   listsubrepos)
 
     def heads(self, start=None):
         heads = self.changelog.heads(start)
         # sort the output in rev descending order
         return sorted(heads, key=self.changelog.rev, reverse=True)
 
     def branchheads(self, branch=None, start=None, closed=False):
         '''return a (possibly filtered) list of heads for the given branch
 
         Heads are returned in topological order, from newest to oldest.
         If branch is None, use the dirstate branch.
         If start is not None, return only heads reachable from start.
         If closed is True, return heads that are marked as closed as well.
         '''
         if branch is None:
             branch = self[None].branch()
         branches = self.branchmap()
         if branch not in branches:
             return []
         # the cache returns heads ordered lowest to highest
         bheads = list(reversed(branches.branchheads(branch, closed=closed)))
         if start is not None:
             # filter out the heads that cannot be reached from startrev
             fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
             bheads = [h for h in bheads if h in fbheads]
         return bheads
 
     def branches(self, nodes):
         if not nodes:
             nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while True:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom and n != nullid:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n)
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def checkpush(self, pushop):
         """Extensions can override this function if additional checks have
         to be performed before pushing, or call it if they override push
         command.
         """
         pass
 
     @unfilteredpropertycache
     def prepushoutgoinghooks(self):
         """Return util.hooks consists of "(repo, remote, outgoing)"
         functions, which are called before pushing changesets.
         """
         return util.hooks()
 
     def stream_in(self, remote, requirements):
         lock = self.lock()
         try:
             # Save remote branchmap. We will use it later
             # to speed up branchcache creation
             rbranchmap = None
             if remote.capable("branchmap"):
                 rbranchmap = remote.branchmap()
 
             fp = remote.stream_out()
             l = fp.readline()
             try:
                 resp = int(l)
             except ValueError:
                 raise error.ResponseError(
                     _('unexpected response from remote server:'), l)
             if resp == 1:
                 raise util.Abort(_('operation forbidden by server'))
             elif resp == 2:
                 raise util.Abort(_('locking the remote repository failed'))
             elif resp != 0:
                 raise util.Abort(_('the server sent an unknown error code'))
             self.ui.status(_('streaming all changes\n'))
             l = fp.readline()
             try:
                 total_files, total_bytes = map(int, l.split(' ', 1))
             except (ValueError, TypeError):
                 raise error.ResponseError(
                     _('unexpected response from remote server:'), l)
             self.ui.status(_('%d files to transfer, %s of data\n') %
                            (total_files, util.bytecount(total_bytes)))
             handled_bytes = 0
             self.ui.progress(_('clone'), 0, total=total_bytes)
             start = time.time()
 
             tr = self.transaction(_('clone'))
             try:
                 for i in xrange(total_files):
                     # XXX doesn't support '\n' or '\r' in filenames
                     l = fp.readline()
                     try:
                         name, size = l.split('\0', 1)
                         size = int(size)
                     except (ValueError, TypeError):
                         raise error.ResponseError(
                             _('unexpected response from remote server:'), l)
                     if self.ui.debugflag:
                         self.ui.debug('adding %s (%s)\n' %
                                       (name, util.bytecount(size)))
                     # for backwards compat, name was partially encoded
                     ofp = self.svfs(store.decodedir(name), 'w')
                     for chunk in util.filechunkiter(fp, limit=size):
                         handled_bytes += len(chunk)
                         self.ui.progress(_('clone'), handled_bytes,
                                          total=total_bytes)
                         ofp.write(chunk)
                     ofp.close()
                 tr.close()
             finally:
                 tr.release()
 
             # Writing straight to files circumvented the inmemory caches
             self.invalidate()
 
             elapsed = time.time() - start
             if elapsed <= 0:
                 elapsed = 0.001
             self.ui.progress(_('clone'), None)
             self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
                            (util.bytecount(total_bytes), elapsed,
                             util.bytecount(total_bytes / elapsed)))
 
             # new requirements = old non-format requirements +
             #                    new format-related
             # requirements from the streamed-in repository
             requirements.update(set(self.requirements) - self.supportedformats)
             self._applyrequirements(requirements)
             self._writerequirements()
 
             if rbranchmap:
                 rbheads = []
                 closed = []
                 for bheads in rbranchmap.itervalues():
                     rbheads.extend(bheads)
                     for h in bheads:
                         r = self.changelog.rev(h)
                         b, c = self.changelog.branchinfo(r)
                         if c:
                             closed.append(h)
 
                 if rbheads:
                     rtiprev = max((int(self.changelog.rev(node))
                             for node in rbheads))
                     cache = branchmap.branchcache(rbranchmap,
                                                   self[rtiprev].node(),
                                                   rtiprev,
                                                   closednodes=closed)
                     # Try to stick it as low as possible
                     # filter above served are unlikely to be fetch from a clone
                     for candidate in ('base', 'immutable', 'served'):
                         rview = self.filtered(candidate)
                         if cache.validfor(rview):
                             self._branchcaches[candidate] = cache
                             cache.write(rview)
                             break
             self.invalidate()
             return len(self.heads()) + 1
         finally:
             lock.release()
 
     def clone(self, remote, heads=[], stream=None):
         '''clone remote repository.
 
         keyword arguments:
         heads: list of revs to clone (forces use of pull)
         stream: use streaming clone if possible'''
 
         # now, all clients that can request uncompressed clones can
         # read repo formats supported by all servers that can serve
         # them.
 
         # if revlog format changes, client will have to check version
         # and format flags on "stream" capability, and use
         # uncompressed only if compatible.
 
         if stream is None:
             # if the server explicitly prefers to stream (for fast LANs)
             stream = remote.capable('stream-preferred')
 
         if stream and not heads:
             # 'stream' means remote revlog format is revlogv1 only
             if remote.capable('stream'):
                 self.stream_in(remote, set(('revlogv1',)))
             else:
                 # otherwise, 'streamreqs' contains the remote revlog format
                 streamreqs = remote.capable('streamreqs')
                 if streamreqs:
                     streamreqs = set(streamreqs.split(','))
                     # if we support it, stream in and adjust our requirements
                     if not streamreqs - self.supportedformats:
                         self.stream_in(remote, streamreqs)
 
         quiet = self.ui.backupconfig('ui', 'quietbookmarkmove')
         try:
             self.ui.setconfig('ui', 'quietbookmarkmove', True, 'clone')
             ret = exchange.pull(self, remote, heads).cgresult
         finally:
             self.ui.restoreconfig(quiet)
         return ret
 
     def pushkey(self, namespace, key, old, new):
         try:
             self.hook('prepushkey', throw=True, namespace=namespace, key=key,
                       old=old, new=new)
         except error.HookAbort, exc:
             self.ui.write_err(_("pushkey-abort: %s\n") % exc)
             if exc.hint:
                 self.ui.write_err(_("(%s)\n") % exc.hint)
             return False
         self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
         ret = pushkey.push(self, namespace, key, old, new)
         def runhook():
             self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
                       ret=ret)
         self._afterlock(runhook)
         return ret
 
     def listkeys(self, namespace):
         self.hook('prelistkeys', throw=True, namespace=namespace)
         self.ui.debug('listing keys for "%s"\n' % namespace)
         values = pushkey.list(self, namespace)
         self.hook('listkeys', namespace=namespace, values=values)
         return values
 
     def debugwireargs(self, one, two, three=None, four=None, five=None):
         '''used to test argument passing over the wire'''
         return "%s %s %s %s %s" % (one, two, three, four, five)
 
     def savecommitmessage(self, text):
         fp = self.vfs('last-message.txt', 'wb')
         try:
             fp.write(text)
         finally:
             fp.close()
         return self.pathto(fp.name[len(self.root) + 1:])
 
 # used to avoid circular references so destructors work
 def aftertrans(files):
     renamefiles = [tuple(t) for t in files]
     def a():
         for vfs, src, dest in renamefiles:
             try:
                 vfs.rename(src, dest)
             except OSError: # journal file does not yet exist
                 pass
     return a
 
 def undoname(fn):
     base, name = os.path.split(fn)
     assert name.startswith('journal')
     return os.path.join(base, name.replace('journal', 'undo', 1))
 
 def instance(ui, path, create):
     return localrepository(ui, util.urllocalpath(path), create)
 
 def islocal(path):
     return True

mercurial/subrepo.py

@@ -1,1791 +1,1803 b''
 # subrepo.py - sub-repository handling for Mercurial
 #
 # Copyright 2009-2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import copy
 import errno, os, re, shutil, posixpath, sys
 import xml.dom.minidom
 import stat, subprocess, tarfile
 from i18n import _
 import config, util, node, error, cmdutil, scmutil, match as matchmod
 import phases
 import pathutil
 import exchange
 hg = None
 propertycache = util.propertycache
 
 nullstate = ('', '', 'empty')
 
 def _expandedabspath(path):
     '''
     get a path or url and if it is a path expand it and return an absolute path
     '''
     expandedpath = util.urllocalpath(util.expandpath(path))
     u = util.url(expandedpath)
     if not u.scheme:
         path = util.normpath(os.path.abspath(u.path))
     return path
 
 def _getstorehashcachename(remotepath):
     '''get a unique filename for the store hash cache of a remote repository'''
     return util.sha1(_expandedabspath(remotepath)).hexdigest()[0:12]
 
 class SubrepoAbort(error.Abort):
     """Exception class used to avoid handling a subrepo error more than once"""
     def __init__(self, *args, **kw):
         error.Abort.__init__(self, *args, **kw)
         self.subrepo = kw.get('subrepo')
         self.cause = kw.get('cause')
 
 def annotatesubrepoerror(func):
     def decoratedmethod(self, *args, **kargs):
         try:
             res = func(self, *args, **kargs)
         except SubrepoAbort, ex:
             # This exception has already been handled
             raise ex
         except error.Abort, ex:
             subrepo = subrelpath(self)
             errormsg = str(ex) + ' ' + _('(in subrepo %s)') % subrepo
             # avoid handling this exception by raising a SubrepoAbort exception
             raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,
                                cause=sys.exc_info())
         return res
     return decoratedmethod
 
 def state(ctx, ui):
     """return a state dict, mapping subrepo paths configured in .hgsub
     to tuple: (source from .hgsub, revision from .hgsubstate, kind
     (key in types dict))
     """
     p = config.config()
     def read(f, sections=None, remap=None):
         if f in ctx:
             try:
                 data = ctx[f].data()
             except IOError, err:
                 if err.errno != errno.ENOENT:
                     raise
                 # handle missing subrepo spec files as removed
                 ui.warn(_("warning: subrepo spec file %s not found\n") % f)
                 return
             p.parse(f, data, sections, remap, read)
         else:
             raise util.Abort(_("subrepo spec file %s not found") % f)
 
     if '.hgsub' in ctx:
         read('.hgsub')
 
     for path, src in ui.configitems('subpaths'):
         p.set('subpaths', path, src, ui.configsource('subpaths', path))
 
     rev = {}
     if '.hgsubstate' in ctx:
         try:
             for i, l in enumerate(ctx['.hgsubstate'].data().splitlines()):
                 l = l.lstrip()
                 if not l:
                     continue
                 try:
                     revision, path = l.split(" ", 1)
                 except ValueError:
                     raise util.Abort(_("invalid subrepository revision "
                                        "specifier in .hgsubstate line %d")
                                      % (i + 1))
                 rev[path] = revision
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
 
     def remap(src):
         for pattern, repl in p.items('subpaths'):
             # Turn r'C:\foo\bar' into r'C:\\foo\\bar' since re.sub
             # does a string decode.
             repl = repl.encode('string-escape')
             # However, we still want to allow back references to go
             # through unharmed, so we turn r'\\1' into r'\1'. Again,
             # extra escapes are needed because re.sub string decodes.
             repl = re.sub(r'\\\\([0-9]+)', r'\\\1', repl)
             try:
                 src = re.sub(pattern, repl, src, 1)
             except re.error, e:
                 raise util.Abort(_("bad subrepository pattern in %s: %s")
                                  % (p.source('subpaths', pattern), e))
         return src
 
     state = {}
     for path, src in p[''].items():
         kind = 'hg'
         if src.startswith('['):
             if ']' not in src:
                 raise util.Abort(_('missing ] in subrepo source'))
             kind, src = src.split(']', 1)
             kind = kind[1:]
             src = src.lstrip() # strip any extra whitespace after ']'
 
         if not util.url(src).isabs():
             parent = _abssource(ctx.repo(), abort=False)
             if parent:
                 parent = util.url(parent)
                 parent.path = posixpath.join(parent.path or '', src)
                 parent.path = posixpath.normpath(parent.path)
                 joined = str(parent)
                 # Remap the full joined path and use it if it changes,
                 # else remap the original source.
                 remapped = remap(joined)
                 if remapped == joined:
                     src = remap(src)
                 else:
                     src = remapped
 
         src = remap(src)
         state[util.pconvert(path)] = (src.strip(), rev.get(path, ''), kind)
 
     return state
 
 def writestate(repo, state):
     """rewrite .hgsubstate in (outer) repo with these subrepo states"""
     lines = ['%s %s\n' % (state[s][1], s) for s in sorted(state)]
     repo.wwrite('.hgsubstate', ''.join(lines), '')
 
 def submerge(repo, wctx, mctx, actx, overwrite):
     """delegated from merge.applyupdates: merging of .hgsubstate file
     in working context, merging context and ancestor context"""
     if mctx == actx: # backwards?
         actx = wctx.p1()
     s1 = wctx.substate
     s2 = mctx.substate
     sa = actx.substate
     sm = {}
 
     repo.ui.debug("subrepo merge %s %s %s\n" % (wctx, mctx, actx))
 
     def debug(s, msg, r=""):
         if r:
             r = "%s:%s:%s" % r
         repo.ui.debug("  subrepo %s: %s %s\n" % (s, msg, r))
 
     for s, l in sorted(s1.iteritems()):
         a = sa.get(s, nullstate)
         ld = l # local state with possible dirty flag for compares
         if wctx.sub(s).dirty():
             ld = (l[0], l[1] + "+")
         if wctx == actx: # overwrite
             a = ld
 
         if s in s2:
             r = s2[s]
             if ld == r or r == a: # no change or local is newer
                 sm[s] = l
                 continue
             elif ld == a: # other side changed
                 debug(s, "other changed, get", r)
                 wctx.sub(s).get(r, overwrite)
                 sm[s] = r
             elif ld[0] != r[0]: # sources differ
                 if repo.ui.promptchoice(
                     _(' subrepository sources for %s differ\n'
                       'use (l)ocal source (%s) or (r)emote source (%s)?'
                       '$$ &Local $$ &Remote') % (s, l[0], r[0]), 0):
                     debug(s, "prompt changed, get", r)
                     wctx.sub(s).get(r, overwrite)
                     sm[s] = r
             elif ld[1] == a[1]: # local side is unchanged
                 debug(s, "other side changed, get", r)
                 wctx.sub(s).get(r, overwrite)
                 sm[s] = r
             else:
                 debug(s, "both sides changed")
                 srepo = wctx.sub(s)
                 option = repo.ui.promptchoice(
                     _(' subrepository %s diverged (local revision: %s, '
                       'remote revision: %s)\n'
                       '(M)erge, keep (l)ocal or keep (r)emote?'
                       '$$ &Merge $$ &Local $$ &Remote')
                     % (s, srepo.shortid(l[1]), srepo.shortid(r[1])), 0)
                 if option == 0:
                     wctx.sub(s).merge(r)
                     sm[s] = l
                     debug(s, "merge with", r)
                 elif option == 1:
                     sm[s] = l
                     debug(s, "keep local subrepo revision", l)
                 else:
                     wctx.sub(s).get(r, overwrite)
                     sm[s] = r
                     debug(s, "get remote subrepo revision", r)
         elif ld == a: # remote removed, local unchanged
             debug(s, "remote removed, remove")
             wctx.sub(s).remove()
         elif a == nullstate: # not present in remote or ancestor
             debug(s, "local added, keep")
             sm[s] = l
             continue
         else:
             if repo.ui.promptchoice(
                 _(' local changed subrepository %s which remote removed\n'
                   'use (c)hanged version or (d)elete?'
                   '$$ &Changed $$ &Delete') % s, 0):
                 debug(s, "prompt remove")
                 wctx.sub(s).remove()
 
     for s, r in sorted(s2.items()):
         if s in s1:
             continue
         elif s not in sa:
             debug(s, "remote added, get", r)
             mctx.sub(s).get(r)
             sm[s] = r
         elif r != sa[s]:
             if repo.ui.promptchoice(
                 _(' remote changed subrepository %s which local removed\n'
                   'use (c)hanged version or (d)elete?'
                   '$$ &Changed $$ &Delete') % s, 0) == 0:
                 debug(s, "prompt recreate", r)
                 mctx.sub(s).get(r)
                 sm[s] = r
 
     # record merged .hgsubstate
     writestate(repo, sm)
     return sm
 
 def _updateprompt(ui, sub, dirty, local, remote):
     if dirty:
         msg = (_(' subrepository sources for %s differ\n'
                  'use (l)ocal source (%s) or (r)emote source (%s)?'
                  '$$ &Local $$ &Remote')
                % (subrelpath(sub), local, remote))
     else:
         msg = (_(' subrepository sources for %s differ (in checked out '
                  'version)\n'
                  'use (l)ocal source (%s) or (r)emote source (%s)?'
                  '$$ &Local $$ &Remote')
                % (subrelpath(sub), local, remote))
     return ui.promptchoice(msg, 0)
 
 def reporelpath(repo):
     """return path to this (sub)repo as seen from outermost repo"""
     parent = repo
     while util.safehasattr(parent, '_subparent'):
         parent = parent._subparent
     return repo.root[len(pathutil.normasprefix(parent.root)):]
 
 def subrelpath(sub):
     """return path to this subrepo as seen from outermost repo"""
     if util.safehasattr(sub, '_relpath'):
         return sub._relpath
     if not util.safehasattr(sub, '_repo'):
         return sub._path
     return reporelpath(sub._repo)
 
 def _abssource(repo, push=False, abort=True):
     """return pull/push path of repo - either based on parent repo .hgsub info
     or on the top repo config. Abort or return None if no source found."""
     if util.safehasattr(repo, '_subparent'):
         source = util.url(repo._subsource)
         if source.isabs():
             return str(source)
         source.path = posixpath.normpath(source.path)
         parent = _abssource(repo._subparent, push, abort=False)
         if parent:
             parent = util.url(util.pconvert(parent))
             parent.path = posixpath.join(parent.path or '', source.path)
             parent.path = posixpath.normpath(parent.path)
             return str(parent)
     else: # recursion reached top repo
         if util.safehasattr(repo, '_subtoppath'):
             return repo._subtoppath
         if push and repo.ui.config('paths', 'default-push'):
             return repo.ui.config('paths', 'default-push')
         if repo.ui.config('paths', 'default'):
             return repo.ui.config('paths', 'default')
         if repo.shared():
             # chop off the .hg component to get the default path form
             return os.path.dirname(repo.sharedpath)
     if abort:
         raise util.Abort(_("default path for subrepository not found"))
 
 def _sanitize(ui, path, ignore):
     for dirname, dirs, names in os.walk(path):
         for i, d in enumerate(dirs):
             if d.lower() == ignore:
                 del dirs[i]
                 break
         if os.path.basename(dirname).lower() != '.hg':
             continue
         for f in names:
             if f.lower() == 'hgrc':
                 ui.warn(_("warning: removing potentially hostile 'hgrc' "
                           "in '%s'\n") % dirname)
                 os.unlink(os.path.join(dirname, f))
 
 def subrepo(ctx, path):
     """return instance of the right subrepo class for subrepo in path"""
     # subrepo inherently violates our import layering rules
     # because it wants to make repo objects from deep inside the stack
     # so we manually delay the circular imports to not break
     # scripts that don't use our demand-loading
     global hg
     import hg as h
     hg = h
 
     pathutil.pathauditor(ctx.repo().root)(path)
     state = ctx.substate[path]
     if state[2] not in types:
         raise util.Abort(_('unknown subrepo type %s') % state[2])
     return types[state[2]](ctx, path, state[:2])
 
 def newcommitphase(ui, ctx):
     commitphase = phases.newcommitphase(ui)
     substate = getattr(ctx, "substate", None)
     if not substate:
         return commitphase
     check = ui.config('phases', 'checksubrepos', 'follow')
     if check not in ('ignore', 'follow', 'abort'):
         raise util.Abort(_('invalid phases.checksubrepos configuration: %s')
                          % (check))
     if check == 'ignore':
         return commitphase
     maxphase = phases.public
     maxsub = None
     for s in sorted(substate):
         sub = ctx.sub(s)
         subphase = sub.phase(substate[s][1])
         if maxphase < subphase:
             maxphase = subphase
             maxsub = s
     if commitphase < maxphase:
         if check == 'abort':
             raise util.Abort(_("can't commit in %s phase"
                                " conflicting %s from subrepository %s") %
                              (phases.phasenames[commitphase],
                               phases.phasenames[maxphase], maxsub))
         ui.warn(_("warning: changes are committed in"
                   " %s phase from subrepository %s\n") %
                 (phases.phasenames[maxphase], maxsub))
         return maxphase
     return commitphase
 
 # subrepo classes need to implement the following abstract class:
 
 class abstractsubrepo(object):
 
     def __init__(self, ui):
         self.ui = ui
 
     def storeclean(self, path):
         """
         returns true if the repository has not changed since it was last
         cloned from or pushed to a given repository.
         """
         return False
 
     def dirty(self, ignoreupdate=False):
         """returns true if the dirstate of the subrepo is dirty or does not
         match current stored state. If ignoreupdate is true, only check
         whether the subrepo has uncommitted changes in its dirstate.
         """
         raise NotImplementedError
 
+    def dirtyreason(self, ignoreupdate=False):
+        """return reason string if it is ``dirty()``
+
+        Returned string should have enough information for the message
+        of exception.
+
+        This returns None, otherwise.
+        """
+        if self.dirty(ignoreupdate=ignoreupdate):
+            return _("uncommitted changes in subrepository '%s'"
+                     ) % subrelpath(self)
+
     def basestate(self):
         """current working directory base state, disregarding .hgsubstate
         state and working directory modifications"""
         raise NotImplementedError
 
     def checknested(self, path):
         """check if path is a subrepository within this repository"""
         return False
 
     def commit(self, text, user, date):
         """commit the current changes to the subrepo with the given
         log message. Use given user and date if possible. Return the
         new state of the subrepo.
         """
         raise NotImplementedError
 
     def phase(self, state):
         """returns phase of specified state in the subrepository.
         """
         return phases.public
 
     def remove(self):
         """remove the subrepo
 
         (should verify the dirstate is not dirty first)
         """
         raise NotImplementedError
 
     def get(self, state, overwrite=False):
         """run whatever commands are needed to put the subrepo into
         this state
         """
         raise NotImplementedError
 
     def merge(self, state):
         """merge currently-saved state with the new state."""
         raise NotImplementedError
 
     def push(self, opts):
         """perform whatever action is analogous to 'hg push'
 
         This may be a no-op on some systems.
         """
         raise NotImplementedError
 
     def add(self, ui, match, prefix, explicitonly, **opts):
         return []
 
     def addremove(self, matcher, prefix, opts, dry_run, similarity):
         self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))
         return 1
 
     def cat(self, match, prefix, **opts):
         return 1
 
     def status(self, rev2, **opts):
         return scmutil.status([], [], [], [], [], [], [])
 
     def diff(self, ui, diffopts, node2, match, prefix, **opts):
         pass
 
     def outgoing(self, ui, dest, opts):
         return 1
 
     def incoming(self, ui, source, opts):
         return 1
 
     def files(self):
         """return filename iterator"""
         raise NotImplementedError
 
     def filedata(self, name):
         """return file data"""
         raise NotImplementedError
 
     def fileflags(self, name):
         """return file flags"""
         return ''
 
     def printfiles(self, ui, m, fm, fmt):
         """handle the files command for this subrepo"""
         return 1
 
     def archive(self, archiver, prefix, match=None):
         if match is not None:
             files = [f for f in self.files() if match(f)]
         else:
             files = self.files()
         total = len(files)
         relpath = subrelpath(self)
         self.ui.progress(_('archiving (%s)') % relpath, 0,
                          unit=_('files'), total=total)
         for i, name in enumerate(files):
             flags = self.fileflags(name)
             mode = 'x' in flags and 0755 or 0644
             symlink = 'l' in flags
             archiver.addfile(os.path.join(prefix, self._path, name),
                              mode, symlink, self.filedata(name))
             self.ui.progress(_('archiving (%s)') % relpath, i + 1,
                              unit=_('files'), total=total)
         self.ui.progress(_('archiving (%s)') % relpath, None)
         return total
 
     def walk(self, match):
         '''
         walk recursively through the directory tree, finding all files
         matched by the match function
         '''
         pass
 
     def forget(self, match, prefix):
         return ([], [])
 
     def removefiles(self, matcher, prefix, after, force, subrepos):
         """remove the matched files from the subrepository and the filesystem,
         possibly by force and/or after the file has been removed from the
         filesystem.  Return 0 on success, 1 on any warning.
         """
         return 1
 
     def revert(self, substate, *pats, **opts):
         self.ui.warn('%s: reverting %s subrepos is unsupported\n' \
             % (substate[0], substate[2]))
         return []
 
     def shortid(self, revid):
         return revid
 
 class hgsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state):
         super(hgsubrepo, self).__init__(ctx.repo().ui)
         self._path = path
         self._state = state
         self._ctx = ctx
         r = ctx.repo()
         root = r.wjoin(path)
         create = not r.wvfs.exists('%s/.hg' % path)
         self._repo = hg.repository(r.baseui, root, create=create)
         self.ui = self._repo.ui
         for s, k in [('ui', 'commitsubrepos')]:
             v = r.ui.config(s, k)
             if v:
                 self.ui.setconfig(s, k, v, 'subrepo')
         self.ui.setconfig('ui', '_usedassubrepo', 'True', 'subrepo')
         self._initrepo(r, state[0], create)
 
     def storeclean(self, path):
         lock = self._repo.lock()
         try:
             return self._storeclean(path)
         finally:
             lock.release()
 
     def _storeclean(self, path):
         clean = True
         itercache = self._calcstorehash(path)
         try:
             for filehash in self._readstorehashcache(path):
                 if filehash != itercache.next():
                     clean = False
                     break
         except StopIteration:
             # the cached and current pull states have a different size
             clean = False
         if clean:
             try:
                 itercache.next()
                 # the cached and current pull states have a different size
                 clean = False
             except StopIteration:
                 pass
         return clean
 
     def _calcstorehash(self, remotepath):
         '''calculate a unique "store hash"
 
         This method is used to to detect when there are changes that may
         require a push to a given remote path.'''
         # sort the files that will be hashed in increasing (likely) file size
         filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i')
         yield '# %s\n' % _expandedabspath(remotepath)
         vfs = self._repo.vfs
         for relname in filelist:
             filehash = util.sha1(vfs.tryread(relname)).hexdigest()
             yield '%s = %s\n' % (relname, filehash)
 
     @propertycache
     def _cachestorehashvfs(self):
         return scmutil.vfs(self._repo.join('cache/storehash'))
 
     def _readstorehashcache(self, remotepath):
         '''read the store hash cache for a given remote repository'''
         cachefile = _getstorehashcachename(remotepath)
         return self._cachestorehashvfs.tryreadlines(cachefile, 'r')
 
     def _cachestorehash(self, remotepath):
         '''cache the current store hash
 
         Each remote repo requires its own store hash cache, because a subrepo
         store may be "clean" versus a given remote repo, but not versus another
         '''
         cachefile = _getstorehashcachename(remotepath)
         lock = self._repo.lock()
         try:
             storehash = list(self._calcstorehash(remotepath))
             vfs = self._cachestorehashvfs
             vfs.writelines(cachefile, storehash, mode='w', notindexed=True)
         finally:
             lock.release()
 
     @annotatesubrepoerror
     def _initrepo(self, parentrepo, source, create):
         self._repo._subparent = parentrepo
         self._repo._subsource = source
 
         if create:
             lines = ['[paths]\n']
 
             def addpathconfig(key, value):
                 if value:
                     lines.append('%s = %s\n' % (key, value))
                     self.ui.setconfig('paths', key, value, 'subrepo')
 
             defpath = _abssource(self._repo, abort=False)
             defpushpath = _abssource(self._repo, True, abort=False)
             addpathconfig('default', defpath)
             if defpath != defpushpath:
                 addpathconfig('default-push', defpushpath)
 
             fp = self._repo.vfs("hgrc", "w", text=True)
             try:
                 fp.write(''.join(lines))
             finally:
                 fp.close()
 
     @annotatesubrepoerror
     def add(self, ui, match, prefix, explicitonly, **opts):
         return cmdutil.add(ui, self._repo, match,
                            os.path.join(prefix, self._path), explicitonly,
                            **opts)
 
     @annotatesubrepoerror
     def addremove(self, m, prefix, opts, dry_run, similarity):
         # In the same way as sub directories are processed, once in a subrepo,
         # always entry any of its subrepos.  Don't corrupt the options that will
         # be used to process sibling subrepos however.
         opts = copy.copy(opts)
         opts['subrepos'] = True
         return scmutil.addremove(self._repo, m,
                                  os.path.join(prefix, self._path), opts,
                                  dry_run, similarity)
 
     @annotatesubrepoerror
     def cat(self, match, prefix, **opts):
         rev = self._state[1]
         ctx = self._repo[rev]
         return cmdutil.cat(self.ui, self._repo, ctx, match, prefix, **opts)
 
     @annotatesubrepoerror
     def status(self, rev2, **opts):
         try:
             rev1 = self._state[1]
             ctx1 = self._repo[rev1]
             ctx2 = self._repo[rev2]
             return self._repo.status(ctx1, ctx2, **opts)
         except error.RepoLookupError, inst:
             self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
                          % (inst, subrelpath(self)))
             return scmutil.status([], [], [], [], [], [], [])
 
     @annotatesubrepoerror
     def diff(self, ui, diffopts, node2, match, prefix, **opts):
         try:
             node1 = node.bin(self._state[1])
             # We currently expect node2 to come from substate and be
             # in hex format
             if node2 is not None:
                 node2 = node.bin(node2)
             cmdutil.diffordiffstat(ui, self._repo, diffopts,
                                    node1, node2, match,
                                    prefix=posixpath.join(prefix, self._path),
                                    listsubrepos=True, **opts)
         except error.RepoLookupError, inst:
             self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
                           % (inst, subrelpath(self)))
 
     @annotatesubrepoerror
     def archive(self, archiver, prefix, match=None):
         self._get(self._state + ('hg',))
         total = abstractsubrepo.archive(self, archiver, prefix, match)
         rev = self._state[1]
         ctx = self._repo[rev]
         for subpath in ctx.substate:
             s = subrepo(ctx, subpath)
             submatch = matchmod.narrowmatcher(subpath, match)
             total += s.archive(
                 archiver, os.path.join(prefix, self._path), submatch)
         return total
 
     @annotatesubrepoerror
     def dirty(self, ignoreupdate=False):
         r = self._state[1]
         if r == '' and not ignoreupdate: # no state recorded
             return True
         w = self._repo[None]
         if r != w.p1().hex() and not ignoreupdate:
             # different version checked out
             return True
         return w.dirty() # working directory changed
 
     def basestate(self):
         return self._repo['.'].hex()
 
     def checknested(self, path):
         return self._repo._checknested(self._repo.wjoin(path))
 
     @annotatesubrepoerror
     def commit(self, text, user, date):
         # don't bother committing in the subrepo if it's only been
         # updated
         if not self.dirty(True):
             return self._repo['.'].hex()
         self.ui.debug("committing subrepo %s\n" % subrelpath(self))
         n = self._repo.commit(text, user, date)
         if not n:
             return self._repo['.'].hex() # different version checked out
         return node.hex(n)
 
     @annotatesubrepoerror
     def phase(self, state):
         return self._repo[state].phase()
 
     @annotatesubrepoerror
     def remove(self):
         # we can't fully delete the repository as it may contain
         # local-only history
         self.ui.note(_('removing subrepo %s\n') % subrelpath(self))
         hg.clean(self._repo, node.nullid, False)
 
     def _get(self, state):
         source, revision, kind = state
         if revision in self._repo.unfiltered():
             return True
         self._repo._subsource = source
         srcurl = _abssource(self._repo)
         other = hg.peer(self._repo, {}, srcurl)
         if len(self._repo) == 0:
             self.ui.status(_('cloning subrepo %s from %s\n')
                            % (subrelpath(self), srcurl))
             parentrepo = self._repo._subparent
             shutil.rmtree(self._repo.path)
             other, cloned = hg.clone(self._repo._subparent.baseui, {},
                                      other, self._repo.root,
                                      update=False)
             self._repo = cloned.local()
             self._initrepo(parentrepo, source, create=True)
             self._cachestorehash(srcurl)
         else:
             self.ui.status(_('pulling subrepo %s from %s\n')
                            % (subrelpath(self), srcurl))
             cleansub = self.storeclean(srcurl)
             exchange.pull(self._repo, other)
             if cleansub:
                 # keep the repo clean after pull
                 self._cachestorehash(srcurl)
         return False
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         inrepo = self._get(state)
         source, revision, kind = state
         repo = self._repo
         repo.ui.debug("getting subrepo %s\n" % self._path)
         if inrepo:
             urepo = repo.unfiltered()
             ctx = urepo[revision]
             if ctx.hidden():
                 urepo.ui.warn(
                     _('revision %s in subrepo %s is hidden\n') \
                     % (revision[0:12], self._path))
                 repo = urepo
         hg.updaterepo(repo, revision, overwrite)
 
     @annotatesubrepoerror
     def merge(self, state):
         self._get(state)
         cur = self._repo['.']
         dst = self._repo[state[1]]
         anc = dst.ancestor(cur)
 
         def mergefunc():
             if anc == cur and dst.branch() == cur.branch():
                 self.ui.debug("updating subrepo %s\n" % subrelpath(self))
                 hg.update(self._repo, state[1])
             elif anc == dst:
                 self.ui.debug("skipping subrepo %s\n" % subrelpath(self))
             else:
                 self.ui.debug("merging subrepo %s\n" % subrelpath(self))
                 hg.merge(self._repo, state[1], remind=False)
 
         wctx = self._repo[None]
         if self.dirty():
             if anc != dst:
                 if _updateprompt(self.ui, self, wctx.dirty(), cur, dst):
                     mergefunc()
             else:
                 mergefunc()
         else:
             mergefunc()
 
     @annotatesubrepoerror
     def push(self, opts):
         force = opts.get('force')
         newbranch = opts.get('new_branch')
         ssh = opts.get('ssh')
 
         # push subrepos depth-first for coherent ordering
         c = self._repo['']
         subs = c.substate # only repos that are committed
         for s in sorted(subs):
             if c.sub(s).push(opts) == 0:
                 return False
 
         dsturl = _abssource(self._repo, True)
         if not force:
             if self.storeclean(dsturl):
                 self.ui.status(
                     _('no changes made to subrepo %s since last push to %s\n')
                     % (subrelpath(self), dsturl))
                 return None
         self.ui.status(_('pushing subrepo %s to %s\n') %
             (subrelpath(self), dsturl))
         other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
         res = exchange.push(self._repo, other, force, newbranch=newbranch)
 
         # the repo is now clean
         self._cachestorehash(dsturl)
         return res.cgresult
 
     @annotatesubrepoerror
     def outgoing(self, ui, dest, opts):
         return hg.outgoing(ui, self._repo, _abssource(self._repo, True), opts)
 
     @annotatesubrepoerror
     def incoming(self, ui, source, opts):
         return hg.incoming(ui, self._repo, _abssource(self._repo, False), opts)
 
     @annotatesubrepoerror
     def files(self):
         rev = self._state[1]
         ctx = self._repo[rev]
         return ctx.manifest().keys()
 
     def filedata(self, name):
         rev = self._state[1]
         return self._repo[rev][name].data()
 
     def fileflags(self, name):
         rev = self._state[1]
         ctx = self._repo[rev]
         return ctx.flags(name)
 
     @annotatesubrepoerror
     def printfiles(self, ui, m, fm, fmt):
         # If the parent context is a workingctx, use the workingctx here for
         # consistency.
         if self._ctx.rev() is None:
             ctx = self._repo[None]
         else:
             rev = self._state[1]
             ctx = self._repo[rev]
         return cmdutil.files(ui, ctx, m, fm, fmt, True)
 
     def walk(self, match):
         ctx = self._repo[None]
         return ctx.walk(match)
 
     @annotatesubrepoerror
     def forget(self, match, prefix):
         return cmdutil.forget(self.ui, self._repo, match,
                               os.path.join(prefix, self._path), True)
 
     @annotatesubrepoerror
     def removefiles(self, matcher, prefix, after, force, subrepos):
         return cmdutil.remove(self.ui, self._repo, matcher,
                               os.path.join(prefix, self._path), after, force,
                               subrepos)
 
     @annotatesubrepoerror
     def revert(self, substate, *pats, **opts):
         # reverting a subrepo is a 2 step process:
         # 1. if the no_backup is not set, revert all modified
         #    files inside the subrepo
         # 2. update the subrepo to the revision specified in
         #    the corresponding substate dictionary
         self.ui.status(_('reverting subrepo %s\n') % substate[0])
         if not opts.get('no_backup'):
             # Revert all files on the subrepo, creating backups
             # Note that this will not recursively revert subrepos
             # We could do it if there was a set:subrepos() predicate
             opts = opts.copy()
             opts['date'] = None
             opts['rev'] = substate[1]
 
             self.filerevert(*pats, **opts)
 
         # Update the repo to the revision specified in the given substate
         if not opts.get('dry_run'):
             self.get(substate, overwrite=True)
 
     def filerevert(self, *pats, **opts):
         ctx = self._repo[opts['rev']]
         parents = self._repo.dirstate.parents()
         if opts.get('all'):
             pats = ['set:modified()']
         else:
             pats = []
         cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
 
     def shortid(self, revid):
         return revid[:12]
 
 class svnsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state):
         super(svnsubrepo, self).__init__(ctx.repo().ui)
         self._path = path
         self._state = state
         self._ctx = ctx
         self._exe = util.findexe('svn')
         if not self._exe:
             raise util.Abort(_("'svn' executable not found for subrepo '%s'")
                              % self._path)
 
     def _svncommand(self, commands, filename='', failok=False):
         cmd = [self._exe]
         extrakw = {}
         if not self.ui.interactive():
             # Making stdin be a pipe should prevent svn from behaving
             # interactively even if we can't pass --non-interactive.
             extrakw['stdin'] = subprocess.PIPE
             # Starting in svn 1.5 --non-interactive is a global flag
             # instead of being per-command, but we need to support 1.4 so
             # we have to be intelligent about what commands take
             # --non-interactive.
             if commands[0] in ('update', 'checkout', 'commit'):
                 cmd.append('--non-interactive')
         cmd.extend(commands)
         if filename is not None:
             path = os.path.join(self._ctx.repo().origroot, self._path, filename)
             cmd.append(path)
         env = dict(os.environ)
         # Avoid localized output, preserve current locale for everything else.
         lc_all = env.get('LC_ALL')
         if lc_all:
             env['LANG'] = lc_all
             del env['LC_ALL']
         env['LC_MESSAGES'] = 'C'
         p = subprocess.Popen(cmd, bufsize=-1, close_fds=util.closefds,
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                               universal_newlines=True, env=env, **extrakw)
         stdout, stderr = p.communicate()
         stderr = stderr.strip()
         if not failok:
             if p.returncode:
                 raise util.Abort(stderr or 'exited with code %d' % p.returncode)
             if stderr:
                 self.ui.warn(stderr + '\n')
         return stdout, stderr
 
     @propertycache
     def _svnversion(self):
         output, err = self._svncommand(['--version', '--quiet'], filename=None)
         m = re.search(r'^(\d+)\.(\d+)', output)
         if not m:
             raise util.Abort(_('cannot retrieve svn tool version'))
         return (int(m.group(1)), int(m.group(2)))
 
     def _wcrevs(self):
         # Get the working directory revision as well as the last
         # commit revision so we can compare the subrepo state with
         # both. We used to store the working directory one.
         output, err = self._svncommand(['info', '--xml'])
         doc = xml.dom.minidom.parseString(output)
         entries = doc.getElementsByTagName('entry')
         lastrev, rev = '0', '0'
         if entries:
             rev = str(entries[0].getAttribute('revision')) or '0'
             commits = entries[0].getElementsByTagName('commit')
             if commits:
                 lastrev = str(commits[0].getAttribute('revision')) or '0'
         return (lastrev, rev)
 
     def _wcrev(self):
         return self._wcrevs()[0]
 
     def _wcchanged(self):
         """Return (changes, extchanges, missing) where changes is True
         if the working directory was changed, extchanges is
         True if any of these changes concern an external entry and missing
         is True if any change is a missing entry.
         """
         output, err = self._svncommand(['status', '--xml'])
         externals, changes, missing = [], [], []
         doc = xml.dom.minidom.parseString(output)
         for e in doc.getElementsByTagName('entry'):
             s = e.getElementsByTagName('wc-status')
             if not s:
                 continue
             item = s[0].getAttribute('item')
             props = s[0].getAttribute('props')
             path = e.getAttribute('path')
             if item == 'external':
                 externals.append(path)
             elif item == 'missing':
                 missing.append(path)
             if (item not in ('', 'normal', 'unversioned', 'external')
                 or props not in ('', 'none', 'normal')):
                 changes.append(path)
         for path in changes:
             for ext in externals:
                 if path == ext or path.startswith(ext + os.sep):
                     return True, True, bool(missing)
         return bool(changes), False, bool(missing)
 
     def dirty(self, ignoreupdate=False):
         if not self._wcchanged()[0]:
             if self._state[1] in self._wcrevs() or ignoreupdate:
                 return False
         return True
 
     def basestate(self):
         lastrev, rev = self._wcrevs()
         if lastrev != rev:
             # Last committed rev is not the same than rev. We would
             # like to take lastrev but we do not know if the subrepo
             # URL exists at lastrev.  Test it and fallback to rev it
             # is not there.
             try:
                 self._svncommand(['list', '%s@%s' % (self._state[0], lastrev)])
                 return lastrev
             except error.Abort:
                 pass
         return rev
 
     @annotatesubrepoerror
     def commit(self, text, user, date):
         # user and date are out of our hands since svn is centralized
         changed, extchanged, missing = self._wcchanged()
         if not changed:
             return self.basestate()
         if extchanged:
             # Do not try to commit externals
             raise util.Abort(_('cannot commit svn externals'))
         if missing:
             # svn can commit with missing entries but aborting like hg
             # seems a better approach.
             raise util.Abort(_('cannot commit missing svn entries'))
         commitinfo, err = self._svncommand(['commit', '-m', text])
         self.ui.status(commitinfo)
         newrev = re.search('Committed revision ([0-9]+).', commitinfo)
         if not newrev:
             if not commitinfo.strip():
                 # Sometimes, our definition of "changed" differs from
                 # svn one. For instance, svn ignores missing files
                 # when committing. If there are only missing files, no
                 # commit is made, no output and no error code.
                 raise util.Abort(_('failed to commit svn changes'))
             raise util.Abort(commitinfo.splitlines()[-1])
         newrev = newrev.groups()[0]
         self.ui.status(self._svncommand(['update', '-r', newrev])[0])
         return newrev
 
     @annotatesubrepoerror
     def remove(self):
         if self.dirty():
             self.ui.warn(_('not removing repo %s because '
                            'it has changes.\n') % self._path)
             return
         self.ui.note(_('removing subrepo %s\n') % self._path)
 
         def onerror(function, path, excinfo):
             if function is not os.remove:
                 raise
             # read-only files cannot be unlinked under Windows
             s = os.stat(path)
             if (s.st_mode & stat.S_IWRITE) != 0:
                 raise
             os.chmod(path, stat.S_IMODE(s.st_mode) | stat.S_IWRITE)
             os.remove(path)
 
         path = self._ctx.repo().wjoin(self._path)
         shutil.rmtree(path, onerror=onerror)
         try:
             os.removedirs(os.path.dirname(path))
         except OSError:
             pass
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         if overwrite:
             self._svncommand(['revert', '--recursive'])
         args = ['checkout']
         if self._svnversion >= (1, 5):
             args.append('--force')
         # The revision must be specified at the end of the URL to properly
         # update to a directory which has since been deleted and recreated.
         args.append('%s@%s' % (state[0], state[1]))
         status, err = self._svncommand(args, failok=True)
         _sanitize(self.ui, self._ctx.repo().wjoin(self._path), '.svn')
         if not re.search('Checked out revision [0-9]+.', status):
             if ('is already a working copy for a different URL' in err
                 and (self._wcchanged()[:2] == (False, False))):
                 # obstructed but clean working copy, so just blow it away.
                 self.remove()
                 self.get(state, overwrite=False)
                 return
             raise util.Abort((status or err).splitlines()[-1])
         self.ui.status(status)
 
     @annotatesubrepoerror
     def merge(self, state):
         old = self._state[1]
         new = state[1]
         wcrev = self._wcrev()
         if new != wcrev:
             dirty = old == wcrev or self._wcchanged()[0]
             if _updateprompt(self.ui, self, dirty, wcrev, new):
                 self.get(state, False)
 
     def push(self, opts):
         # push is a no-op for SVN
         return True
 
     @annotatesubrepoerror
     def files(self):
         output = self._svncommand(['list', '--recursive', '--xml'])[0]
         doc = xml.dom.minidom.parseString(output)
         paths = []
         for e in doc.getElementsByTagName('entry'):
             kind = str(e.getAttribute('kind'))
             if kind != 'file':
                 continue
             name = ''.join(c.data for c
                            in e.getElementsByTagName('name')[0].childNodes
                            if c.nodeType == c.TEXT_NODE)
             paths.append(name.encode('utf-8'))
         return paths
 
     def filedata(self, name):
         return self._svncommand(['cat'], name)[0]
 
 
 class gitsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state):
         super(gitsubrepo, self).__init__(ctx.repo().ui)
         self._state = state
         self._ctx = ctx
         self._path = path
         self._relpath = os.path.join(reporelpath(ctx.repo()), path)
         self._abspath = ctx.repo().wjoin(path)
         self._subparent = ctx.repo()
         self._ensuregit()
 
     def _ensuregit(self):
         try:
             self._gitexecutable = 'git'
             out, err = self._gitnodir(['--version'])
         except OSError, e:
             if e.errno != 2 or os.name != 'nt':
                 raise
             self._gitexecutable = 'git.cmd'
             out, err = self._gitnodir(['--version'])
         versionstatus = self._checkversion(out)
         if versionstatus == 'unknown':
             self.ui.warn(_('cannot retrieve git version\n'))
         elif versionstatus == 'abort':
             raise util.Abort(_('git subrepo requires at least 1.6.0 or later'))
         elif versionstatus == 'warning':
             self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n'))
 
     @staticmethod
     def _gitversion(out):
         m = re.search(r'^git version (\d+)\.(\d+)\.(\d+)', out)
         if m:
             return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
 
         m = re.search(r'^git version (\d+)\.(\d+)', out)
         if m:
             return (int(m.group(1)), int(m.group(2)), 0)
 
         return -1
 
     @staticmethod
     def _checkversion(out):
         '''ensure git version is new enough
 
         >>> _checkversion = gitsubrepo._checkversion
         >>> _checkversion('git version 1.6.0')
         'ok'
         >>> _checkversion('git version 1.8.5')
         'ok'
         >>> _checkversion('git version 1.4.0')
         'abort'
         >>> _checkversion('git version 1.5.0')
         'warning'
         >>> _checkversion('git version 1.9-rc0')
         'ok'
         >>> _checkversion('git version 1.9.0.265.g81cdec2')
         'ok'
         >>> _checkversion('git version 1.9.0.GIT')
         'ok'
         >>> _checkversion('git version 12345')
         'unknown'
         >>> _checkversion('no')
         'unknown'
         '''
         version = gitsubrepo._gitversion(out)
         # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
         # despite the docstring comment.  For now, error on 1.4.0, warn on
         # 1.5.0 but attempt to continue.
         if version == -1:
             return 'unknown'
         if version < (1, 5, 0):
             return 'abort'
         elif version < (1, 6, 0):
             return 'warning'
         return 'ok'
 
     def _gitcommand(self, commands, env=None, stream=False):
         return self._gitdir(commands, env=env, stream=stream)[0]
 
     def _gitdir(self, commands, env=None, stream=False):
         return self._gitnodir(commands, env=env, stream=stream,
                               cwd=self._abspath)
 
     def _gitnodir(self, commands, env=None, stream=False, cwd=None):
         """Calls the git command
 
         The methods tries to call the git command. versions prior to 1.6.0
         are not supported and very probably fail.
         """
         self.ui.debug('%s: git %s\n' % (self._relpath, ' '.join(commands)))
         # unless ui.quiet is set, print git's stderr,
         # which is mostly progress and useful info
         errpipe = None
         if self.ui.quiet:
             errpipe = open(os.devnull, 'w')
         p = subprocess.Popen([self._gitexecutable] + commands, bufsize=-1,
                              cwd=cwd, env=env, close_fds=util.closefds,
                              stdout=subprocess.PIPE, stderr=errpipe)
         if stream:
             return p.stdout, None
 
         retdata = p.stdout.read().strip()
         # wait for the child to exit to avoid race condition.
         p.wait()
 
         if p.returncode != 0 and p.returncode != 1:
             # there are certain error codes that are ok
             command = commands[0]
             if command in ('cat-file', 'symbolic-ref'):
                 return retdata, p.returncode
             # for all others, abort
             raise util.Abort('git %s error %d in %s' %
                              (command, p.returncode, self._relpath))
 
         return retdata, p.returncode
 
     def _gitmissing(self):
         return not os.path.exists(os.path.join(self._abspath, '.git'))
 
     def _gitstate(self):
         return self._gitcommand(['rev-parse', 'HEAD'])
 
     def _gitcurrentbranch(self):
         current, err = self._gitdir(['symbolic-ref', 'HEAD', '--quiet'])
         if err:
             current = None
         return current
 
     def _gitremote(self, remote):
         out = self._gitcommand(['remote', 'show', '-n', remote])
         line = out.split('\n')[1]
         i = line.index('URL: ') + len('URL: ')
         return line[i:]
 
     def _githavelocally(self, revision):
         out, code = self._gitdir(['cat-file', '-e', revision])
         return code == 0
 
     def _gitisancestor(self, r1, r2):
         base = self._gitcommand(['merge-base', r1, r2])
         return base == r1
 
     def _gitisbare(self):
         return self._gitcommand(['config', '--bool', 'core.bare']) == 'true'
 
     def _gitupdatestat(self):
         """This must be run before git diff-index.
         diff-index only looks at changes to file stat;
         this command looks at file contents and updates the stat."""
         self._gitcommand(['update-index', '-q', '--refresh'])
 
     def _gitbranchmap(self):
         '''returns 2 things:
         a map from git branch to revision
         a map from revision to branches'''
         branch2rev = {}
         rev2branch = {}
 
         out = self._gitcommand(['for-each-ref', '--format',
                                 '%(objectname) %(refname)'])
         for line in out.split('\n'):
             revision, ref = line.split(' ')
             if (not ref.startswith('refs/heads/') and
                 not ref.startswith('refs/remotes/')):
                 continue
             if ref.startswith('refs/remotes/') and ref.endswith('/HEAD'):
                 continue # ignore remote/HEAD redirects
             branch2rev[ref] = revision
             rev2branch.setdefault(revision, []).append(ref)
         return branch2rev, rev2branch
 
     def _gittracking(self, branches):
         'return map of remote branch to local tracking branch'
         # assumes no more than one local tracking branch for each remote
         tracking = {}
         for b in branches:
             if b.startswith('refs/remotes/'):
                 continue
             bname = b.split('/', 2)[2]
             remote = self._gitcommand(['config', 'branch.%s.remote' % bname])
             if remote:
                 ref = self._gitcommand(['config', 'branch.%s.merge' % bname])
                 tracking['refs/remotes/%s/%s' %
                          (remote, ref.split('/', 2)[2])] = b
         return tracking
 
     def _abssource(self, source):
         if '://' not in source:
             # recognize the scp syntax as an absolute source
             colon = source.find(':')
             if colon != -1 and '/' not in source[:colon]:
                 return source
         self._subsource = source
         return _abssource(self)
 
     def _fetch(self, source, revision):
         if self._gitmissing():
             source = self._abssource(source)
             self.ui.status(_('cloning subrepo %s from %s\n') %
                             (self._relpath, source))
             self._gitnodir(['clone', source, self._abspath])
         if self._githavelocally(revision):
             return
         self.ui.status(_('pulling subrepo %s from %s\n') %
                         (self._relpath, self._gitremote('origin')))
         # try only origin: the originally cloned repo
         self._gitcommand(['fetch'])
         if not self._githavelocally(revision):
             raise util.Abort(_("revision %s does not exist in subrepo %s\n") %
                                (revision, self._relpath))
 
     @annotatesubrepoerror
     def dirty(self, ignoreupdate=False):
         if self._gitmissing():
             return self._state[1] != ''
         if self._gitisbare():
             return True
         if not ignoreupdate and self._state[1] != self._gitstate():
             # different version checked out
             return True
         # check for staged changes or modified files; ignore untracked files
         self._gitupdatestat()
         out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
         return code == 1
 
     def basestate(self):
         return self._gitstate()
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         source, revision, kind = state
         if not revision:
             self.remove()
             return
         self._fetch(source, revision)
         # if the repo was set to be bare, unbare it
         if self._gitisbare():
             self._gitcommand(['config', 'core.bare', 'false'])
             if self._gitstate() == revision:
                 self._gitcommand(['reset', '--hard', 'HEAD'])
                 return
         elif self._gitstate() == revision:
             if overwrite:
                 # first reset the index to unmark new files for commit, because
                 # reset --hard will otherwise throw away files added for commit,
                 # not just unmark them.
                 self._gitcommand(['reset', 'HEAD'])
                 self._gitcommand(['reset', '--hard', 'HEAD'])
             return
         branch2rev, rev2branch = self._gitbranchmap()
 
         def checkout(args):
             cmd = ['checkout']
             if overwrite:
                 # first reset the index to unmark new files for commit, because
                 # the -f option will otherwise throw away files added for
                 # commit, not just unmark them.
                 self._gitcommand(['reset', 'HEAD'])
                 cmd.append('-f')
             self._gitcommand(cmd + args)
             _sanitize(self.ui, self._abspath, '.git')
 
         def rawcheckout():
             # no branch to checkout, check it out with no branch
             self.ui.warn(_('checking out detached HEAD in subrepo %s\n') %
                           self._relpath)
             self.ui.warn(_('check out a git branch if you intend '
                             'to make changes\n'))
             checkout(['-q', revision])
 
         if revision not in rev2branch:
             rawcheckout()
             return
         branches = rev2branch[revision]
         firstlocalbranch = None
         for b in branches:
             if b == 'refs/heads/master':
                 # master trumps all other branches
                 checkout(['refs/heads/master'])
                 return
             if not firstlocalbranch and not b.startswith('refs/remotes/'):
                 firstlocalbranch = b
         if firstlocalbranch:
             checkout([firstlocalbranch])
             return
 
         tracking = self._gittracking(branch2rev.keys())
         # choose a remote branch already tracked if possible
         remote = branches[0]
         if remote not in tracking:
             for b in branches:
                 if b in tracking:
                     remote = b
                     break
 
         if remote not in tracking:
             # create a new local tracking branch
             local = remote.split('/', 3)[3]
             checkout(['-b', local, remote])
         elif self._gitisancestor(branch2rev[tracking[remote]], remote):
             # When updating to a tracked remote branch,
             # if the local tracking branch is downstream of it,
             # a normal `git pull` would have performed a "fast-forward merge"
             # which is equivalent to updating the local branch to the remote.
             # Since we are only looking at branching at update, we need to
             # detect this situation and perform this action lazily.
             if tracking[remote] != self._gitcurrentbranch():
                 checkout([tracking[remote]])
             self._gitcommand(['merge', '--ff', remote])
             _sanitize(self.ui, self._abspath, '.git')
         else:
             # a real merge would be required, just checkout the revision
             rawcheckout()
 
     @annotatesubrepoerror
     def commit(self, text, user, date):
         if self._gitmissing():
             raise util.Abort(_("subrepo %s is missing") % self._relpath)
         cmd = ['commit', '-a', '-m', text]
         env = os.environ.copy()
         if user:
             cmd += ['--author', user]
         if date:
             # git's date parser silently ignores when seconds < 1e9
             # convert to ISO8601
             env['GIT_AUTHOR_DATE'] = util.datestr(date,
                                                   '%Y-%m-%dT%H:%M:%S %1%2')
         self._gitcommand(cmd, env=env)
         # make sure commit works otherwise HEAD might not exist under certain
         # circumstances
         return self._gitstate()
 
     @annotatesubrepoerror
     def merge(self, state):
         source, revision, kind = state
         self._fetch(source, revision)
         base = self._gitcommand(['merge-base', revision, self._state[1]])
         self._gitupdatestat()
         out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
 
         def mergefunc():
             if base == revision:
                 self.get(state) # fast forward merge
             elif base != self._state[1]:
                 self._gitcommand(['merge', '--no-commit', revision])
             _sanitize(self.ui, self._abspath, '.git')
 
         if self.dirty():
             if self._gitstate() != revision:
                 dirty = self._gitstate() == self._state[1] or code != 0
                 if _updateprompt(self.ui, self, dirty,
                                  self._state[1][:7], revision[:7]):
                     mergefunc()
         else:
             mergefunc()
 
     @annotatesubrepoerror
     def push(self, opts):
         force = opts.get('force')
 
         if not self._state[1]:
             return True
         if self._gitmissing():
             raise util.Abort(_("subrepo %s is missing") % self._relpath)
         # if a branch in origin contains the revision, nothing to do
         branch2rev, rev2branch = self._gitbranchmap()
         if self._state[1] in rev2branch:
             for b in rev2branch[self._state[1]]:
                 if b.startswith('refs/remotes/origin/'):
                     return True
         for b, revision in branch2rev.iteritems():
             if b.startswith('refs/remotes/origin/'):
                 if self._gitisancestor(self._state[1], revision):
                     return True
         # otherwise, try to push the currently checked out branch
         cmd = ['push']
         if force:
             cmd.append('--force')
 
         current = self._gitcurrentbranch()
         if current:
             # determine if the current branch is even useful
             if not self._gitisancestor(self._state[1], current):
                 self.ui.warn(_('unrelated git branch checked out '
                                 'in subrepo %s\n') % self._relpath)
                 return False
             self.ui.status(_('pushing branch %s of subrepo %s\n') %
                            (current.split('/', 2)[2], self._relpath))
             ret = self._gitdir(cmd + ['origin', current])
             return ret[1] == 0
         else:
             self.ui.warn(_('no branch checked out in subrepo %s\n'
                            'cannot push revision %s\n') %
                           (self._relpath, self._state[1]))
             return False
 
     @annotatesubrepoerror
     def add(self, ui, match, prefix, explicitonly, **opts):
         if self._gitmissing():
             return []
 
         (modified, added, removed,
          deleted, unknown, ignored, clean) = self.status(None, unknown=True,
                                                          clean=True)
 
         tracked = set()
         # dirstates 'amn' warn, 'r' is added again
         for l in (modified, added, deleted, clean):
             tracked.update(l)
 
         # Unknown files not of interest will be rejected by the matcher
         files = unknown
         files.extend(match.files())
 
         rejected = []
 
         files = [f for f in sorted(set(files)) if match(f)]
         for f in files:
             exact = match.exact(f)
             command = ["add"]
             if exact:
                 command.append("-f") #should be added, even if ignored
             if ui.verbose or not exact:
                 ui.status(_('adding %s\n') % match.rel(f))
 
             if f in tracked:  # hg prints 'adding' even if already tracked
                 if exact:
                     rejected.append(f)
                 continue
             if not opts.get('dry_run'):
                 self._gitcommand(command + [f])
 
         for f in rejected:
             ui.warn(_("%s already tracked!\n") % match.abs(f))
 
         return rejected
 
     @annotatesubrepoerror
     def remove(self):
         if self._gitmissing():
             return
         if self.dirty():
             self.ui.warn(_('not removing repo %s because '
                            'it has changes.\n') % self._relpath)
             return
         # we can't fully delete the repository as it may contain
         # local-only history
         self.ui.note(_('removing subrepo %s\n') % self._relpath)
         self._gitcommand(['config', 'core.bare', 'true'])
         for f in os.listdir(self._abspath):
             if f == '.git':
                 continue
             path = os.path.join(self._abspath, f)
             if os.path.isdir(path) and not os.path.islink(path):
                 shutil.rmtree(path)
             else:
                 os.remove(path)
 
     def archive(self, archiver, prefix, match=None):
         total = 0
         source, revision = self._state
         if not revision:
             return total
         self._fetch(source, revision)
 
         # Parse git's native archive command.
         # This should be much faster than manually traversing the trees
         # and objects with many subprocess calls.
         tarstream = self._gitcommand(['archive', revision], stream=True)
         tar = tarfile.open(fileobj=tarstream, mode='r|')
         relpath = subrelpath(self)
         self.ui.progress(_('archiving (%s)') % relpath, 0, unit=_('files'))
         for i, info in enumerate(tar):
             if info.isdir():
                 continue
             if match and not match(info.name):
                 continue
             if info.issym():
                 data = info.linkname
             else:
                 data = tar.extractfile(info).read()
             archiver.addfile(os.path.join(prefix, self._path, info.name),
                              info.mode, info.issym(), data)
             total += 1
             self.ui.progress(_('archiving (%s)') % relpath, i + 1,
                              unit=_('files'))
         self.ui.progress(_('archiving (%s)') % relpath, None)
         return total
 
 
     @annotatesubrepoerror
     def cat(self, match, prefix, **opts):
         rev = self._state[1]
         if match.anypats():
             return 1 #No support for include/exclude yet
 
         if not match.files():
             return 1
 
         for f in match.files():
             output = self._gitcommand(["show", "%s:%s" % (rev, f)])
             fp = cmdutil.makefileobj(self._subparent, opts.get('output'),
                                      self._ctx.node(),
                                      pathname=os.path.join(prefix, f))
             fp.write(output)
             fp.close()
         return 0
 
 
     @annotatesubrepoerror
     def status(self, rev2, **opts):
         rev1 = self._state[1]
         if self._gitmissing() or not rev1:
             # if the repo is missing, return no results
             return scmutil.status([], [], [], [], [], [], [])
         modified, added, removed = [], [], []
         self._gitupdatestat()
         if rev2:
             command = ['diff-tree', rev1, rev2]
         else:
             command = ['diff-index', rev1]
         out = self._gitcommand(command)
         for line in out.split('\n'):
             tab = line.find('\t')
             if tab == -1:
                 continue
             status, f = line[tab - 1], line[tab + 1:]
             if status == 'M':
                 modified.append(f)
             elif status == 'A':
                 added.append(f)
             elif status == 'D':
                 removed.append(f)
 
         deleted, unknown, ignored, clean = [], [], [], []
 
         command = ['status', '--porcelain', '-z']
         if opts.get('unknown'):
             command += ['--untracked-files=all']
         if opts.get('ignored'):
             command += ['--ignored']
         out = self._gitcommand(command)
 
         changedfiles = set()
         changedfiles.update(modified)
         changedfiles.update(added)
         changedfiles.update(removed)
         for line in out.split('\0'):
             if not line:
                 continue
             st = line[0:2]
             #moves and copies show 2 files on one line
             if line.find('\0') >= 0:
                 filename1, filename2 = line[3:].split('\0')
             else:
                 filename1 = line[3:]
                 filename2 = None
 
             changedfiles.add(filename1)
             if filename2:
                 changedfiles.add(filename2)
 
             if st == '??':
                 unknown.append(filename1)
             elif st == '!!':
                 ignored.append(filename1)
 
         if opts.get('clean'):
             out = self._gitcommand(['ls-files'])
             for f in out.split('\n'):
                 if not f in changedfiles:
                     clean.append(f)
 
         return scmutil.status(modified, added, removed, deleted,
                               unknown, ignored, clean)
 
     @annotatesubrepoerror
     def diff(self, ui, diffopts, node2, match, prefix, **opts):
         node1 = self._state[1]
         cmd = ['diff']
         if opts['stat']:
             cmd.append('--stat')
         else:
             # for Git, this also implies '-p'
             cmd.append('-U%d' % diffopts.context)
 
         gitprefix = os.path.join(prefix, self._path)
 
         if diffopts.noprefix:
             cmd.extend(['--src-prefix=%s/' % gitprefix,
                         '--dst-prefix=%s/' % gitprefix])
         else:
             cmd.extend(['--src-prefix=a/%s/' % gitprefix,
                         '--dst-prefix=b/%s/' % gitprefix])
 
         if diffopts.ignorews:
             cmd.append('--ignore-all-space')
         if diffopts.ignorewsamount:
             cmd.append('--ignore-space-change')
         if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \
                 and diffopts.ignoreblanklines:
             cmd.append('--ignore-blank-lines')
 
         cmd.append(node1)
         if node2:
             cmd.append(node2)
 
         if match.anypats():
             return #No support for include/exclude yet
 
         output = ""
         if match.always():
             output += self._gitcommand(cmd) + '\n'
         elif match.files():
             for f in match.files():
                 output += self._gitcommand(cmd + [f]) + '\n'
         elif match(gitprefix): #Subrepo is matched
             output += self._gitcommand(cmd) + '\n'
 
         if output.strip():
             ui.write(output)
 
     @annotatesubrepoerror
     def revert(self, substate, *pats, **opts):
         self.ui.status(_('reverting subrepo %s\n') % substate[0])
         if not opts.get('no_backup'):
             status = self.status(None)
             names = status.modified
             for name in names:
                 bakname = "%s.orig" % name
                 self.ui.note(_('saving current version of %s as %s\n') %
                         (name, bakname))
                 util.rename(os.path.join(self._abspath, name),
                             os.path.join(self._abspath, bakname))
 
         if not opts.get('dry_run'):
             self.get(substate, overwrite=True)
         return []
 
     def shortid(self, revid):
         return revid[:7]
 
 types = {
     'hg': hgsubrepo,
     'svn': svnsubrepo,
     'git': gitsubrepo,
     }

tests/test-largefiles-misc.t

@@ -1,1074 +1,1074 b''
 This file contains testcases that tend to be related to special cases or less
 common commands affecting largefile.
 
 Each sections should be independent of each others.
 
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 
 
 Test copies and moves from a directory other than root (issue3516)
 =========================================================================
 
   $ hg init lf_cpmv
   $ cd lf_cpmv
   $ mkdir dira
   $ mkdir dira/dirb
   $ touch dira/dirb/largefile
   $ hg add --large dira/dirb/largefile
   $ hg commit -m "added"
   Invoking status precommit hook
   A dira/dirb/largefile
   $ cd dira
   $ hg cp dirb/largefile foo/largefile
   $ hg ci -m "deep copy"
   Invoking status precommit hook
   A dira/foo/largefile
   $ find . | sort
   .
   ./dirb
   ./dirb/largefile
   ./foo
   ./foo/largefile
   $ hg mv foo/largefile baz/largefile
   $ hg ci -m "moved"
   Invoking status precommit hook
   A dira/baz/largefile
   R dira/foo/largefile
   $ find . | sort
   .
   ./baz
   ./baz/largefile
   ./dirb
   ./dirb/largefile
   $ cd ..
   $ hg mv dira dirc
   moving .hglf/dira/baz/largefile to .hglf/dirc/baz/largefile (glob)
   moving .hglf/dira/dirb/largefile to .hglf/dirc/dirb/largefile (glob)
   $ find * | sort
   dirc
   dirc/baz
   dirc/baz/largefile
   dirc/dirb
   dirc/dirb/largefile
 
   $ hg clone -q . ../fetch
   $ hg --config extensions.fetch= fetch ../fetch
   abort: uncommitted changes
   [255]
   $ hg up -qC
   $ cd ..
 
 Clone a local repository owned by another user
 ===================================================
 
 #if unix-permissions
 
 We have to simulate that here by setting $HOME and removing write permissions
   $ ORIGHOME="$HOME"
   $ mkdir alice
   $ HOME="`pwd`/alice"
   $ cd alice
   $ hg init pubrepo
   $ cd pubrepo
   $ dd if=/dev/zero bs=1k count=11k > a-large-file 2> /dev/null
   $ hg add --large a-large-file
   $ hg commit -m "Add a large file"
   Invoking status precommit hook
   A a-large-file
   $ cd ..
   $ chmod -R a-w pubrepo
   $ cd ..
   $ mkdir bob
   $ HOME="`pwd`/bob"
   $ cd bob
   $ hg clone --pull ../alice/pubrepo pubrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ chmod -R u+w alice/pubrepo
   $ HOME="$ORIGHOME"
 
 #endif
 
 
 Symlink to a large largefile should behave the same as a symlink to a normal file
 =====================================================================================
 
 #if symlink
 
   $ hg init largesymlink
   $ cd largesymlink
   $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null
   $ hg add --large largefile
   $ hg commit -m "commit a large file"
   Invoking status precommit hook
   A largefile
   $ ln -s largefile largelink
   $ hg add largelink
   $ hg commit -m "commit a large symlink"
   Invoking status precommit hook
   A largelink
   $ rm -f largelink
   $ hg up >/dev/null
   $ test -f largelink
   [1]
   $ test -L largelink
   [1]
   $ rm -f largelink # make next part of the test independent of the previous
   $ hg up -C >/dev/null
   $ test -f largelink
   $ test -L largelink
   $ cd ..
 
 #endif
 
 
 test for pattern matching on 'hg status':
 ==============================================
 
 
 to boost performance, largefiles checks whether specified patterns are
 related to largefiles in working directory (NOT to STANDIN) or not.
 
   $ hg init statusmatch
   $ cd statusmatch
 
   $ mkdir -p a/b/c/d
   $ echo normal > a/b/c/d/e.normal.txt
   $ hg add a/b/c/d/e.normal.txt
   $ echo large > a/b/c/d/e.large.txt
   $ hg add --large a/b/c/d/e.large.txt
   $ mkdir -p a/b/c/x
   $ echo normal > a/b/c/x/y.normal.txt
   $ hg add a/b/c/x/y.normal.txt
   $ hg commit -m 'add files'
   Invoking status precommit hook
   A a/b/c/d/e.large.txt
   A a/b/c/d/e.normal.txt
   A a/b/c/x/y.normal.txt
 
 (1) no pattern: no performance boost
   $ hg status -A
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 (2) pattern not related to largefiles: performance boost
   $ hg status -A a/b/c/x
   C a/b/c/x/y.normal.txt
 
 (3) pattern related to largefiles: no performance boost
   $ hg status -A a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
 
 (4) pattern related to STANDIN (not to largefiles): performance boost
   $ hg status -A .hglf/a
   C .hglf/a/b/c/d/e.large.txt
 
 (5) mixed case: no performance boost
   $ hg status -A a/b/c/x a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 verify that largefiles doesn't break filesets
 
   $ hg log --rev . --exclude "set:binary()"
   changeset:   0:41bd42f10efa
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
 verify that large files in subrepos handled properly
   $ hg init subrepo
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
   Invoking status precommit hook
   A .hgsub
   ? .hgsubstate
   $ echo "rev 1" > subrepo/large.txt
   $ hg add --large subrepo/large.txt
   $ hg sum
   parent: 1:8ee150ea2e9c tip
    add subrepo
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg st
   $ hg st -S
   A subrepo/large.txt
   $ hg ci -S -m "commit top repo"
   committing subrepository subrepo
   Invoking status precommit hook
   A large.txt
   Invoking status precommit hook
   M .hgsubstate
 # No differences
   $ hg st -S
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: (clean)
   update: (current)
   $ echo "rev 2" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg ci -m "this commit should fail without -S"
-  abort: uncommitted changes in subrepo subrepo
+  abort: uncommitted changes in subrepository 'subrepo'
   (use --subrepos for recursive commit)
   [255]
 
 Add a normal file to the subrepo, then test archiving
 
   $ echo 'normal file' > subrepo/normal.txt
   $ touch large.dat
   $ mv subrepo/large.txt subrepo/renamed-large.txt
   $ hg addremove -S --dry-run
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg addremove --dry-run subrepo
   removing subrepo/large.txt (glob)
   adding subrepo/normal.txt (glob)
   adding subrepo/renamed-large.txt (glob)
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
   $ cd ..
 
   $ hg -R statusmatch addremove --dry-run statusmatch/subrepo
   removing statusmatch/subrepo/large.txt (glob)
   adding statusmatch/subrepo/normal.txt (glob)
   adding statusmatch/subrepo/renamed-large.txt (glob)
   $ hg -R statusmatch status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg -R statusmatch addremove --dry-run -S
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ cd statusmatch
 
   $ mv subrepo/renamed-large.txt subrepo/large.txt
   $ hg addremove subrepo
   adding subrepo/normal.txt (glob)
   $ hg forget subrepo/normal.txt
 
   $ hg addremove -S
   adding large.dat as a largefile
   adding subrepo/normal.txt
   $ rm large.dat
 
   $ hg addremove subrepo
   $ hg addremove -S
   removing large.dat
 
 Lock in subrepo, otherwise the change isn't archived
 
   $ hg ci -S -m "add normal file to top level"
   committing subrepository subrepo
   Invoking status precommit hook
   M large.txt
   A normal.txt
   Invoking status precommit hook
   M .hgsubstate
   $ hg archive -S ../lf_subrepo_archive
   $ find ../lf_subrepo_archive | sort
   ../lf_subrepo_archive
   ../lf_subrepo_archive/.hg_archival.txt
   ../lf_subrepo_archive/.hgsub
   ../lf_subrepo_archive/.hgsubstate
   ../lf_subrepo_archive/a
   ../lf_subrepo_archive/a/b
   ../lf_subrepo_archive/a/b/c
   ../lf_subrepo_archive/a/b/c/d
   ../lf_subrepo_archive/a/b/c/d/e.large.txt
   ../lf_subrepo_archive/a/b/c/d/e.normal.txt
   ../lf_subrepo_archive/a/b/c/x
   ../lf_subrepo_archive/a/b/c/x/y.normal.txt
   ../lf_subrepo_archive/subrepo
   ../lf_subrepo_archive/subrepo/large.txt
   ../lf_subrepo_archive/subrepo/normal.txt
 
 Test update with subrepos.
 
   $ hg update 0
   getting changed largefiles
   0 largefiles updated, 1 removed
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -S
   $ hg update tip
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 # modify a large file
   $ echo "modified" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
 # update -C should revert the change.
   $ hg update -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   getting changed largefiles
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 
   $ hg forget -v subrepo/large.txt
   removing subrepo/large.txt (glob)
 
 Test reverting a forgotten file
   $ hg revert -R subrepo subrepo/large.txt
   $ hg status -SA subrepo/large.txt
   C subrepo/large.txt
 
   $ hg rm -v subrepo/large.txt
   removing subrepo/large.txt (glob)
   $ hg revert -R subrepo subrepo/large.txt
   $ rm subrepo/large.txt
   $ hg addremove -S
   removing subrepo/large.txt
   $ hg st -S
   R subrepo/large.txt
 
 Test archiving a revision that references a subrepo that is not yet
 cloned (see test-subrepo-recursion.t):
 
   $ hg clone -U . ../empty
   $ cd ../empty
   $ hg archive --subrepos -r tip ../archive.tar.gz
   cloning subrepo subrepo from $TESTTMP/statusmatch/subrepo
   $ cd ..
 
 
 
 
 
 
 Test addremove, forget and others
 ==============================================
 
 Test that addremove picks up largefiles prior to the initial commit (issue3541)
 
   $ hg init addrm2
   $ cd addrm2
   $ touch large.dat
   $ touch large2.dat
   $ touch normal
   $ hg add --large large.dat
   $ hg addremove -v
   adding large2.dat as a largefile
   adding normal
 
 Test that forgetting all largefiles reverts to islfilesrepo() == False
 (addremove will add *.dat as normal files now)
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg addremove -v
   adding large.dat
   adding large2.dat
 
 Test commit's addremove option prior to the first commit
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg add --large large.dat
   $ hg ci -Am "commit"
   adding large2.dat as a largefile
   Invoking status precommit hook
   A large.dat
   A large2.dat
   A normal
   $ find .hglf | sort
   .hglf
   .hglf/large.dat
   .hglf/large2.dat
 
 Test actions on largefiles using relative paths from subdir
 
   $ mkdir sub
   $ cd sub
   $ echo anotherlarge > anotherlarge
   $ hg add --large anotherlarge
   $ hg st
   A sub/anotherlarge
   $ hg st anotherlarge
   A anotherlarge
   $ hg commit -m anotherlarge anotherlarge
   Invoking status precommit hook
   A sub/anotherlarge
   $ hg log anotherlarge
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg --debug log -T '{rev}: {desc}\n' ../sub/anotherlarge
   updated patterns: ['../.hglf/sub/../sub/anotherlarge', '../sub/anotherlarge']
   1: anotherlarge
 
   $ hg log -G anotherlarge
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     anotherlarge
   |
 
   $ hg log glob:another*
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg --debug log -T '{rev}: {desc}\n' -G glob:another*
   updated patterns: ['glob:../.hglf/sub/another*', 'glob:another*']
   @  1: anotherlarge
   |
 
 #if no-msys
   $ hg --debug log -T '{rev}: {desc}\n' 'glob:../.hglf/sub/another*' # no-msys
   updated patterns: ['glob:../.hglf/sub/another*']
   1: anotherlarge
 
   $ hg --debug log -G -T '{rev}: {desc}\n' 'glob:../.hglf/sub/another*' # no-msys
   updated patterns: ['glob:../.hglf/sub/another*']
   @  1: anotherlarge
   |
 #endif
 
   $ echo more >> anotherlarge
   $ hg st .
   M anotherlarge
   $ hg cat anotherlarge
   anotherlarge
   $ hg revert anotherlarge
   $ hg st
   ? sub/anotherlarge.orig
   $ cd ..
 
 Test glob logging from the root dir
   $ hg log glob:**another*
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg log -G glob:**another*
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     anotherlarge
   |
 
   $ cd ..
 
 Log from outer space
   $ hg --debug log -R addrm2 -T '{rev}: {desc}\n' 'addrm2/sub/anotherlarge'
   updated patterns: ['addrm2/.hglf/sub/anotherlarge', 'addrm2/sub/anotherlarge']
   1: anotherlarge
   $ hg --debug log -R addrm2 -T '{rev}: {desc}\n' 'addrm2/.hglf/sub/anotherlarge'
   updated patterns: ['addrm2/.hglf/sub/anotherlarge']
   1: anotherlarge
 
 
 Check error message while exchange
 =========================================================
 
 issue3651: summary/outgoing with largefiles shows "no remote repo"
 unexpectedly
 
   $ mkdir issue3651
   $ cd issue3651
 
   $ hg init src
   $ echo a > src/a
   $ hg -R src add --large src/a
   $ hg -R src commit -m '#0'
   Invoking status precommit hook
   A a
 
 check messages when no remote repository is specified:
 "no remote repo" route for "hg outgoing --large" is not tested here,
 because it can't be reproduced easily.
 
   $ hg init clone1
   $ hg -R clone1 -q pull src
   $ hg -R clone1 -q update
   $ hg -R clone1 paths | grep default
   [1]
 
   $ hg -R clone1 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   largefiles: (no remote repo)
 
 check messages when there is no files to upload:
 
   $ hg -q clone src clone2
   $ hg -R clone2 paths | grep default
   default = $TESTTMP/issue3651/src (glob)
 
   $ hg -R clone2 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   largefiles: (no files to upload)
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
   [1]
 
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
 
 check messages when there are files to upload:
 
   $ echo b > clone2/b
   $ hg -R clone2 add --large clone2/b
   $ hg -R clone2 commit -m '#1'
   Invoking status precommit hook
   A b
   $ hg -R clone2 summary --large
   parent: 1:1acbe71ce432 tip
    #1
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 1 entities for 1 files to upload
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   changeset:   1:1acbe71ce432
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     #1
   
   largefiles to upload (1 entities):
   b
   
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   @  1
   
   largefiles to upload (1 entities):
   b
   
 
   $ cp clone2/b clone2/b1
   $ cp clone2/b clone2/b2
   $ hg -R clone2 add --large clone2/b1 clone2/b2
   $ hg -R clone2 commit -m '#2: add largefiles referring same entity'
   Invoking status precommit hook
   A b1
   A b2
   $ hg -R clone2 summary --large
   parent: 2:6095d0695d70 tip
    #2: add largefiles referring same entity
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 1 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   largefiles to upload (1 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 1 clone2/.hglf/b
   89e6c98d92887913cadf06b2adb97f26cde4849b
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   finding outgoing largefiles: 0/2 revision (0.00%)
   finding outgoing largefiles: 1/2 revision (50.00%)
   largefiles to upload (1 entities):
   b
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
   $ echo bbb > clone2/b
   $ hg -R clone2 commit -m '#3: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ echo bbbb > clone2/b
   $ hg -R clone2 commit -m '#4: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ cp clone2/b1 clone2/b
   $ hg -R clone2 commit -m '#5: refer existing largefile entity again'
   Invoking status precommit hook
   M b
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 3 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (3 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 3 clone2/.hglf/b
   c801c9cfe94400963fcb683246217d5db77f9a9a
   $ hg -R clone2 cat -r 4 clone2/.hglf/b
   13f9ed0898e315bf59dc2973fec52037b6f441a2
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/5 revision (0.00%)
   finding outgoing largefiles: 1/5 revision (20.00%)
   finding outgoing largefiles: 2/5 revision (40.00%)
   finding outgoing largefiles: 3/5 revision (60.00%)
   finding outgoing largefiles: 4/5 revision (80.00%)
   largefiles to upload (3 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       89e6c98d92887913cadf06b2adb97f26cde4849b
       c801c9cfe94400963fcb683246217d5db77f9a9a
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
 Pushing revision #1 causes uploading entity 89e6c98d9288, which is
 shared also by largefiles b1, b2 in revision #2 and b in revision #5.
 
 Then, entity 89e6c98d9288 is not treated as "outgoing entity" at "hg
 summary" and "hg outgoing", even though files in outgoing revision #2
 and #5 refer it.
 
   $ hg -R clone2 push -r 1 -q
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   largefiles: 2 entities for 1 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (2 entities):
   b
   
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/4 revision (0.00%)
   finding outgoing largefiles: 1/4 revision (25.00%)
   finding outgoing largefiles: 2/4 revision (50.00%)
   finding outgoing largefiles: 3/4 revision (75.00%)
   largefiles to upload (2 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       c801c9cfe94400963fcb683246217d5db77f9a9a
   
 
   $ cd ..
 
 merge action 'd' for 'local renamed directory to d2/g' which has no filename
 ==================================================================================
 
   $ hg init merge-action
   $ cd merge-action
   $ touch l
   $ hg add --large l
   $ mkdir d1
   $ touch d1/f
   $ hg ci -Aqm0
   Invoking status precommit hook
   A d1/f
   A l
   $ echo > d1/f
   $ touch d1/g
   $ hg ci -Aqm1
   Invoking status precommit hook
   M d1/f
   A d1/g
   $ hg up -qr0
   $ hg mv d1 d2
   moving d1/f to d2/f (glob)
   $ hg ci -qm2
   Invoking status precommit hook
   A d2/f
   R d1/f
   $ hg merge
   merging d2/f and d1/f to d2/f
   getting changed largefiles
   0 largefiles updated, 0 removed
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 
 Merge conflicts:
 =====================
 
   $ hg init merge
   $ cd merge
   $ echo 0 > f-different
   $ echo 0 > f-same
   $ echo 0 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ hg add --large *
   $ hg ci -m0
   Invoking status precommit hook
   A f-different
   A f-same
   A f-unchanged-1
   A f-unchanged-2
   $ echo tmp1 > f-unchanged-1
   $ echo tmp1 > f-unchanged-2
   $ echo tmp1 > f-same
   $ hg ci -m1
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ echo 2 > f-different
   $ echo 0 > f-unchanged-1
   $ echo 1 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m2
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg up -qr0
   $ echo tmp2 > f-unchanged-1
   $ echo tmp2 > f-unchanged-2
   $ echo tmp2 > f-same
   $ hg ci -m3
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   created new head
   $ echo 1 > f-different
   $ echo 1 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m4
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg merge
   largefile f-different has a merge conflict
   ancestor was 09d2af8dd22201dd8d48e5dcfcaed281ff9422c7
   keep (l)ocal e5fa44f2b31c1fb553b6021e7360d07d5d91ff5e or
   take (o)ther 7448d8798a4380162d4b56f9b452e2f6f9e24e7a? l
   getting changed largefiles
   1 largefiles updated, 0 removed
   0 files updated, 4 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat f-different
   1
   $ cat f-same
   1
   $ cat f-unchanged-1
   1
   $ cat f-unchanged-2
   1
   $ cd ..
 
 Test largefile insulation (do not enabled a side effect
 ========================================================
 
 Check whether "largefiles" feature is supported only in repositories
 enabling largefiles extension.
 
   $ mkdir individualenabling
   $ cd individualenabling
 
   $ hg init enabledlocally
   $ echo large > enabledlocally/large
   $ hg -R enabledlocally add --large enabledlocally/large
   $ hg -R enabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ hg init notenabledlocally
   $ echo large > notenabledlocally/large
   $ hg -R notenabledlocally add --large notenabledlocally/large
   $ hg -R notenabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > # disable globally
   > largefiles=!
   > EOF
   $ cat >> enabledlocally/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg -R enabledlocally root
   $TESTTMP/individualenabling/enabledlocally (glob)
   $ hg -R notenabledlocally root
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see http://mercurial.selenic.com/wiki/MissingRequirement for more information)
   [255]
 
   $ hg init push-dst
   $ hg -R enabledlocally push push-dst
   pushing to push-dst
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg init pull-src
   $ hg -R pull-src pull enabledlocally
   pulling from enabledlocally
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg clone enabledlocally clone-dst
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see http://mercurial.selenic.com/wiki/MissingRequirement for more information)
   [255]
   $ test -d clone-dst
   [1]
   $ hg clone --pull enabledlocally clone-pull-dst
   abort: required features are not supported in the destination: largefiles
   [255]
   $ test -d clone-pull-dst
   [1]
 
 #if serve
 
 Test largefiles specific peer setup, when largefiles is enabled
 locally (issue4109)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
   $ mkdir -p $TESTTMP/individualenabling/usercache
 
   $ hg serve -R enabledlocally -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg init pull-dst
   $ cat > pull-dst/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > [largefiles]
   > # ignore system cache to force largefiles specific wire proto access
   > usercache=$TESTTMP/individualenabling/usercache
   > EOF
   $ hg -R pull-dst -q pull -u http://localhost:$HGPORT
 
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 #endif
 
 Test overridden functions work correctly even for repos disabling
 largefiles (issue4547)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
 (test updating implied by clone)
 
   $ hg init enabled-but-no-largefiles
   $ echo normal1 > enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles commit -m '#0@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal1
   $ cat >> enabled-but-no-largefiles/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg clone -q enabled-but-no-largefiles no-largefiles
 
 (test rebasing implied by pull: precommit while rebasing unexpectedly
 shows "normal3" as "?", because lfdirstate isn't yet written out at
 that time)
 
   $ echo normal2 > enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles commit -m '#1@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal2
 
   $ echo normal3 > no-largefiles/normal3
   $ hg -R no-largefiles add no-largefiles/normal3
   $ hg -R no-largefiles commit -m '#1@no-largefiles'
   Invoking status precommit hook
   A normal3
 
   $ hg -R no-largefiles -q pull --rebase
   Invoking status precommit hook
   ? normal3
 
 (test reverting)
 
   $ hg init subrepo-root
   $ cat >> subrepo-root/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ echo large > subrepo-root/large
   $ hg -R subrepo-root add --large subrepo-root/large
   $ hg clone -q no-largefiles subrepo-root/no-largefiles
   $ cat > subrepo-root/.hgsub <<EOF
   > no-largefiles = no-largefiles
   > EOF
   $ hg -R subrepo-root add subrepo-root/.hgsub
   $ hg -R subrepo-root commit -m '#0'
   Invoking status precommit hook
   A .hgsub
   A large
   ? .hgsubstate
   $ echo dirty >> subrepo-root/large
   $ echo dirty >> subrepo-root/no-largefiles/normal1
   $ hg -R subrepo-root status -S
   M large
   M no-largefiles/normal1
   $ hg -R subrepo-root revert --all
   reverting subrepo-root/.hglf/large (glob)
   reverting subrepo no-largefiles
   reverting subrepo-root/no-largefiles/normal1 (glob)
 
   $ cd ..
 
 
 Test "pull --rebase" when rebase is enabled before largefiles (issue3861)
 =========================================================================
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
   $ mkdir issue3861
   $ cd issue3861
   $ hg init src
   $ hg clone -q src dst
   $ echo a > src/a
   $ hg -R src commit -Aqm "#0"
   Invoking status precommit hook
   A a
 
   $ cat >> dst/.hg/hgrc <<EOF
   > [extensions]
   > largefiles=
   > EOF
   $ hg -R dst pull --rebase
   pulling from $TESTTMP/issue3861/src (glob)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   nothing to rebase - working directory parent is already an ancestor of destination bf5e395ced2c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..

tests/test-subrepo-recursion.t

@@ -1,546 +1,546 b''
 Create test repository:
 
   $ hg init repo
   $ cd repo
   $ echo x1 > x.txt
 
   $ hg init foo
   $ cd foo
   $ echo y1 > y.txt
 
   $ hg init bar
   $ cd bar
   $ echo z1 > z.txt
 
   $ cd ..
   $ echo 'bar = bar' > .hgsub
 
   $ cd ..
   $ echo 'foo = foo' > .hgsub
 
 Add files --- .hgsub files must go first to trigger subrepos:
 
   $ hg add -S .hgsub
   $ hg add -S foo/.hgsub
   $ hg add -S foo/bar
   adding foo/bar/z.txt (glob)
   $ hg add -S
   adding x.txt
   adding foo/y.txt (glob)
 
 Test recursive status without committing anything:
 
   $ hg status -S
   A .hgsub
   A foo/.hgsub
   A foo/bar/z.txt
   A foo/y.txt
   A x.txt
 
 Test recursive diff without committing anything:
 
   $ hg diff --nodates -S foo
   diff -r 000000000000 foo/.hgsub
   --- /dev/null
   +++ b/foo/.hgsub
   @@ -0,0 +1,1 @@
   +bar = bar
   diff -r 000000000000 foo/y.txt
   --- /dev/null
   +++ b/foo/y.txt
   @@ -0,0 +1,1 @@
   +y1
   diff -r 000000000000 foo/bar/z.txt
   --- /dev/null
   +++ b/foo/bar/z.txt
   @@ -0,0 +1,1 @@
   +z1
 
 Commits:
 
   $ hg commit -m fails
-  abort: uncommitted changes in subrepo foo
+  abort: uncommitted changes in subrepository 'foo'
   (use --subrepos for recursive commit)
   [255]
 
 The --subrepos flag overwrite the config setting:
 
   $ hg commit -m 0-0-0 --config ui.commitsubrepos=No --subrepos
   committing subrepository foo
   committing subrepository foo/bar (glob)
 
   $ cd foo
   $ echo y2 >> y.txt
   $ hg commit -m 0-1-0
 
   $ cd bar
   $ echo z2 >> z.txt
   $ hg commit -m 0-1-1
 
   $ cd ..
   $ hg commit -m 0-2-1
 
   $ cd ..
   $ hg commit -m 1-2-1
 
 Change working directory:
 
   $ echo y3 >> foo/y.txt
   $ echo z3 >> foo/bar/z.txt
   $ hg status -S
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status call crossing repository boundaries:
 
   $ hg status -S foo/bar/z.txt
   M foo/bar/z.txt
   $ hg status -S -I 'foo/?.txt'
   M foo/y.txt
   $ hg status -S -I '**/?.txt'
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S -I '**/?.txt'
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status from within a subdirectory:
 
   $ mkdir dir
   $ cd dir
   $ echo a1 > a.txt
   $ hg status -S
   M foo/bar/z.txt
   M foo/y.txt
   ? dir/a.txt
   $ hg diff --nodates -S
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status with relative path:
 
   $ hg status -S ..
   M ../foo/bar/z.txt
   M ../foo/y.txt
   ? a.txt
 
 XXX: filtering lfilesrepo.status() in 3.3-rc causes these files to be listed as
 added instead of modified.
   $ hg status -S .. --config extensions.largefiles=
   M ../foo/bar/z.txt
   M ../foo/y.txt
   ? a.txt
 
   $ hg diff --nodates -S ..
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
   $ cd ..
 
 Cleanup and final commit:
 
   $ rm -r dir
   $ hg commit --subrepos -m 2-3-2
   committing subrepository foo
   committing subrepository foo/bar (glob)
 
 Test explicit path commands within subrepos: add/forget
   $ echo z1 > foo/bar/z2.txt
   $ hg status -S
   ? foo/bar/z2.txt
   $ hg add foo/bar/z2.txt
   $ hg status -S
   A foo/bar/z2.txt
   $ hg forget foo/bar/z2.txt
   $ hg status -S
   ? foo/bar/z2.txt
   $ hg forget foo/bar/z2.txt
   not removing foo/bar/z2.txt: file is already untracked (glob)
   [1]
   $ hg status -S
   ? foo/bar/z2.txt
   $ rm foo/bar/z2.txt
 
 Log with the relationships between repo and its subrepo:
 
   $ hg log --template '{rev}:{node|short} {desc}\n'
   2:1326fa26d0c0 2-3-2
   1:4b3c9ff4f66b 1-2-1
   0:23376cbba0d8 0-0-0
 
   $ hg -R foo log --template '{rev}:{node|short} {desc}\n'
   3:65903cebad86 2-3-2
   2:d254738c5f5e 0-2-1
   1:8629ce7dcc39 0-1-0
   0:af048e97ade2 0-0-0
 
   $ hg -R foo/bar log --template '{rev}:{node|short} {desc}\n'
   2:31ecbdafd357 2-3-2
   1:9647f22de499 0-1-1
   0:4904098473f9 0-0-0
 
 Status between revisions:
 
   $ hg status -S
   $ hg status -S --rev 0:1
   M .hgsubstate
   M foo/.hgsubstate
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S -I '**/?.txt' --rev 0:1
   diff -r af048e97ade2 -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,1 +1,2 @@
    y1
   +y2
   diff -r 4904098473f9 -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,1 +1,2 @@
    z1
   +z2
 
 Enable progress extension for archive tests:
 
   $ cp $HGRCPATH $HGRCPATH.no-progress
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > progress =
   > [progress]
   > assume-tty = 1
   > delay = 0
   > format = topic bar number
   > refresh = 0
   > width = 60
   > EOF
 
 Test archiving to a directory tree (the doubled lines in the output
 only show up in the test output, not in real usage):
 
   $ hg archive --subrepos ../archive
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (glob) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive | sort
   ../archive
   ../archive/.hg_archival.txt
   ../archive/.hgsub
   ../archive/.hgsubstate
   ../archive/foo
   ../archive/foo/.hgsub
   ../archive/foo/.hgsubstate
   ../archive/foo/bar
   ../archive/foo/bar/z.txt
   ../archive/foo/y.txt
   ../archive/x.txt
 
 Test archiving to zip file (unzip output is unstable):
 
   $ hg archive --subrepos ../archive.zip
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (glob) (esc)
                                                               \r (no-eol) (esc)
 
 Test archiving a revision that references a subrepo that is not yet
 cloned:
 
   $ hg clone -U . ../empty
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ cd ../empty
   $ hg archive --subrepos -r tip ../archive.tar.gz
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (glob) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (glob) (esc)
                                                               \r (no-eol) (esc)
   cloning subrepo foo from $TESTTMP/repo/foo
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar (glob)
 
 The newly cloned subrepos contain no working copy:
 
   $ hg -R foo summary
   parent: -1:000000000000  (no revision checked out)
   branch: default
   commit: (clean)
   update: 4 new changesets (update)
 
 Disable progress extension and cleanup:
 
   $ mv $HGRCPATH.no-progress $HGRCPATH
 
 Test archiving when there is a directory in the way for a subrepo
 created by archive:
 
   $ hg clone -U . ../almost-empty
   $ cd ../almost-empty
   $ mkdir foo
   $ echo f > foo/f
   $ hg archive --subrepos -r tip archive
   cloning subrepo foo from $TESTTMP/empty/foo
   abort: destination '$TESTTMP/almost-empty/foo' is not empty (in subrepo foo) (glob)
   [255]
 
 Clone and test outgoing:
 
   $ cd ..
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo foo from $TESTTMP/repo/foo
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar (glob)
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo2
   $ hg outgoing -S
   comparing with $TESTTMP/repo (glob)
   searching for changes
   no changes found
   comparing with $TESTTMP/repo/foo
   searching for changes
   no changes found
   comparing with $TESTTMP/repo/foo/bar
   searching for changes
   no changes found
   [1]
 
 Make nested change:
 
   $ echo y4 >> foo/y.txt
   $ hg diff --nodates -S
   diff -r 65903cebad86 foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,3 +1,4 @@
    y1
    y2
    y3
   +y4
   $ hg commit --subrepos -m 3-4-2
   committing subrepository foo
   $ hg outgoing -S
   comparing with $TESTTMP/repo (glob)
   searching for changes
   changeset:   3:2655b8ecc4ee
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo/foo
   searching for changes
   changeset:   4:e96193d6cb36
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo/foo/bar
   searching for changes
   no changes found
 
 
 Switch to original repo and setup default path:
 
   $ cd ../repo
   $ echo '[paths]' >> .hg/hgrc
   $ echo 'default = ../repo2' >> .hg/hgrc
 
 Test incoming:
 
   $ hg incoming -S
   comparing with $TESTTMP/repo2 (glob)
   searching for changes
   changeset:   3:2655b8ecc4ee
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo2/foo
   searching for changes
   changeset:   4:e96193d6cb36
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo2/foo/bar
   searching for changes
   no changes found
 
   $ hg incoming -S --bundle incoming.hg
   abort: cannot combine --bundle and --subrepos
   [255]
 
 Test missing subrepo:
 
   $ rm -r foo
   $ hg status -S
   warning: error "unknown revision '65903cebad86f1a84bd4f1134f62fa7dcb7a1c98'" in subrepository "foo"
 
 Issue2619: IndexError: list index out of range on hg add with subrepos
 The subrepo must sorts after the explicit filename.
 
   $ cd ..
   $ hg init test
   $ cd test
   $ hg init x
   $ echo abc > abc.txt
   $ hg ci -Am "abc"
   adding abc.txt
   $ echo "x = x" >> .hgsub
   $ hg add .hgsub
   $ touch a x/a
   $ hg add a x/a
 
   $ hg ci -Sm "added x"
   committing subrepository x
   $ echo abc > x/a
   $ hg revert --rev '.^' "set:subrepo('glob:x*')"
   abort: subrepository 'x' does not exist in 25ac2c9b3180!
   [255]
 
   $ cd ..

tests/test-subrepo.t

@@ -1,1618 +1,1618 b''
 Let commit recurse into subrepos by default to match pre-2.0 behavior:
 
   $ echo "[ui]" >> $HGRCPATH
   $ echo "commitsubrepos = Yes" >> $HGRCPATH
 
   $ hg init t
   $ cd t
 
 first revision, no sub
 
   $ echo a > a
   $ hg ci -Am0
   adding a
 
 add first sub
 
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ echo a > s/a
 
 Issue2232: committing a subrepo without .hgsub
 
   $ hg ci -mbad s
   abort: can't commit subrepos without .hgsub
   [255]
 
   $ hg -R s add s/a
   $ hg files -S
   .hgsub
   a
   s/a (glob)
 
   $ hg -R s ci -Ams0
   $ hg sum
   parent: 0:f7b1eb17ad24 tip
    0
   branch: default
   commit: 1 added, 1 subrepos
   update: (current)
   $ hg ci -m1
 
 test handling .hgsubstate "added" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg add .hgsubstate
   $ hg ci -m1
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
 
 Revert subrepo and test subrepo fileset keyword:
 
   $ echo b > s/a
   $ hg revert --dry-run "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ cat s/a
   b
   $ hg revert "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ cat s/a
   a
   $ rm s/a.orig
 
 Revert subrepo with no backup. The "reverting s/a" line is gone since
 we're really running 'hg update' in the subrepo:
 
   $ echo b > s/a
   $ hg revert --no-backup s
   reverting subrepo s
 
 Issue2022: update -C
 
   $ echo b > s/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: (clean)
   update: (current)
 
 commands that require a clean repo should respect subrepos
 
   $ echo b >> s/a
   $ hg backout tip
   abort: uncommitted changes in subrepo s
   [255]
   $ hg revert -C -R s s/a
 
 add sub sub
 
   $ echo ss = ss > s/.hgsub
   $ hg init s/ss
   $ echo a > s/ss/a
   $ hg -R s add s/.hgsub
   $ hg -R s/ss add s/ss/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg ci -m2
   committing subrepository s
   committing subrepository s/ss (glob)
   $ hg sum
   parent: 2:df30734270ae tip
    2
   branch: default
   commit: (clean)
   update: (current)
 
 test handling .hgsubstate "modified" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
   $ hg rollback -q
   $ hg status -A .hgsubstate
   M .hgsubstate
   $ hg ci -m2
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
 
 bump sub rev (and check it is ignored by ui.commitsubrepos)
 
   $ echo b > s/a
   $ hg -R s ci -ms1
   $ hg --config ui.commitsubrepos=no ci -m3
 
 leave sub dirty (and check ui.commitsubrepos=no aborts the commit)
 
   $ echo c > s/a
   $ hg --config ui.commitsubrepos=no ci -m4
-  abort: uncommitted changes in subrepo s
+  abort: uncommitted changes in subrepository 's'
   (use --subrepos for recursive commit)
   [255]
   $ hg id
   f6affe3fbfaa+ tip
   $ hg -R s ci -mc
   $ hg id
   f6affe3fbfaa+ tip
   $ echo d > s/a
   $ hg ci -m4
   committing subrepository s
   $ hg tip -R s
   changeset:   4:02dcf1d70411
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
 
 check caching
 
   $ hg co 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg debugsub
 
 restore
 
   $ hg co
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsub
   path s
    source   s
    revision 02dcf1d704118aee3ee306ccfa1910850d5b05ef
 
 new branch for merge tests
 
   $ hg co 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo t = t >> .hgsub
   $ hg init t
   $ echo t > t/t
   $ hg -R t add t
   adding t/t (glob)
 
 5
 
   $ hg ci -m5 # add sub
   committing subrepository t
   created new head
   $ echo t2 > t/t
 
 6
 
   $ hg st -R s
   $ hg ci -m6 # change sub
   committing subrepository t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo t3 > t/t
 
 7
 
   $ hg ci -m7 # change sub again for conflict test
   committing subrepository t
   $ hg rm .hgsub
 
 8
 
   $ hg ci -m8 # remove sub
 
 test handling .hgsubstate "removed" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg remove .hgsubstate
   $ hg ci -m8
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
 
 merge tests
 
   $ hg co -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 5 # test adding
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 60ca1237c19474e7a3978b0dc1ca4e6f36d51382
   $ hg ci -m9
   created new head
   $ hg merge 6 --debug # test change
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1f14a2e2d3ec, local: f0d2028bf86d+, remote: 1831e14459c4
    .hgsubstate: versions differ -> m
   updating: .hgsubstate 1/1 files (100.00%)
   subrepo merge f0d2028bf86d+ 1831e14459c4 1f14a2e2d3ec
     subrepo t: other changed, get t:6747d179aa9a688023c4b0cad32e4c92bb7f34ad:hg
   getting subrepo t
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 60ca1237c194, local: 60ca1237c194+, remote: 6747d179aa9a
    t: remote is newer -> g
   getting t
   updating: t 1/1 files (100.00%)
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo conflict > t/t
   $ hg ci -m10
   committing subrepository t
   $ HGMERGE=internal:merge hg merge --debug 7 # test conflict
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1831e14459c4, local: e45c8b14af55+, remote: f94576341bcf
    .hgsubstate: versions differ -> m
   updating: .hgsubstate 1/1 files (100.00%)
   subrepo merge e45c8b14af55+ f94576341bcf 1831e14459c4
     subrepo t: both sides changed 
    subrepository t diverged (local revision: 20a0db6fbf6c, remote revision: 7af322bc1198)
   (M)erge, keep (l)ocal or keep (r)emote? m
   merging subrepo t
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 6747d179aa9a, local: 20a0db6fbf6c+, remote: 7af322bc1198
    preserving t for resolve of t
    t: versions differ -> m
   updating: t 1/1 files (100.00%)
   picked tool 'internal:merge' for t (binary False symlink False)
   merging t
   my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
   warning: conflicts during merge.
   merging t incomplete! (edit conflicts, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
     subrepo t: merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 should conflict
 
   $ cat t/t
   <<<<<<< local: 20a0db6fbf6c - test: 10
   conflict
   =======
   t3
   >>>>>>> other: 7af322bc1198  - test: 7
 
 11: remove subrepo t
 
   $ hg co -C 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg revert -r 4 .hgsub # remove t
   $ hg ci -m11
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 
 local removed, remote changed, keep changed
 
   $ hg merge 6
    remote changed subrepository t which local removed
   use (c)hanged version or (d)elete? c
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   6747d179aa9a688023c4b0cad32e4c92bb7f34ad t
   $ hg ci -m 'local removed, remote changed, keep changed'
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ cat t/t
   t2
 
 local removed, remote changed, keep removed
 
   $ hg co -C 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge --config ui.interactive=true 6 <<EOF
   > d
   > EOF
    remote changed subrepository t which local removed
   use (c)hanged version or (d)elete? d
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local removed, remote changed, keep removed'
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
 
 local changed, remote removed, keep changed
 
   $ hg co -C 6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 11
    local changed subrepository t which remote removed
   use (c)hanged version or (d)elete? c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local changed, remote removed, keep changed'
   created new head
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ cat t/t
   t2
 
 local changed, remote removed, keep removed
 
   $ hg co -C 6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge --config ui.interactive=true 11 <<EOF
   > d
   > EOF
    local changed subrepository t which remote removed
   use (c)hanged version or (d)elete? d
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local changed, remote removed, keep removed'
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
 
 clean up to avoid having to fix up the tests below
 
   $ hg co -C 10
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > strip=
   > EOF
   $ hg strip -r 11:15
   saved backup bundle to $TESTTMP/t/.hg/strip-backup/*-backup.hg (glob)
 
 clone
 
   $ cd ..
   $ hg clone t tc
   updating to branch default
   cloning subrepo s from $TESTTMP/t/s
   cloning subrepo s/ss from $TESTTMP/t/s/ss (glob)
   cloning subrepo t from $TESTTMP/t/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd tc
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 20a0db6fbf6c3d2836e6519a642ae929bfc67c0e
 
 push
 
   $ echo bah > t/t
   $ hg ci -m11
   committing subrepository t
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 push -f
 
   $ echo bah > s/a
   $ hg ci -m12
   committing subrepository s
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   abort: push creates new remote head 12a213df6fa9! (in subrepo s)
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg push -f
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 check that unmodified subrepos are not pushed
 
   $ hg clone . ../tcc
   updating to branch default
   cloning subrepo s from $TESTTMP/tc/s
   cloning subrepo s/ss from $TESTTMP/tc/s/ss (glob)
   cloning subrepo t from $TESTTMP/tc/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 the subrepos on the new clone have nothing to push to its source
 
   $ hg push -R ../tcc .
   pushing to .
   no changes made to subrepo s/ss since last push to s/ss (glob)
   no changes made to subrepo s since last push to s
   no changes made to subrepo t since last push to t
   searching for changes
   no changes found
   [1]
 
 the subrepos on the source do not have a clean store versus the clone target
 because they were never explicitly pushed to the source
 
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to ../tcc/s
   searching for changes
   no changes found
   pushing subrepo t to ../tcc/t
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 
 after push their stores become clean
 
   $ hg push ../tcc
   pushing to ../tcc
   no changes made to subrepo s/ss since last push to ../tcc/s/ss (glob)
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 updating a subrepo to a different revision or changing
 its working directory does not make its store dirty
 
   $ hg -R s update '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ echo foo >> s/a
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg -R s update -C tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 committing into a subrepo makes its store (but not its parent's store) dirty
 
   $ echo foo >> s/ss/a
   $ hg -R s/ss commit -m 'test dirty store detection'
   $ hg push
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
 
 a subrepo store may be clean versus one repo but not versus another
 
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 update
 
   $ cd ../t
   $ hg up -C # discard our earlier merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah > t/t
   $ hg ci -m13
   committing subrepository t
 
 backout calls revert internally with minimal opts, which should not raise
 KeyError
 
   $ hg backout ".^"
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   changeset c373c8102e68 backed out, don't forget to commit.
 
   $ hg up -C # discard changes
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 pull
 
   $ cd ../tc
   $ hg pull
   pulling from $TESTTMP/t (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 should pull t
 
   $ hg up
   pulling subrepo t from $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat t/t
   blah
 
 bogus subrepo path aborts
 
   $ echo 'bogus=[boguspath' >> .hgsub
   $ hg ci -m 'bogus subrepo path'
   abort: missing ] in subrepo source
   [255]
 
 Issue1986: merge aborts when trying to merge a subrepo that
 shouldn't need merging
 
 # subrepo layout
 #
 #   o   5 br
 #  /|
 # o |   4 default
 # | |
 # | o   3 br
 # |/|
 # o |   2 default
 # | |
 # | o   1 br
 # |/
 # o     0 default
 
   $ cd ..
   $ rm -rf sub
   $ hg init main
   $ cd main
   $ hg init s
   $ cd s
   $ echo a > a
   $ hg ci -Am1
   adding a
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m1
   $ hg up default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg up br
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
 
 # main repo layout:
 #
 #   * <-- try to merge default into br again
 # .`|
 # . o   5 br      --> substate = 5
 # . |
 # o |   4 default --> substate = 4
 # | |
 # | o   3 br      --> substate = 2
 # |/|
 # o |   2 default --> substate = 2
 # | |
 # | o   1 br      --> substate = 3
 # |/
 # o     0 default --> substate = 2
 
   $ cd ..
   $ echo 's = s' > .hgsub
   $ hg -R s up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci -Am1
   adding .hgsub
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg -R s up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg ci -Am1
   adding b
   $ hg up default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Am1
   adding d
   $ hg up 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo e > e
   $ hg ci -Am1
   adding e
 
   $ hg up 5
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4    # try to merge default into br again
    subrepository s diverged (local revision: f8f13b33206e, remote revision: a3f9062a4f88)
   (M)erge, keep (l)ocal or keep (r)emote? m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 test subrepo delete from .hgsubstate
 
   $ hg init testdelete
   $ mkdir testdelete/nested testdelete/nested2
   $ hg init testdelete/nested
   $ hg init testdelete/nested2
   $ echo test > testdelete/nested/foo
   $ echo test > testdelete/nested2/foo
   $ hg -R testdelete/nested add
   adding testdelete/nested/foo (glob)
   $ hg -R testdelete/nested2 add
   adding testdelete/nested2/foo (glob)
   $ hg -R testdelete/nested ci -m test
   $ hg -R testdelete/nested2 ci -m test
   $ echo nested = nested > testdelete/.hgsub
   $ echo nested2 = nested2 >> testdelete/.hgsub
   $ hg -R testdelete add
   adding testdelete/.hgsub (glob)
   $ hg -R testdelete ci -m "nested 1 & 2 added"
   $ echo nested = nested > testdelete/.hgsub
   $ hg -R testdelete ci -m "nested 2 deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
   $ hg -R testdelete remove testdelete/.hgsub
   $ hg -R testdelete ci -m ".hgsub deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
 
 test repository cloning
 
   $ mkdir mercurial mercurial2
   $ hg init nested_absolute
   $ echo test > nested_absolute/foo
   $ hg -R nested_absolute add
   adding nested_absolute/foo (glob)
   $ hg -R nested_absolute ci -mtest
   $ cd mercurial
   $ hg init nested_relative
   $ echo test2 > nested_relative/foo2
   $ hg -R nested_relative add
   adding nested_relative/foo2 (glob)
   $ hg -R nested_relative ci -mtest2
   $ hg init main
   $ echo "nested_relative = ../nested_relative" > main/.hgsub
   $ echo "nested_absolute = `pwd`/nested_absolute" >> main/.hgsub
   $ hg -R main add
   adding main/.hgsub (glob)
   $ hg -R main ci -m "add subrepos"
   $ cd ..
   $ hg clone mercurial/main mercurial2/main
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat mercurial2/main/nested_absolute/.hg/hgrc \
   >     mercurial2/main/nested_relative/.hg/hgrc
   [paths]
   default = $TESTTMP/mercurial/nested_absolute
   [paths]
   default = $TESTTMP/mercurial/nested_relative
   $ rm -rf mercurial mercurial2
 
 Issue1977: multirepo push should fail if subrepo push fails
 
   $ hg init repo
   $ hg init repo/s
   $ echo a > repo/s/a
   $ hg -R repo/s ci -Am0
   adding a
   $ echo s = s > repo/.hgsub
   $ hg -R repo ci -Am1
   adding .hgsub
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo s from $TESTTMP/repo/s
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -q -R repo2 pull -u
   $ echo 1 > repo2/s/a
   $ hg -R repo2/s ci -m2
   $ hg -q -R repo2/s push
   $ hg -R repo2/s up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > repo2/s/b
   $ hg -R repo2/s ci -m3 -A
   adding b
   created new head
   $ hg -R repo2 ci -m3
   $ hg -q -R repo2 push
   abort: push creates new remote head cc505f09a8b2! (in subrepo s)
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg -R repo update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test if untracked file is not overwritten
 
   $ echo issue3276_ok > repo/s/b
   $ hg -R repo2 push -f -q
   $ touch -t 200001010000 repo/.hgsubstate
   $ hg -R repo status --config debug.dirstate.delaywrite=2 repo/.hgsubstate
   $ hg -R repo update
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision (in subrepo s)
   [255]
 
   $ cat repo/s/b
   issue3276_ok
   $ rm repo/s/b
   $ touch -t 200001010000 repo/.hgsubstate
   $ hg -R repo revert --all
   reverting repo/.hgsubstate (glob)
   reverting subrepo s
   $ hg -R repo update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat repo/s/b
   2
   $ rm -rf repo2 repo
 
 
 Issue1852 subrepos with relative paths always push/pull relative to default
 
 Prepare a repo with subrepo
 
   $ hg init issue1852a
   $ cd issue1852a
   $ hg init sub/repo
   $ echo test > sub/repo/foo
   $ hg -R sub/repo add sub/repo/foo
   $ echo sub/repo = sub/repo > .hgsub
   $ hg add .hgsub
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ echo test >> sub/repo/foo
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ hg cat sub/repo/foo
   test
   test
   $ mkdir -p tmp/sub/repo
   $ hg cat -r 0 --output tmp/%p_p sub/repo/foo
   $ cat tmp/sub/repo/foo_p
   test
   $ mv sub/repo sub_
   $ hg cat sub/repo/baz
   skipping missing subrepository: sub/repo
   [1]
   $ rm -rf sub/repo
   $ mv sub_ sub/repo
   $ cd ..
 
 Create repo without default path, pull top repo, and see what happens on update
 
   $ hg init issue1852b
   $ hg -R issue1852b pull issue1852a
   pulling from issue1852a
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hg -R issue1852b update
   abort: default path for subrepository not found (in subrepo sub/repo) (glob)
   [255]
 
 Ensure a full traceback, not just the SubrepoAbort part
 
   $ hg -R issue1852b update --traceback 2>&1 | grep 'raise util\.Abort'
       raise util.Abort(_("default path for subrepository not found"))
 
 Pull -u now doesn't help
 
   $ hg -R issue1852b pull -u issue1852a
   pulling from issue1852a
   searching for changes
   no changes found
 
 Try the same, but with pull -u
 
   $ hg init issue1852c
   $ hg -R issue1852c pull -r0 -u issue1852a
   pulling from issue1852a
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   cloning subrepo sub/repo from issue1852a/sub/repo (glob)
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Try to push from the other side
 
   $ hg -R issue1852a push `pwd`/issue1852c
   pushing to $TESTTMP/issue1852c (glob)
   pushing subrepo sub/repo to $TESTTMP/issue1852c/sub/repo (glob)
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Incoming and outgoing should not use the default path:
 
   $ hg clone -q issue1852a issue1852d
   $ hg -R issue1852d outgoing --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
   $ hg -R issue1852d incoming --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
 
 Check status of files when none of them belong to the first
 subrepository:
 
   $ hg init subrepo-status
   $ cd subrepo-status
   $ hg init subrepo-1
   $ hg init subrepo-2
   $ cd subrepo-2
   $ touch file
   $ hg add file
   $ cd ..
   $ echo subrepo-1 = subrepo-1 > .hgsub
   $ echo subrepo-2 = subrepo-2 >> .hgsub
   $ hg add .hgsub
   $ hg ci -m 'Added subrepos'
   committing subrepository subrepo-2
   $ hg st subrepo-2/file
 
 Check that share works with subrepo
   $ hg --config extensions.share= share . ../shared
   updating working directory
   cloning subrepo subrepo-2 from $TESTTMP/subrepo-status/subrepo-2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ test -f ../shared/subrepo-1/.hg/sharedpath
   [1]
   $ hg -R ../shared in
   abort: repository default not found!
   [255]
   $ hg -R ../shared/subrepo-2 showconfig paths
   paths.default=$TESTTMP/subrepo-status/subrepo-2
   $ hg -R ../shared/subrepo-1 sum --remote
   parent: -1:000000000000 tip (empty repository)
   branch: default
   commit: (clean)
   update: (current)
   remote: (synced)
 
 Check hg update --clean
   $ cd $TESTTMP/t
   $ rm -r t/t.orig
   $ hg status -S --all
   C .hgsub
   C .hgsubstate
   C a
   C s/.hgsub
   C s/.hgsubstate
   C s/a
   C s/ss/a
   C t/t
   $ echo c1 > s/a
   $ cd s
   $ echo c1 > b
   $ echo c1 > c
   $ hg add b
   $ cd ..
   $ hg status -S
   M s/a
   A s/b
   ? s/c
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
   ? s/b
   ? s/c
 
 Sticky subrepositories, no changes
   $ cd $TESTTMP/t
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ hg update 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   365661e5936a
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Sticky subrepositories, file changes
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   365661e5936a+
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update tip
    subrepository s diverged (local revision: fc627a69481f, remote revision: 12a213df6fa9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (fc627a69481f) or (r)emote source (12a213df6fa9)? l
    subrepository t diverged (local revision: e95bcfa18a35, remote revision: 52c0adc0515a)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ
   use (l)ocal source (e95bcfa18a35) or (r)emote source (52c0adc0515a)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Sticky subrepository, revision updates
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ cd s
   $ hg update -r -2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../t
   $ hg update -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 10
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 20a0db6fbf6c)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ (in checked out version)
   use (l)ocal source (7af322bc1198) or (r)emote source (20a0db6fbf6c)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411
   $ hg -R t id
   7af322bc1198
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
   $ hg update tip
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: 12a213df6fa9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (02dcf1d70411) or (r)emote source (12a213df6fa9)? l
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 52c0adc0515a)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ
   use (l)ocal source (7af322bc1198) or (r)emote source (52c0adc0515a)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
 
 Sticky repository, update --clean
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
 
 Test subrepo already at intended revision:
   $ cd s
   $ hg update fc627a69481f
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 11
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   (M)erge, keep (l)ocal or keep (r)emote? m
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   11+
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Test that removing .hgsubstate doesn't break anything:
 
   $ hg rm -f .hgsubstate
   $ hg ci -mrm
   nothing changed
   [1]
   $ hg log -vr tip
   changeset:   13:925c17564ef8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsubstate
   description:
   13
   
   
 
 Test that removing .hgsub removes .hgsubstate:
 
   $ hg rm .hgsub
   $ hg ci -mrm2
   created new head
   $ hg log -vr tip
   changeset:   14:2400bccd50af
   tag:         tip
   parent:      11:365661e5936a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsub .hgsubstate
   description:
   rm2
   
   
 Test issue3153: diff -S with deleted subrepos
 
   $ hg diff --nodates -S -c .
   diff -r 365661e5936a -r 2400bccd50af .hgsub
   --- a/.hgsub
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -s = s
   -t = t
   diff -r 365661e5936a -r 2400bccd50af .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   -e95bcfa18a358dc4936da981ebf4147b4cad1362 t
 
 Test behavior of add for explicit path in subrepo:
   $ cd ..
   $ hg init explicit
   $ cd explicit
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ hg ci -m0
 Adding with an explicit path in a subrepo adds the file
   $ echo c1 > f1
   $ echo c2 > s/f2
   $ hg st -S
   ? f1
   ? s/f2
   $ hg add s/f2
   $ hg st -S
   A s/f2
   ? f1
   $ hg ci -R s -m0
   $ hg ci -Am1
   adding f1
 Adding with an explicit path in a subrepo with -S has the same behavior
   $ echo c3 > f3
   $ echo c4 > s/f4
   $ hg st -S
   ? f3
   ? s/f4
   $ hg add -S s/f4
   $ hg st -S
   A s/f4
   ? f3
   $ hg ci -R s -m1
   $ hg ci -Ama2
   adding f3
 Adding without a path or pattern silently ignores subrepos
   $ echo c5 > f5
   $ echo c6 > s/f6
   $ echo c7 > s/f7
   $ hg st -S
   ? f5
   ? s/f6
   ? s/f7
   $ hg add
   adding f5
   $ hg st -S
   A f5
   ? s/f6
   ? s/f7
   $ hg ci -R s -Am2
   adding f6
   adding f7
   $ hg ci -m3
 Adding without a path or pattern with -S also adds files in subrepos
   $ echo c8 > f8
   $ echo c9 > s/f9
   $ echo c10 > s/f10
   $ hg st -S
   ? f8
   ? s/f10
   ? s/f9
   $ hg add -S
   adding f8
   adding s/f10 (glob)
   adding s/f9 (glob)
   $ hg st -S
   A f8
   A s/f10
   A s/f9
   $ hg ci -R s -m3
   $ hg ci -m4
 Adding with a pattern silently ignores subrepos
   $ echo c11 > fm11
   $ echo c12 > fn12
   $ echo c13 > s/fm13
   $ echo c14 > s/fn14
   $ hg st -S
   ? fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg add 'glob:**fm*'
   adding fm11
   $ hg st -S
   A fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg ci -R s -Am4
   adding fm13
   adding fn14
   $ hg ci -Am5
   adding fn12
 Adding with a pattern with -S also adds matches in subrepos
   $ echo c15 > fm15
   $ echo c16 > fn16
   $ echo c17 > s/fm17
   $ echo c18 > s/fn18
   $ hg st -S
   ? fm15
   ? fn16
   ? s/fm17
   ? s/fn18
   $ hg add -S 'glob:**fm*'
   adding fm15
   adding s/fm17 (glob)
   $ hg st -S
   A fm15
   A s/fm17
   ? fn16
   ? s/fn18
   $ hg ci -R s -Am5
   adding fn18
   $ hg ci -Am6
   adding fn16
 
 Test behavior of forget for explicit path in subrepo:
 Forgetting an explicit path in a subrepo untracks the file
   $ echo c19 > s/f19
   $ hg add s/f19
   $ hg st -S
   A s/f19
   $ hg forget s/f19
   $ hg st -S
   ? s/f19
   $ rm s/f19
   $ cd ..
 
 Courtesy phases synchronisation to publishing server does not block the push
 (issue3781)
 
   $ cp -r main issue3781
   $ cp -r main issue3781-dest
   $ cd issue3781-dest/s
   $ hg phase tip # show we have draft changeset
   5: draft
   $ chmod a-w .hg/store/phaseroots # prevent phase push
   $ cd ../../issue3781
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > default=../issue3781-dest/
   > EOF
   $ hg push
   pushing to $TESTTMP/issue3781-dest (glob)
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
   $ cd ..
 
 Test phase choice for newly created commit with "phases.subrepochecks"
 configuration
 
   $ cd t
   $ hg update -q -r 12
 
   $ cat >> s/ss/.hg/hgrc <<EOF
   > [phases]
   > new-commit = secret
   > EOF
   $ cat >> s/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ echo phasecheck1 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=abort -m phasecheck1
   committing subrepository ss
   transaction abort!
   rollback completed
   abort: can't commit in draft phase conflicting secret from subrepository ss
   [255]
   $ echo phasecheck2 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=ignore -m phasecheck2
   committing subrepository ss
   $ hg -R s/ss phase tip
   3: secret
   $ hg -R s phase tip
   6: draft
   $ echo phasecheck3 >> s/ss/a
   $ hg -R s commit -S -m phasecheck3
   committing subrepository ss
   warning: changes are committed in secret phase from subrepository ss
   $ hg -R s/ss phase tip
   4: secret
   $ hg -R s phase tip
   7: secret
 
   $ cat >> t/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ cat >> .hg/hgrc <<EOF
   > [phases]
   > new-commit = public
   > EOF
   $ echo phasecheck4 >>   s/ss/a
   $ echo phasecheck4 >>   t/t
   $ hg commit -S -m phasecheck4
   committing subrepository s
   committing subrepository s/ss (glob)
   warning: changes are committed in secret phase from subrepository ss
   committing subrepository t
   warning: changes are committed in secret phase from subrepository s
   created new head
   $ hg -R s/ss phase tip
   5: secret
   $ hg -R s phase tip
   8: secret
   $ hg -R t phase tip
   6: draft
   $ hg phase tip
   15: secret
 
   $ cd ..
 
 
 Test that commit --secret works on both repo and subrepo (issue4182)
 
   $ cd main
   $ echo secret >> b
   $ echo secret >> s/b
   $ hg commit --secret --subrepo -m "secret"
   committing subrepository s
   $ hg phase -r .
   6: secret
   $ cd s
   $ hg phase -r .
   6: secret
   $ cd ../../
 
 Test "subrepos" template keyword
 
   $ cd t
   $ hg update -q 15
   $ cat > .hgsub <<EOF
   > s = s
   > EOF
   $ hg commit -m "16"
   warning: changes are committed in secret phase from subrepository s
 
 (addition of ".hgsub" itself)
 
   $ hg diff --nodates -c 1 .hgsubstate
   diff -r f7b1eb17ad24 -r 7cf8cfea66e4 .hgsubstate
   --- /dev/null
   +++ b/.hgsubstate
   @@ -0,0 +1,1 @@
   +e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg log -r 1 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f7b1eb17ad24 000000000000
   s
 
 (modification of existing entry)
 
   $ hg diff --nodates -c 2 .hgsubstate
   diff -r 7cf8cfea66e4 -r df30734270ae .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +dc73e2e6d2675eb2e41e33c205f4bdab4ea5111d s
   $ hg log -r 2 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   s
 
 (addition of entry)
 
   $ hg diff --nodates -c 5 .hgsubstate
   diff -r 7cf8cfea66e4 -r 1f14a2e2d3ec .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 5 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   t
 
 (removal of existing entry)
 
   $ hg diff --nodates -c 16 .hgsubstate
   diff -r 8bec38d2bd0b -r f2f70bc3d3c9 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,2 +1,1 @@
    0731af8ca9423976d3743119d0865097c07bdc1b s
   -e202dc79b04c88a636ea8913d9182a1346d9b3dc t
   $ hg log -r 16 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   8bec38d2bd0b 000000000000
   t
 
 (merging)
 
   $ hg diff --nodates -c 9 .hgsubstate
   diff -r f6affe3fbfaa -r f0d2028bf86d .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 9 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f6affe3fbfaa 1f14a2e2d3ec
   t
 
 (removal of ".hgsub" itself)
 
   $ hg diff --nodates -c 8 .hgsubstate
   diff -r f94576341bcf -r 96615c1dad2d .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   -7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4 t
   $ hg log -r 8 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f94576341bcf 000000000000
 
 Test that '[paths]' is configured correctly at subrepo creation
 
   $ cd $TESTTMP/tc
   $ cat > .hgsub <<EOF
   > # to clear bogus subrepo path 'bogus=[boguspath'
   > s = s
   > t = t
   > EOF
   $ hg update -q --clean null
   $ rm -rf s t
   $ cat >> .hg/hgrc <<EOF
   > [paths]
   > default-push = /foo/bar
   > EOF
   $ hg update -q
   $ cat s/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s
   default-push = /foo/bar/s
   $ cat s/ss/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s/ss
   default-push = /foo/bar/s/ss
   $ cat t/.hg/hgrc
   [paths]
   default = $TESTTMP/t/t
   default-push = /foo/bar/t
   $ cd ..