merge: let the user choose to merge, keep local or keep remote subrepo revisions

When a subrepo has changed on the local and remote revisions, prompt the user
whether it wants to merge those subrepo revisions, keep the local revision or
keep the remote revision.

Up until now mercurial would always perform a merge on a subrepo that had
changed on the local and the remote revisions. This is often inconvenient. For
example:

- You may want to perform the actual subrepo merge after you have merged the
parent subrepo files.
- Some subrepos may be considered "read only", in the sense that you are not
supposed to add new revisions to them. In those cases "merging a subrepo" means
choosing which _existing_ revision you want to use on the merged revision. This
is often the case for subrepos that contain binary dependencies (such as DLLs,
etc).

This new prompt makes mercurial better cope with those common scenarios.

Notes:

- The default behavior (which is the one that is used when ui is not
interactive) remains unchanged (i.e. merge is the default action).
- This prompt will be shown even if the ui --tool flag is set.
- I don't know of a way to test the "keep local" and "keep remote" options (i.e.
to force the test to choose those options).


# HG changeset patch
# User Angel Ezquerra <[e-mail]>
# Date 1378420708 -7200
#      Fri Sep 06 00:38:28 2013 +0200
# Node ID 2fb9cb0c7b26303ac3178b7739975e663075857d
# Parent  50d721553198cea51c30f53b76d41dc919280097
merge: let the user choose to merge, keep local or keep remote subrepo revisions

When a subrepo has changed on the local and remote revisions, prompt the user
whether it wants to merge those subrepo revisions, keep the local revision or
keep the remote revision.

Up until now mercurial would always perform a merge on a subrepo that had
changed on the local and the remote revisions. This is often inconvenient. For
example:

- You may want to perform the actual subrepo merge after you have merged the
parent subrepo files.
- Some subrepos may be considered "read only", in the sense that you are not
supposed to add new revisions to them. In those cases "merging a subrepo" means
choosing which _existing_ revision you want to use on the merged revision. This
is often the case for subrepos that contain binary dependencies (such as DLLs,
etc).

This new prompt makes mercurial better cope with those common scenarios.

Notes:

- The default behavior (which is the one that is used when ui is not
interactive) remains unchanged (i.e. merge is the default action).
- This prompt will be shown even if the ui --tool flag is set.
- I don't know of a way to test the "keep local" and "keep remote" options (i.e.
to force the test to choose those options).

mercurial/subrepo.py

@@ -1,1454 +1,1469
 # 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 errno, os, re, shutil, posixpath, sys
 import xml.dom.minidom
 import stat, subprocess, tarfile
 from i18n import _
 import config, scmutil, util, node, error, cmdutil, bookmarks, match as matchmod
 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]
 
 def _calcfilehash(filename):
     data = ''
     if os.path.exists(filename):
         fd = open(filename, 'rb')
         data = fd.read()
         fd.close()
     return util.sha1(data).hexdigest()
 
 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, merge with", r)
-                wctx.sub(s).merge(r)
-                sm[s] = l
+                debug(s, "both sides changed")
+                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, l[1][:12], r[1][:12]), 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)
                 wctx.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)?\n'
                  '$$ &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)?\n'
                  '$$ &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
     p = parent.root.rstrip(os.sep)
     return repo.root[len(p) + 1:]
 
 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.sharedpath != repo.path:
             # 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 itersubrepos(ctx1, ctx2):
     """find subrepos in ctx1 or ctx2"""
     # Create a (subpath, ctx) mapping where we prefer subpaths from
     # ctx1. The subpaths from ctx2 are important when the .hgsub file
     # has been modified (in ctx2) but not yet committed (in ctx1).
     subpaths = dict.fromkeys(ctx2.substate, ctx2)
     subpaths.update(dict.fromkeys(ctx1.substate, ctx1))
     for subpath, ctx in sorted(subpaths.iteritems()):
         yield subpath, ctx.sub(subpath)
 
 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
 
     scmutil.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])
 
 # subrepo classes need to implement the following abstract class:
 
 class abstractsubrepo(object):
 
     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 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 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, dryrun, listsubrepos, prefix, explicitonly):
         return []
 
     def status(self, rev2, **opts):
         return [], [], [], [], [], [], []
 
     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 archive(self, ui, 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)
         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))
             ui.progress(_('archiving (%s)') % relpath, i + 1,
                         unit=_('files'), total=total)
         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, ui, match, prefix):
         return ([], [])
 
     def revert(self, ui, substate, *pats, **opts):
         ui.warn('%s: reverting %s subrepos is unsupported\n' \
             % (substate[0], substate[2]))
         return []
 
 class hgsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state):
         self._path = path
         self._state = state
         r = ctx._repo
         root = r.wjoin(path)
         create = False
         if not os.path.exists(os.path.join(root, '.hg')):
             create = True
             util.makedirs(root)
         self._repo = hg.repository(r.baseui, root, create=create)
         for s, k in [('ui', 'commitsubrepos')]:
             v = r.ui.config(s, k)
             if v:
                 self._repo.ui.setconfig(s, k, v)
         self._repo.ui.setconfig('ui', '_usedassubrepo', 'True')
         self._initrepo(r, state[0], create)
 
     def storeclean(self, path):
         clean = True
         lock = self._repo.lock()
         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
         lock.release()
         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)
         for relname in filelist:
             absname = os.path.normpath(self._repo.join(relname))
             yield '%s = %s\n' % (relname, _calcfilehash(absname))
 
     def _getstorehashcachepath(self, remotepath):
         '''get a unique path for the store hash cache'''
         return self._repo.join(os.path.join(
             'cache', 'storehash', _getstorehashcachename(remotepath)))
 
     def _readstorehashcache(self, remotepath):
         '''read the store hash cache for a given remote repository'''
         cachefile = self._getstorehashcachepath(remotepath)
         if not os.path.exists(cachefile):
             return ''
         fd = open(cachefile, 'r')
         pullstate = fd.readlines()
         fd.close()
         return pullstate
 
     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 = self._getstorehashcachepath(remotepath)
         lock = self._repo.lock()
         storehash = list(self._calcstorehash(remotepath))
         cachedir = os.path.dirname(cachefile)
         if not os.path.exists(cachedir):
             util.makedirs(cachedir, notindexed=True)
         fd = open(cachefile, 'w')
         fd.writelines(storehash)
         fd.close()
         lock.release()
 
     @annotatesubrepoerror
     def _initrepo(self, parentrepo, source, create):
         self._repo._subparent = parentrepo
         self._repo._subsource = source
 
         if create:
             fp = self._repo.opener("hgrc", "w", text=True)
             fp.write('[paths]\n')
 
             def addpathconfig(key, value):
                 if value:
                     fp.write('%s = %s\n' % (key, value))
                     self._repo.ui.setconfig('paths', key, value)
 
             defpath = _abssource(self._repo, abort=False)
             defpushpath = _abssource(self._repo, True, abort=False)
             addpathconfig('default', defpath)
             if defpath != defpushpath:
                 addpathconfig('default-push', defpushpath)
             fp.close()
 
     @annotatesubrepoerror
     def add(self, ui, match, dryrun, listsubrepos, prefix, explicitonly):
         return cmdutil.add(ui, self._repo, match, dryrun, listsubrepos,
                            os.path.join(prefix, self._path), explicitonly)
 
     @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._repo.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
                                % (inst, subrelpath(self)))
             return [], [], [], [], [], [], []
 
     @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._repo.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
                                % (inst, subrelpath(self)))
 
     @annotatesubrepoerror
     def archive(self, ui, archiver, prefix, match=None):
         self._get(self._state + ('hg',))
         total = abstractsubrepo.archive(self, ui, 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(
                 ui, 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._repo.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 remove(self):
         # we can't fully delete the repository as it may contain
         # local-only history
         self._repo.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 not in self._repo:
             self._repo._subsource = source
             srcurl = _abssource(self._repo)
             other = hg.peer(self._repo, {}, srcurl)
             if len(self._repo) == 0:
                 self._repo.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._repo.ui.status(_('pulling subrepo %s from %s\n')
                                      % (subrelpath(self), srcurl))
                 cleansub = self.storeclean(srcurl)
                 remotebookmarks = other.listkeys('bookmarks')
                 self._repo.pull(other)
                 bookmarks.updatefromremote(self._repo.ui, self._repo,
                                            remotebookmarks, srcurl)
                 if cleansub:
                     # keep the repo clean after pull
                     self._cachestorehash(srcurl)
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         self._get(state)
         source, revision, kind = state
         self._repo.ui.debug("getting subrepo %s\n" % self._path)
         hg.updaterepo(self._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._repo.ui.debug("updating subrepo %s\n" % subrelpath(self))
                 hg.update(self._repo, state[1])
             elif anc == dst:
                 self._repo.ui.debug("skipping subrepo %s\n" % subrelpath(self))
             else:
                 self._repo.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._repo.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._repo.ui.status(
                     _('no changes made to subrepo %s since last push to %s\n')
                     % (subrelpath(self), dsturl))
                 return None
         self._repo.ui.status(_('pushing subrepo %s to %s\n') %
             (subrelpath(self), dsturl))
         other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
         res = self._repo.push(other, force, newbranch=newbranch)
 
         # the repo is now clean
         self._cachestorehash(dsturl)
         return res
 
     @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()
 
     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)
 
     def walk(self, match):
         ctx = self._repo[None]
         return ctx.walk(match)
 
     @annotatesubrepoerror
     def forget(self, ui, match, prefix):
         return cmdutil.forget(ui, self._repo, match,
                               os.path.join(prefix, self._path), True)
 
     @annotatesubrepoerror
     def revert(self, ui, 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
         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]
 
             pats = []
             if not opts.get('all'):
                 pats = ['set:modified()']
             self.filerevert(ui, *pats, **opts)
 
         # Update the repo to the revision specified in the given substate
         self.get(substate, overwrite=True)
 
     def filerevert(self, ui, *pats, **opts):
         ctx = self._repo[opts['rev']]
         parents = self._repo.dirstate.parents()
         if opts.get('all'):
             pats = ['set:modified()']
         else:
             pats = []
         cmdutil.revert(ui, self._repo, ctx, parents, *pats, **opts)
 
 class svnsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state):
         self._path = path
         self._state = state
         self._ctx = ctx
         self._ui = ctx._repo.ui
         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)
         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):
         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._ui = ctx._repo.ui
         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'])
         m = re.search(r'^git version (\d+)\.(\d+)\.(\d+)', out)
         if not m:
             self._ui.warn(_('cannot retrieve git version'))
             return
         version = (int(m.group(1)), m.group(2), m.group(3))
         # 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, 5, 0):
             raise util.Abort(_('git subrepo requires at least 1.6.0 or later'))
         elif version < (1, 6, 0):
             self._ui.warn(_('git subrepo requires at least 1.6.0 or later'))
 
     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)
 
         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])
         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])
 
         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))
             self._gitcommand(cmd + ['origin', current])
             return True
         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 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, ui, 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)
         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
             ui.progress(_('archiving (%s)') % relpath, i + 1,
                         unit=_('files'))
         ui.progress(_('archiving (%s)') % relpath, None)
         return total
 
 
     @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 [], [], [], [], [], [], []
         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 = []
         return modified, added, removed, deleted, unknown, ignored, clean
 
 types = {
     'hg': hgsubrepo,
     'svn': svnsubrepo,
     'git': gitsubrepo,
     }

tests/test-mq-subrepo.t

@@ -1,540 +1,542
   $ echo "[ui]" >> $HGRCPATH
   $ echo "commitsubrepos = Yes" >> $HGRCPATH
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
   $ echo "record=" >> $HGRCPATH
   $ echo "[diff]" >> $HGRCPATH
   $ echo "nodates=1" >> $HGRCPATH
 
   $ stdin=`pwd`/stdin.tmp
 
 fn to create new repository w/dirty subrepo, and cd into it
   $ mkrepo() {
   >     hg init $1
   >     cd $1
   >     hg qinit
   > }
 
 fn to create dirty subrepo
   $ mksubrepo() {
   >     hg init $1
   >     cd $1
   >     echo a > a
   >     hg add
   >     cd ..
   > }
 
   $ testadd() {
   >     cat - > "$stdin"
   >     mksubrepo sub
   >     echo sub = sub >> .hgsub
   >     hg add .hgsub
   >     echo % abort when adding .hgsub w/dirty subrepo
   >     hg status -S
   >     echo '%' $*
   >     cat "$stdin" | hg $*
   >     echo [$?]
   >     hg -R sub ci -m0sub
   >     echo % update substate when adding .hgsub w/clean updated subrepo
   >     hg status -S
   >     echo '%' $*
   >     cat "$stdin" | hg $*
   >     hg debugsub
   > }
 
   $ testmod() {
   >     cat - > "$stdin"
   >     mksubrepo sub2
   >     echo sub2 = sub2 >> .hgsub
   >     echo % abort when modifying .hgsub w/dirty subrepo
   >     hg status -S
   >     echo '%' $*
   >     cat "$stdin" | hg $*
   >     echo [$?]
   >     hg -R sub2 ci -m0sub2
   >     echo % update substate when modifying .hgsub w/clean updated subrepo
   >     hg status -S
   >     echo '%' $*
   >     cat "$stdin" | hg $*
   >     hg debugsub
   > }
 
   $ testrm1() {
   >     cat - > "$stdin"
   >     mksubrepo sub3
   >     echo sub3 = sub3 >> .hgsub
   >     hg ci -Aqmsub3
   >     $EXTRA
   >     echo b >> sub3/a
   >     hg rm .hgsub
   >     echo % update substate when removing .hgsub w/dirty subrepo
   >     hg status -S
   >     echo '%' $*
   >     cat "$stdin" | hg $*
   >     echo % debugsub should be empty
   >     hg debugsub
   > }
 
   $ testrm2() {
   >     cat - > "$stdin"
   >     mksubrepo sub4
   >     echo sub4 = sub4 >> .hgsub
   >     hg ci -Aqmsub4
   >     $EXTRA
   >     hg rm .hgsub
   >     echo % update substate when removing .hgsub w/clean updated subrepo
   >     hg status -S
   >     echo '%' $*
   >     cat "$stdin" | hg $*
   >     echo % debugsub should be empty
   >     hg debugsub
   > }
 
 
 handle subrepos safely on qnew
 
   $ mkrepo repo-2499-qnew
   $ testadd qnew -m0 0.diff
   adding a
   % abort when adding .hgsub w/dirty subrepo
   A .hgsub
   A sub/a
   % qnew -m0 0.diff
   abort: uncommitted changes in subrepository sub
   [255]
   % update substate when adding .hgsub w/clean updated subrepo
   A .hgsub
   % qnew -m0 0.diff
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
 
   $ testmod qnew -m1 1.diff
   adding a
   % abort when modifying .hgsub w/dirty subrepo
   M .hgsub
   A sub2/a
   % qnew -m1 1.diff
   abort: uncommitted changes in subrepository sub2
   [255]
   % update substate when modifying .hgsub w/clean updated subrepo
   M .hgsub
   % qnew -m1 1.diff
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
   path sub2
    source   sub2
    revision 1f94c7611cc6b74f5a17b16121a1170d44776845
 
   $ hg qpop -qa
   patch queue now empty
   $ testrm1 qnew -m2 2.diff
   adding a
   % update substate when removing .hgsub w/dirty subrepo
   M sub3/a
   R .hgsub
   % qnew -m2 2.diff
   % debugsub should be empty
 
   $ hg qpop -qa
   patch queue now empty
   $ testrm2 qnew -m3 3.diff
   adding a
   % update substate when removing .hgsub w/clean updated subrepo
   R .hgsub
   % qnew -m3 3.diff
   % debugsub should be empty
 
   $ cd ..
 
 
 handle subrepos safely on qrefresh
 
   $ mkrepo repo-2499-qrefresh
   $ hg qnew -m0 0.diff
   $ testadd qrefresh
   adding a
   % abort when adding .hgsub w/dirty subrepo
   A .hgsub
   A sub/a
   % qrefresh
   abort: uncommitted changes in subrepository sub
   [255]
   % update substate when adding .hgsub w/clean updated subrepo
   A .hgsub
   % qrefresh
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
 
   $ hg qnew -m1 1.diff
   $ testmod qrefresh
   adding a
   % abort when modifying .hgsub w/dirty subrepo
   M .hgsub
   A sub2/a
   % qrefresh
   abort: uncommitted changes in subrepository sub2
   [255]
   % update substate when modifying .hgsub w/clean updated subrepo
   M .hgsub
   % qrefresh
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
   path sub2
    source   sub2
    revision 1f94c7611cc6b74f5a17b16121a1170d44776845
 
   $ hg qpop -qa
   patch queue now empty
   $ EXTRA='hg qnew -m2 2.diff'
   $ testrm1 qrefresh
   adding a
   % update substate when removing .hgsub w/dirty subrepo
   M sub3/a
   R .hgsub
   % qrefresh
   % debugsub should be empty
 
   $ hg qpop -qa
   patch queue now empty
   $ EXTRA='hg qnew -m3 3.diff'
   $ testrm2 qrefresh
   adding a
   % update substate when removing .hgsub w/clean updated subrepo
   R .hgsub
   % qrefresh
   % debugsub should be empty
   $ EXTRA=
 
   $ cd ..
 
 
 handle subrepos safely on qpush/qpop
 (and we cannot qpop / qpush with a modified subrepo)
 
   $ mkrepo repo-2499-qpush
   $ mksubrepo sub
   adding a
   $ hg -R sub ci -m0sub
   $ echo sub = sub > .hgsub
   $ hg add .hgsub
   $ hg commit -m0
   $ hg debugsub
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
   $ echo foo > ./sub/a
   $ hg -R sub commit -m foo
   $ hg commit -m1
   $ hg qimport -r "0:tip"
   $ hg -R sub id --id
   aa037b301eba
 
 qpop
   $ hg -R sub update 0000
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg qpop
   abort: local changed subrepos found, refresh first
   [255]
   $ hg revert sub
   reverting subrepo sub
   adding sub/a
   $ hg qpop
   popping 1.diff
   now at: 0.diff
   $ hg status -AS
   C .hgsub
   C .hgsubstate
   C sub/a
   $ hg -R sub id --id
   b2fdb12cd82b
 
 qpush
   $ hg -R sub update 0000
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg qpush
   abort: local changed subrepos found, refresh first
   [255]
   $ hg revert sub
   reverting subrepo sub
   adding sub/a
   $ hg qpush
   applying 1.diff
+   subrepository sub diverged (local revision: b2fdb12cd82b, remote revision: aa037b301eba)
+  (M)erge, keep (l)ocal or keep (r)emote? m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   now at: 1.diff
   $ hg status -AS
   C .hgsub
   C .hgsubstate
   C sub/a
   $ hg -R sub id --id
   aa037b301eba
 
   $ cd ..
 
 
 handle subrepos safely on qrecord
 
   $ mkrepo repo-2499-qrecord
   $ testadd qrecord --config ui.interactive=1 -m0 0.diff <<EOF
   > y
   > y
   > EOF
   adding a
   % abort when adding .hgsub w/dirty subrepo
   A .hgsub
   A sub/a
   % qrecord --config ui.interactive=1 -m0 0.diff
   diff --git a/.hgsub b/.hgsub
   new file mode 100644
   examine changes to '.hgsub'? [Ynesfdaq?] 
   abort: uncommitted changes in subrepository sub
   [255]
   % update substate when adding .hgsub w/clean updated subrepo
   A .hgsub
   % qrecord --config ui.interactive=1 -m0 0.diff
   diff --git a/.hgsub b/.hgsub
   new file mode 100644
   examine changes to '.hgsub'? [Ynesfdaq?] 
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
 
   $ testmod qrecord --config ui.interactive=1 -m1 1.diff <<EOF
   > y
   > y
   > EOF
   adding a
   % abort when modifying .hgsub w/dirty subrepo
   M .hgsub
   A sub2/a
   % qrecord --config ui.interactive=1 -m1 1.diff
   diff --git a/.hgsub b/.hgsub
   1 hunks, 1 lines changed
   examine changes to '.hgsub'? [Ynesfdaq?] 
   @@ -1,1 +1,2 @@
    sub = sub
   +sub2 = sub2
   record this change to '.hgsub'? [Ynesfdaq?] 
   abort: uncommitted changes in subrepository sub2
   [255]
   % update substate when modifying .hgsub w/clean updated subrepo
   M .hgsub
   % qrecord --config ui.interactive=1 -m1 1.diff
   diff --git a/.hgsub b/.hgsub
   1 hunks, 1 lines changed
   examine changes to '.hgsub'? [Ynesfdaq?] 
   @@ -1,1 +1,2 @@
    sub = sub
   +sub2 = sub2
   record this change to '.hgsub'? [Ynesfdaq?] 
   path sub
    source   sub
    revision b2fdb12cd82b021c3b7053d67802e77b6eeaee31
   path sub2
    source   sub2
    revision 1f94c7611cc6b74f5a17b16121a1170d44776845
 
   $ hg qpop -qa
   patch queue now empty
   $ testrm1 qrecord --config ui.interactive=1 -m2 2.diff <<EOF
   > y
   > y
   > EOF
   adding a
   % update substate when removing .hgsub w/dirty subrepo
   M sub3/a
   R .hgsub
   % qrecord --config ui.interactive=1 -m2 2.diff
   diff --git a/.hgsub b/.hgsub
   deleted file mode 100644
   examine changes to '.hgsub'? [Ynesfdaq?] 
   % debugsub should be empty
 
   $ hg qpop -qa
   patch queue now empty
   $ testrm2 qrecord --config ui.interactive=1 -m3 3.diff <<EOF
   > y
   > y
   > EOF
   adding a
   % update substate when removing .hgsub w/clean updated subrepo
   R .hgsub
   % qrecord --config ui.interactive=1 -m3 3.diff
   diff --git a/.hgsub b/.hgsub
   deleted file mode 100644
   examine changes to '.hgsub'? [Ynesfdaq?] 
   % debugsub should be empty
 
   $ cd ..
 
 
 correctly handle subrepos with patch queues
   $ mkrepo repo-subrepo-with-queue
   $ mksubrepo sub
   adding a
   $ hg -R sub qnew sub0.diff
   $ echo sub = sub >> .hgsub
   $ hg add .hgsub
   $ hg qnew 0.diff
 
   $ cd ..
 
 check whether MQ operations can import updated .hgsubstate correctly
 both into 'revision' and 'patch file under .hg/patches':
 
   $ hg init importing-hgsubstate
   $ cd importing-hgsubstate
 
   $ echo a > a
   $ hg commit -u test -d '0 0' -Am '#0 in parent'
   adding a
   $ hg init sub
   $ echo sa > sub/sa
   $ hg -R sub commit -u test -d '0 0' -Am '#0 in sub'
   adding sa
   $ echo 'sub = sub' > .hgsub
   $ touch .hgsubstate
   $ hg add .hgsub .hgsubstate
 
   $ hg qnew -u test -d '0 0' import-at-qnew
   $ hg -R sub parents --template '{node} sub\n'
   b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   $ cat .hgsubstate
   b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   $ hg diff -c tip
   diff -r f499373e340c -r b20ffac88564 .hgsub
   --- /dev/null
   +++ b/.hgsub
   @@ -0,0 +1,1 @@
   +sub = sub
   diff -r f499373e340c -r b20ffac88564 .hgsubstate
   --- /dev/null
   +++ b/.hgsubstate
   @@ -0,0 +1,1 @@
   +b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   $ cat .hg/patches/import-at-qnew
   # HG changeset patch
   # Parent f499373e340cdca5d01dee904aeb42dd2a325e71
   # User test
   # Date 0 0
   
   diff -r f499373e340c -r b20ffac88564 .hgsub
   --- /dev/null
   +++ b/.hgsub
   @@ -0,0 +1,1 @@
   +sub = sub
   diff -r f499373e340c -r b20ffac88564 .hgsubstate
   --- /dev/null
   +++ b/.hgsubstate
   @@ -0,0 +1,1 @@
   +b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   $ hg qpop
   popping import-at-qnew
   patch queue now empty
   $ hg qpush
   applying import-at-qnew
   now at: import-at-qnew
 
   $ hg qnew import-at-qrefresh
   $ echo sb > sub/sb
   $ hg -R sub commit -u test -d '0 0' -Am '#1 in sub'
   adding sb
   $ hg qrefresh -u test -d '0 0'
   $ hg -R sub parents --template '{node} sub\n'
   88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ cat .hgsubstate
   88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ hg diff -c tip
   diff -r 44f846335325 -r b3e8c5fa3aaa .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   +88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ cat .hg/patches/import-at-qrefresh
   # HG changeset patch
   # Date 0 0
   # User test
   # Parent 44f846335325209be6be35dc2c9a4be107278c09
   
   diff -r 44f846335325 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   +88ac1bef5ed43b689d1d200b59886b675dec474b sub
 
   $ hg qrefresh -u test -d '0 0'
   $ cat .hgsubstate
   88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ hg diff -c tip
   diff -r 44f846335325 -r b3e8c5fa3aaa .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   +88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ cat .hg/patches/import-at-qrefresh
   # HG changeset patch
   # Date 0 0
   # User test
   # Parent 44f846335325209be6be35dc2c9a4be107278c09
   
   diff -r 44f846335325 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   +88ac1bef5ed43b689d1d200b59886b675dec474b sub
 
   $ hg update -C tip
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg qpop -a
   popping import-at-qrefresh
   popping import-at-qnew
   patch queue now empty
 
   $ hg -R sub update -C 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'sub = sub' > .hgsub
   $ hg commit -Am '#1 in parent'
   adding .hgsub
   $ hg -R sub update -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg commit -Am '#2 in parent (but will be rolled back soon)'
   $ hg rollback
   repository tip rolled back to revision 1 (undo commit)
   working directory now based on revision 1
   $ hg status
   M .hgsubstate
   $ hg qnew -u test -d '0 0' checkstate-at-qnew
   $ hg -R sub parents --template '{node} sub\n'
   88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ cat .hgsubstate
   88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ hg diff -c tip
   diff -r 4d91eb2fa1d1 -r 1259c112d884 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   +88ac1bef5ed43b689d1d200b59886b675dec474b sub
   $ cat .hg/patches/checkstate-at-qnew
   # HG changeset patch
   # Parent 4d91eb2fa1d1b22ec513347b9cd06f6b49d470fa
   # User test
   # Date 0 0
   
   diff -r 4d91eb2fa1d1 -r 1259c112d884 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -b6f6e9c41f3dfd374a6d2ed4535c87951cf979cf sub
   +88ac1bef5ed43b689d1d200b59886b675dec474b sub
 
   $ cd ..
 
   $ cd ..

tests/test-subrepo-git.t

@@ -1,560 +1,568
   $ "$TESTDIR/hghave" git || exit 80
 
 make git commits repeatable
 
   $ echo "[core]" >> $HOME/.gitconfig
   $ echo "autocrlf = false" >> $HOME/.gitconfig
   $ GIT_AUTHOR_NAME='test'; export GIT_AUTHOR_NAME
   $ GIT_AUTHOR_EMAIL='[e-mail]'; export GIT_AUTHOR_EMAIL
   $ GIT_AUTHOR_DATE='1234567891 +0000'; export GIT_AUTHOR_DATE
   $ GIT_COMMITTER_NAME="$GIT_AUTHOR_NAME"; export GIT_COMMITTER_NAME
   $ GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"; export GIT_COMMITTER_EMAIL
   $ GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"; export GIT_COMMITTER_DATE
 
 root hg repo
 
   $ hg init t
   $ cd t
   $ echo a > a
   $ hg add a
   $ hg commit -m a
   $ cd ..
 
 new external git repo
 
   $ mkdir gitroot
   $ cd gitroot
   $ git init -q
   $ echo g > g
   $ git add g
   $ git commit -q -m g
 
 add subrepo clone
 
   $ cd ../t
   $ echo 's = [git]../gitroot' > .hgsub
   $ git clone -q ../gitroot s
   $ hg add .hgsub
   $ hg commit -m 'new git subrepo'
   $ hg debugsub
   path s
    source   ../gitroot
    revision da5f5b1d8ffcf62fb8327bcd3c89a4367a6018e7
 
 record a new commit from upstream from a different branch
 
   $ cd ../gitroot
   $ git checkout -q -b testing
   $ echo gg >> g
   $ git commit -q -a -m gg
 
   $ cd ../t/s
   $ git pull -q >/dev/null 2>/dev/null
   $ git checkout -q -b testing origin/testing >/dev/null
 
   $ cd ..
   $ hg status --subrepos
   M s/g
   $ hg commit -m 'update git subrepo'
   $ hg debugsub
   path s
    source   ../gitroot
    revision 126f2a14290cd5ce061fdedc430170e8d39e1c5a
 
 make $GITROOT pushable, by replacing it with a clone with nothing checked out
 
   $ cd ..
   $ git clone gitroot gitrootbare --bare -q
   $ rm -rf gitroot
   $ mv gitrootbare gitroot
 
 clone root
 
   $ cd t
   $ hg clone . ../tc
   updating to branch default
   cloning subrepo s from $TESTTMP/gitroot
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../tc
   $ hg debugsub
   path s
    source   ../gitroot
    revision 126f2a14290cd5ce061fdedc430170e8d39e1c5a
 
 update to previous substate
 
   $ hg update 1 -q
   $ cat s/g
   g
   $ hg debugsub
   path s
    source   ../gitroot
    revision da5f5b1d8ffcf62fb8327bcd3c89a4367a6018e7
 
 clone root, make local change
 
   $ cd ../t
   $ hg clone . ../ta
   updating to branch default
   cloning subrepo s from $TESTTMP/gitroot
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ../ta
   $ echo ggg >> s/g
   $ hg status --subrepos
   M s/g
   $ hg commit --subrepos -m ggg
   committing subrepository s
   $ hg debugsub
   path s
    source   ../gitroot
    revision 79695940086840c99328513acbe35f90fcd55e57
 
 clone root separately, make different local change
 
   $ cd ../t
   $ hg clone . ../tb
   updating to branch default
   cloning subrepo s from $TESTTMP/gitroot
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ../tb/s
   $ echo f > f
   $ git add f
   $ cd ..
 
   $ hg status --subrepos
   A s/f
   $ hg commit --subrepos -m f
   committing subrepository s
   $ hg debugsub
   path s
    source   ../gitroot
    revision aa84837ccfbdfedcdcdeeedc309d73e6eb069edc
 
 user b push changes
 
   $ hg push 2>/dev/null
   pushing to $TESTTMP/t (glob)
   pushing branch testing of subrepo s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 user a pulls, merges, commits
 
   $ cd ../ta
   $ 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 (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg merge 2>/dev/null
+   subrepository s diverged (local revision: 796959400868, remote revision: aa84837ccfbd)
+  (M)erge, keep (l)ocal or keep (r)emote? m
   pulling subrepo s from $TESTTMP/gitroot
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat s/f
   f
   $ cat s/g
   g
   gg
   ggg
   $ hg commit --subrepos -m 'merge'
   committing subrepository s
   $ hg status --subrepos --rev 1:5
   M .hgsubstate
   M s/g
   A s/f
   $ hg debugsub
   path s
    source   ../gitroot
    revision f47b465e1bce645dbf37232a00574aa1546ca8d3
   $ hg push 2>/dev/null
   pushing to $TESTTMP/t (glob)
   pushing branch testing of subrepo s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
 make upstream git changes
 
   $ cd ..
   $ git clone -q gitroot gitclone
   $ cd gitclone
   $ echo ff >> f
   $ git commit -q -a -m ff
   $ echo fff >> f
   $ git commit -q -a -m fff
   $ git push origin testing 2>/dev/null
 
 make and push changes to hg without updating the subrepo
 
   $ cd ../t
   $ hg clone . ../td
   updating to branch default
   cloning subrepo s from $TESTTMP/gitroot
   checking out detached HEAD in subrepo s
   check out a git branch if you intend to make changes
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../td
   $ echo aa >> a
   $ hg commit -m aa
   $ hg push
   pushing to $TESTTMP/t (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 sync to upstream git, distribute changes
 
   $ cd ../ta
   $ hg pull -u -q
   $ cd s
   $ git pull -q >/dev/null 2>/dev/null
   $ cd ..
   $ hg commit -m 'git upstream sync'
   $ hg debugsub
   path s
    source   ../gitroot
    revision 32a343883b74769118bb1d3b4b1fbf9156f4dddc
   $ hg push -q
 
   $ cd ../tb
   $ hg pull -q
   $ hg update 2>/dev/null
   pulling subrepo s from $TESTTMP/gitroot
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsub
   path s
    source   ../gitroot
    revision 32a343883b74769118bb1d3b4b1fbf9156f4dddc
 
 create a new git branch
 
   $ cd s
   $ git checkout -b b2
   Switched to a new branch 'b2'
   $ echo a>a
   $ git add a
   $ git commit -qm 'add a'
   $ cd ..
   $ hg commit -m 'add branch in s'
 
 pulling new git branch should not create tracking branch named 'origin/b2'
 (issue3870)
   $ cd ../td/s
   $ git remote set-url origin $TESTTMP/tb/s
   $ git branch --no-track oldtesting
   $ cd ..
   $ hg pull -q ../tb
   $ hg up
   From $TESTTMP/tb/s
    * [new branch]      b2         -> origin/b2
   Previous HEAD position was f47b465... merge
   Switched to a new branch 'b2'
   pulling subrepo s from $TESTTMP/tb/s
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 update to a revision without the subrepo, keeping the local git repository
 
   $ cd ../t
   $ hg up 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ ls -a s
   .
   ..
   .git
 
   $ hg up 2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ ls -a s
   .
   ..
   .git
   g
 
 archive subrepos
 
   $ cd ../tc
   $ hg pull -q
   $ hg archive --subrepos -r 5 ../archive 2>/dev/null
   pulling subrepo s from $TESTTMP/gitroot
   $ cd ../archive
   $ cat s/f
   f
   $ cat s/g
   g
   gg
   ggg
 
   $ hg -R ../tc archive --subrepo -r 5 -X ../tc/**f ../archive_x 2>/dev/null
   $ find ../archive_x | sort | grep -v pax_global_header
   ../archive_x
   ../archive_x/.hg_archival.txt
   ../archive_x/.hgsub
   ../archive_x/.hgsubstate
   ../archive_x/a
   ../archive_x/s
   ../archive_x/s/g
 
 create nested repo
 
   $ cd ..
   $ hg init outer
   $ cd outer
   $ echo b>b
   $ hg add b
   $ hg commit -m b
 
   $ hg clone ../t inner
   updating to branch default
   cloning subrepo s from $TESTTMP/gitroot
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo inner = inner > .hgsub
   $ hg add .hgsub
   $ hg commit -m 'nested sub'
 
 nested commit
 
   $ echo ffff >> inner/s/f
   $ hg status --subrepos
   M inner/s/f
   $ hg commit --subrepos -m nested
   committing subrepository inner
   committing subrepository inner/s (glob)
 
 nested archive
 
   $ hg archive --subrepos ../narchive
   $ ls ../narchive/inner/s | grep -v pax_global_header
   f
   g
 
 relative source expansion
 
   $ cd ..
   $ mkdir d
   $ hg clone t d/t
   updating to branch default
   cloning subrepo s from $TESTTMP/gitroot
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Don't crash if the subrepo is missing
 
   $ hg clone t missing -q
   $ cd missing
   $ rm -rf s
   $ hg status -S
   $ hg sum | grep commit
   commit: 1 subrepos
   $ hg push -q
   abort: subrepo s is missing (in subrepo s)
   [255]
   $ hg commit --subrepos -qm missing
   abort: subrepo s is missing (in subrepo s)
   [255]
   $ hg update -C
   cloning subrepo s from $TESTTMP/gitroot
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum | grep commit
   commit: (clean)
 
 Don't crash if the .hgsubstate entry is missing
 
   $ hg update 1 -q
   $ hg rm .hgsubstate
   $ hg commit .hgsubstate -m 'no substate'
   nothing changed
   [1]
   $ hg tag -l nosubstate
   $ hg manifest
   .hgsub
   .hgsubstate
   a
 
   $ hg status -S
   R .hgsubstate
   $ hg sum | grep commit
   commit: 1 removed, 1 subrepos (new branch head)
 
   $ hg commit -m 'restore substate'
   nothing changed
   [1]
   $ hg manifest
   .hgsub
   .hgsubstate
   a
   $ hg sum | grep commit
   commit: 1 removed, 1 subrepos (new branch head)
 
   $ hg update -qC nosubstate
   $ ls s
   g
 
 issue3109: false positives in git diff-index
 
   $ hg update -q
   $ touch -t 200001010000 s/g
   $ hg status --subrepos
   $ touch -t 200001010000 s/g
   $ hg sum | grep commit
   commit: (clean)
 
 Check hg update --clean
   $ cd $TESTTMP/ta
   $ echo  > s/g
   $ cd s
   $ echo c1 > f1
   $ echo c1 > f2
   $ git add f1
   $ cd ..
   $ hg status -S
   M s/g
   A s/f1
   $ ls s
   f
   f1
   f2
   g
   $ hg update --clean
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
   $ ls s
   f
   f1
   f2
   g
 
 Sticky subrepositories, no changes
   $ cd $TESTTMP/ta
   $ hg id -n
   7
   $ cd s
   $ git rev-parse HEAD
   32a343883b74769118bb1d3b4b1fbf9156f4dddc
   $ cd ..
   $ hg update 1 > /dev/null 2>&1
   $ hg id -n
   1
   $ cd s
   $ git rev-parse HEAD
   da5f5b1d8ffcf62fb8327bcd3c89a4367a6018e7
   $ cd ..
 
 Sticky subrepositorys, file changes
   $ touch s/f1
   $ cd s
   $ git add f1
   $ cd ..
   $ hg id -n
   1+
   $ cd s
   $ git rev-parse HEAD
   da5f5b1d8ffcf62fb8327bcd3c89a4367a6018e7
   $ cd ..
   $ hg update 4
+   subrepository s diverged (local revision: da5f5b1d8ffc, remote revision: aa84837ccfbd)
+  (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (da5f5b1) or (r)emote source (aa84837)?
    l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   4+
   $ cd s
   $ git rev-parse HEAD
   da5f5b1d8ffcf62fb8327bcd3c89a4367a6018e7
   $ cd ..
   $ hg update --clean tip > /dev/null 2>&1
 
 Sticky subrepository, revision updates
   $ hg id -n
   7
   $ cd s
   $ git rev-parse HEAD
   32a343883b74769118bb1d3b4b1fbf9156f4dddc
   $ cd ..
   $ cd s
   $ git checkout aa84837ccfbdfedcdcdeeedc309d73e6eb069edc
   Previous HEAD position was 32a3438... fff
   HEAD is now at aa84837... f
   $ cd ..
   $ hg update 1
+   subrepository s diverged (local revision: 32a343883b74, remote revision: da5f5b1d8ffc)
+  (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ (in checked out version)
   use (l)ocal source (32a3438) or (r)emote source (da5f5b1)?
    l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   1+
   $ cd s
   $ git rev-parse HEAD
   aa84837ccfbdfedcdcdeeedc309d73e6eb069edc
   $ cd ..
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ cd s
   $ git add f1
   $ git rev-parse HEAD
   aa84837ccfbdfedcdcdeeedc309d73e6eb069edc
   $ cd ..
   $ hg id -n
   1+
   $ hg update 7
+   subrepository s diverged (local revision: 32a343883b74, remote revision: 32a343883b74)
+  (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (32a3438) or (r)emote source (32a3438)?
    l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   7+
   $ cd s
   $ git rev-parse HEAD
   aa84837ccfbdfedcdcdeeedc309d73e6eb069edc
   $ cd ..
 
 Sticky repository, update --clean
   $ hg update --clean tip 2>/dev/null
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   7
   $ cd s
   $ git rev-parse HEAD
   32a343883b74769118bb1d3b4b1fbf9156f4dddc
   $ cd ..
 
 Test subrepo already at intended revision:
   $ cd s
   $ git checkout 32a343883b74769118bb1d3b4b1fbf9156f4dddc
   HEAD is now at 32a3438... fff
   $ cd ..
   $ hg update 1
   Previous HEAD position was 32a3438... fff
   HEAD is now at da5f5b1... g
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   1
   $ cd s
   $ git rev-parse HEAD
   da5f5b1d8ffcf62fb8327bcd3c89a4367a6018e7
   $ cd ..
 
 Test forgetting files, not implemented in git subrepo, used to
 traceback
 #if no-windows
   $ hg forget 'notafile*'
   notafile*: No such file or directory
   [1]
 #else
   $ hg forget 'notafile'
   notafile: * (glob)
   [1]
 #endif
 
   $ cd ..

tests/test-subrepo-svn.t

@@ -1,626 +1,634
   $ "$TESTDIR/hghave" svn15 || exit 80
 
   $ SVNREPOPATH=`pwd`/svn-repo
 #if windows
   $ SVNREPOURL=file:///`python -c "import urllib, sys; sys.stdout.write(urllib.quote(sys.argv[1]))" "$SVNREPOPATH"`
 #else
   $ SVNREPOURL=file://`python -c "import urllib, sys; sys.stdout.write(urllib.quote(sys.argv[1]))" "$SVNREPOPATH"`
 #endif
 
 create subversion repo
 
   $ WCROOT="`pwd`/svn-wc"
   $ svnadmin create svn-repo
   $ svn co "$SVNREPOURL" svn-wc
   Checked out revision 0.
   $ cd svn-wc
   $ mkdir src
   $ echo alpha > src/alpha
   $ svn add src
   A         src
   A         src/alpha (glob)
   $ mkdir externals
   $ echo other > externals/other
   $ svn add externals
   A         externals
   A         externals/other (glob)
   $ svn ci -m 'Add alpha'
   Adding         externals
   Adding         externals/other (glob)
   Adding         src
   Adding         src/alpha (glob)
   Transmitting file data ..
   Committed revision 1.
   $ svn up -q
   $ echo "externals -r1 $SVNREPOURL/externals" > extdef
   $ svn propset -F extdef svn:externals src
   property 'svn:externals' set on 'src'
   $ svn ci -m 'Setting externals'
   Sending        src
   
   Committed revision 2.
   $ cd ..
 
 create hg repo
 
   $ mkdir sub
   $ cd sub
   $ hg init t
   $ cd t
 
 first revision, no sub
 
   $ echo a > a
   $ hg ci -Am0
   adding a
 
 add first svn sub with leading whitespaces
 
   $ echo "s =        [svn]       $SVNREPOURL/src" >> .hgsub
   $ echo "subdir/s = [svn]       $SVNREPOURL/src" >> .hgsub
   $ svn co --quiet "$SVNREPOURL"/src s
   $ mkdir subdir
   $ svn co --quiet "$SVNREPOURL"/src subdir/s
   $ hg add .hgsub
   $ hg ci -m1
 
 make sure we avoid empty commits (issue2445)
 
   $ hg sum
   parent: 1:* tip (glob)
    1
   branch: default
   commit: (clean)
   update: (current)
   $ hg ci -moops
   nothing changed
   [1]
 
 debugsub
 
   $ hg debugsub
   path s
    source   file://*/svn-repo/src (glob)
    revision 2
   path subdir/s
    source   file://*/svn-repo/src (glob)
    revision 2
 
 change file in svn and hg, commit
 
   $ echo a >> a
   $ echo alpha >> s/alpha
   $ hg sum
   parent: 1:* tip (glob)
    1
   branch: default
   commit: 1 modified, 1 subrepos
   update: (current)
   $ hg commit --subrepos -m 'Message!' | grep -v Updating
   committing subrepository s
   Sending*s/alpha (glob)
   Transmitting file data .
   Committed revision 3.
   
   Fetching external item into '*s/externals'* (glob)
   External at revision 1.
   
   At revision 3.
   $ hg debugsub
   path s
    source   file://*/svn-repo/src (glob)
    revision 3
   path subdir/s
    source   file://*/svn-repo/src (glob)
    revision 2
 
 missing svn file, commit should fail
 
   $ rm s/alpha
   $ hg commit --subrepos -m 'abort on missing file'
   committing subrepository s
   abort: cannot commit missing svn entries (in subrepo s)
   [255]
   $ svn revert s/alpha > /dev/null
 
 add an unrelated revision in svn and update the subrepo to without
 bringing any changes.
 
   $ svn mkdir "$SVNREPOURL/unrelated" -m 'create unrelated'
   
   Committed revision 4.
   $ svn up -q s
   $ hg sum
   parent: 2:* tip (glob)
    Message!
   branch: default
   commit: (clean)
   update: (current)
 
   $ echo a > s/a
 
 should be empty despite change to s/a
 
   $ hg st
 
 add a commit from svn
 
   $ cd "$WCROOT/src"
   $ svn up -q
   $ echo xyz >> alpha
   $ svn propset svn:mime-type 'text/xml' alpha
   property 'svn:mime-type' set on 'alpha'
   $ svn ci -m 'amend a from svn'
   Sending        *alpha (glob)
   Transmitting file data .
   Committed revision 5.
   $ cd ../../sub/t
 
 this commit from hg will fail
 
   $ echo zzz >> s/alpha
   $ (hg ci --subrepos -m 'amend alpha from hg' 2>&1; echo "[$?]") | grep -vi 'out of date'
   committing subrepository s
   abort: svn:*Commit failed (details follow): (glob)
   [255]
   $ svn revert -q s/alpha
 
 this commit fails because of meta changes
 
   $ svn propset svn:mime-type 'text/html' s/alpha
   property 'svn:mime-type' set on 's/alpha' (glob)
   $ (hg ci --subrepos -m 'amend alpha from hg' 2>&1; echo "[$?]") | grep -vi 'out of date'
   committing subrepository s
   abort: svn:*Commit failed (details follow): (glob)
   [255]
   $ svn revert -q s/alpha
 
 this commit fails because of externals changes
 
   $ echo zzz > s/externals/other
   $ hg ci --subrepos -m 'amend externals from hg'
   committing subrepository s
   abort: cannot commit svn externals (in subrepo s)
   [255]
   $ hg diff --subrepos -r 1:2 | grep -v diff
   --- a/.hgsubstate	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hgsubstate	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,2 +1,2 @@
   -2 s
   +3 s
    2 subdir/s
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    a
   +a
   $ svn revert -q s/externals/other
 
 this commit fails because of externals meta changes
 
   $ svn propset svn:mime-type 'text/html' s/externals/other
   property 'svn:mime-type' set on 's/externals/other' (glob)
   $ hg ci --subrepos -m 'amend externals from hg'
   committing subrepository s
   abort: cannot commit svn externals (in subrepo s)
   [255]
   $ svn revert -q s/externals/other
 
 clone
 
   $ cd ..
   $ hg clone t tc
   updating to branch default
   A    tc/s/alpha (glob)
    U   tc/s (glob)
   
   Fetching external item into 'tc/s/externals'* (glob)
   A    tc/s/externals/other (glob)
   Checked out external at revision 1.
   
   Checked out revision 3.
   A    tc/subdir/s/alpha (glob)
    U   tc/subdir/s (glob)
   
   Fetching external item into 'tc/subdir/s/externals'* (glob)
   A    tc/subdir/s/externals/other (glob)
   Checked out external at revision 1.
   
   Checked out revision 2.
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd tc
 
 debugsub in clone
 
   $ hg debugsub
   path s
    source   file://*/svn-repo/src (glob)
    revision 3
   path subdir/s
    source   file://*/svn-repo/src (glob)
    revision 2
 
 verify subrepo is contained within the repo directory
 
   $ python -c "import os.path; print os.path.exists('s')"
   True
 
 update to nullrev (must delete the subrepo)
 
   $ hg up null
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ ls
 
 Check hg update --clean
   $ cd "$TESTTMP/sub/t"
   $ cd s
   $ echo c0 > alpha
   $ echo c1 > f1
   $ echo c1 > f2
   $ svn add f1 -q
   $ svn status | sort
   
   ? *    a (glob)
   ? *    f2 (glob)
   A *    f1 (glob)
   M *    alpha (glob)
   Performing status on external item at 'externals'* (glob)
   X *    externals (glob)
   $ cd ../..
   $ hg -R t update -C
   
   Fetching external item into 't/s/externals'* (glob)
   Checked out external at revision 1.
   
   Checked out revision 3.
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd t/s
   $ svn status | sort
   
   ? *    a (glob)
   ? *    f1 (glob)
   ? *    f2 (glob)
   Performing status on external item at 'externals'* (glob)
   X *    externals (glob)
 
 Sticky subrepositories, no changes
   $ cd "$TESTTMP/sub/t"
   $ hg id -n
   2
   $ cd s
   $ svnversion
   3
   $ cd ..
   $ hg update 1
   U    *s/alpha (glob)
   
   Fetching external item into '*s/externals'* (glob)
   Checked out external at revision 1.
   
   Checked out revision 2.
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   1
   $ cd s
   $ svnversion
   2
   $ cd ..
 
 Sticky subrepositorys, file changes
   $ touch s/f1
   $ cd s
   $ svn add f1
   A         f1
   $ cd ..
   $ hg id -n
   1+
   $ cd s
   $ svnversion
   2M
   $ cd ..
   $ hg update tip
+   subrepository s diverged (local revision: 2, remote revision: 3)
+  (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (2) or (r)emote source (3)?
    l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   2+
   $ cd s
   $ svnversion
   2M
   $ cd ..
   $ hg update --clean tip
   U    *s/alpha (glob)
   
   Fetching external item into '*s/externals'* (glob)
   Checked out external at revision 1.
   
   Checked out revision 3.
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Sticky subrepository, revision updates
   $ hg id -n
   2
   $ cd s
   $ svnversion
   3
   $ cd ..
   $ cd s
   $ svn update -qr 1
   $ cd ..
   $ hg update 1
+   subrepository s diverged (local revision: 3, remote revision: 2)
+  (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ (in checked out version)
   use (l)ocal source (1) or (r)emote source (2)?
    l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   1+
   $ cd s
   $ svnversion
   1
   $ cd ..
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ cd s
   $ svn add f1
   A         f1
   $ svnversion
   1M
   $ cd ..
   $ hg id -n
   1+
   $ hg update tip
+   subrepository s diverged (local revision: 3, remote revision: 3)
+  (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (1) or (r)emote source (3)?
    l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   2+
   $ cd s
   $ svnversion
   1M
   $ cd ..
 
 Sticky repository, update --clean
   $ hg update --clean tip | grep -v 's[/\]externals[/\]other'
   U    *s/alpha (glob)
    U   *s (glob)
   
   Fetching external item into '*s/externals'* (glob)
   Checked out external at revision 1.
   
   Checked out revision 3.
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   2
   $ cd s
   $ svnversion
   3
   $ cd ..
 
 Test subrepo already at intended revision:
   $ cd s
   $ svn update -qr 2
   $ cd ..
   $ hg update 1
+   subrepository s diverged (local revision: 3, remote revision: 2)
+  (M)erge, keep (l)ocal or keep (r)emote? m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   1+
   $ cd s
   $ svnversion
   2
   $ cd ..
 
 Test case where subversion would fail to update the subrepo because there
 are unknown directories being replaced by tracked ones (happens with rebase).
 
   $ cd "$WCROOT/src"
   $ mkdir dir
   $ echo epsilon.py > dir/epsilon.py
   $ svn add dir
   A         dir
   A         dir/epsilon.py (glob)
   $ svn ci -m 'Add dir/epsilon.py'
   Adding         *dir (glob)
   Adding         *dir/epsilon.py (glob)
   Transmitting file data .
   Committed revision 6.
   $ cd ../..
   $ hg init rebaserepo
   $ cd rebaserepo
   $ svn co -r5 --quiet "$SVNREPOURL"/src s
   $ echo "s =        [svn]       $SVNREPOURL/src" >> .hgsub
   $ hg add .hgsub
   $ hg ci -m addsub
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ svn up -qr6 s
   $ hg ci -m updatesub
   created new head
   $ echo pyc > s/dir/epsilon.pyc
   $ hg up 1
   D    *s/dir (glob)
   
   Fetching external item into '*s/externals'* (glob)
   Checked out external at revision 1.
   
   Checked out revision 5.
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg up -q 2
 
 Modify one of the externals to point to a different path so we can
 test having obstructions when switching branches on checkout:
   $ hg checkout tip
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "obstruct =        [svn]       $SVNREPOURL/externals" >> .hgsub
   $ svn co -r5 --quiet "$SVNREPOURL"/externals obstruct
   $ hg commit -m 'Start making obstructed working copy'
   $ hg book other
   $ hg co -r 'p1(tip)'
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "obstruct =        [svn]       $SVNREPOURL/src" >> .hgsub
   $ svn co -r5 --quiet "$SVNREPOURL"/src obstruct
   $ hg commit -m 'Other branch which will be obstructed'
   created new head
 
 Switching back to the head where we have another path mapped to the
 same subrepo should work if the subrepo is clean.
   $ hg co other
   A    *obstruct/other (glob)
   Checked out revision 1.
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 This is surprising, but is also correct based on the current code:
   $ echo "updating should (maybe) fail" > obstruct/other
   $ hg co tip
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   [255]
 
 Point to a Subversion branch which has since been deleted and recreated
 First, create that condition in the repository.
 
   $ hg ci --subrepos -m cleanup | grep -v Updating
   committing subrepository obstruct
   Sending        obstruct/other (glob)
   Transmitting file data .
   Committed revision 7.
   At revision 7.
   $ svn mkdir -m "baseline" $SVNREPOURL/trunk
   
   Committed revision 8.
   $ svn copy -m "initial branch" $SVNREPOURL/trunk $SVNREPOURL/branch
   
   Committed revision 9.
   $ svn co --quiet "$SVNREPOURL"/branch tempwc
   $ cd tempwc
   $ echo "something old" > somethingold
   $ svn add somethingold
   A         somethingold
   $ svn ci -m 'Something old'
   Adding         somethingold
   Transmitting file data .
   Committed revision 10.
   $ svn rm -m "remove branch" $SVNREPOURL/branch
   
   Committed revision 11.
   $ svn copy -m "recreate branch" $SVNREPOURL/trunk $SVNREPOURL/branch
   
   Committed revision 12.
   $ svn up -q
   $ echo "something new" > somethingnew
   $ svn add somethingnew
   A         somethingnew
   $ svn ci -m 'Something new'
   Adding         somethingnew
   Transmitting file data .
   Committed revision 13.
   $ cd ..
   $ rm -rf tempwc
   $ svn co "$SVNREPOURL/branch"@10 recreated
   A    recreated/somethingold (glob)
   Checked out revision 10.
   $ echo "recreated =        [svn]       $SVNREPOURL/branch" >> .hgsub
   $ hg ci -m addsub
   $ cd recreated
   $ svn up -q
   $ cd ..
   $ hg ci -m updatesub
   $ hg up -r-2
   D    *recreated/somethingnew (glob)
   A    *recreated/somethingold (glob)
   Checked out revision 10.
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ test -f recreated/somethingold
 
 Test archive
 
   $ hg archive -S ../archive-all --debug
   archiving: 0/2 files (0.00%)
   archiving: .hgsub 1/2 files (50.00%)
   archiving: .hgsubstate 2/2 files (100.00%)
   archiving (obstruct): 0/1 files (0.00%)
   archiving (obstruct): 1/1 files (100.00%)
   archiving (recreated): 0/1 files (0.00%)
   archiving (recreated): 1/1 files (100.00%)
   archiving (s): 0/2 files (0.00%)
   archiving (s): 1/2 files (50.00%)
   archiving (s): 2/2 files (100.00%)
 
   $ hg archive -S ../archive-exclude --debug -X **old
   archiving: 0/2 files (0.00%)
   archiving: .hgsub 1/2 files (50.00%)
   archiving: .hgsubstate 2/2 files (100.00%)
   archiving (obstruct): 0/1 files (0.00%)
   archiving (obstruct): 1/1 files (100.00%)
   archiving (recreated): 0 files
   archiving (s): 0/2 files (0.00%)
   archiving (s): 1/2 files (50.00%)
   archiving (s): 2/2 files (100.00%)
   $ find ../archive-exclude | sort
   ../archive-exclude
   ../archive-exclude/.hg_archival.txt
   ../archive-exclude/.hgsub
   ../archive-exclude/.hgsubstate
   ../archive-exclude/obstruct
   ../archive-exclude/obstruct/other
   ../archive-exclude/s
   ../archive-exclude/s/alpha
   ../archive-exclude/s/dir
   ../archive-exclude/s/dir/epsilon.py
 
 Test forgetting files, not implemented in svn subrepo, used to
 traceback
 
 #if no-windows
   $ hg forget 'notafile*'
   notafile*: No such file or directory
   [1]
 #else
   $ hg forget 'notafile'
   notafile: * (glob)
   [1]
 #endif
 
 Test a subrepo referencing a just moved svn path. Last commit rev will
 be different from the revision, and the path will be different as
 well.
 
   $ cd "$WCROOT"
   $ svn up > /dev/null
   $ mkdir trunk/subdir branches
   $ echo a > trunk/subdir/a
   $ svn add trunk/subdir branches
   A         trunk/subdir (glob)
   A         trunk/subdir/a (glob)
   A         branches
   $ svn ci -m addsubdir
   Adding         branches
   Adding         trunk/subdir (glob)
   Adding         trunk/subdir/a (glob)
   Transmitting file data .
   Committed revision 14.
   $ svn cp -m branchtrunk $SVNREPOURL/trunk $SVNREPOURL/branches/somebranch
   
   Committed revision 15.
   $ cd ..
 
   $ hg init repo2
   $ cd repo2
   $ svn co $SVNREPOURL/branches/somebranch/subdir
   A    subdir/a (glob)
   Checked out revision 15.
   $ echo "subdir = [svn] $SVNREPOURL/branches/somebranch/subdir" > .hgsub
   $ hg add .hgsub
   $ hg ci -m addsub
   $ hg up null
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   A    *subdir/a (glob)
   Checked out revision 15.
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..

tests/test-subrepo.t

@@ -1,1216 +1,1235
 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 ci -Ams0
   adding a
   $ hg sum
   parent: 0:f7b1eb17ad24 tip
    0
   branch: default
   commit: 1 added, 1 subrepos
   update: (current)
   $ hg ci -m1
 
 Revert subrepo and test subrepo fileset keyword:
 
   $ echo b > s/a
   $ hg revert "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ 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)
 
 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
   (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
 
 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, merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
+    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
    t: versions differ -> m
     preserving t for resolve of t
   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
   conflict
   =======
   t3
   >>>>>>> other
 
 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)
   (did you forget to merge? use push -f to force)
   [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 ".^"
   reverting .hgsubstate
   reverting subrepo s
   reverting s/a (glob)
   reverting subrepo ss
   reverting subrepo t
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ 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)
   (did you forget to merge? use push -f to force)
   [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
   $ 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
   $ 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)
   $ 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 subrepositorys, 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]