mercurial: comparison mercurial/subrepo.py

equal deleted inserted replaced

-:bc694d78d843
+:9e3910db4e78
 import config, scmutil, util, node, error, cmdutil, bookmarks, match as matchmod
 hg = None
 propertycache = util.propertycache
 nullstate = ('', '', 'empty')
+class SubrepoAbort(error.Abort):
+"""Exception class used to avoid handling a subrepo error more than once"""
+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:
+errormsg = _('%s (in subrepo %s)') % (str(ex), subrelpath(self))
+# avoid handling this exception by raising a SubrepoAbort exception
+raise SubrepoAbort(errormsg, hint=ex.hint)
+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))
 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 abort:
-raise util.Abort(_("default path for subrepository %s not found") %
+raise util.Abort(_("default path for subrepository not found"))
-reporelpath(repo))
 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
 v = r.ui.config(s, k)
 if v:
 self._repo.ui.setconfig(s, k, v)
 self._initrepo(r, state[0], create)
+@annotatesubrepoerror
 def _initrepo(self, parentrepo, source, create):
 self._repo._subparent = parentrepo
 self._repo._subsource = source
 if create:
 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]
 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
 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',))
 abstractsubrepo.archive(self, ui, archiver, prefix, match)
 rev = self._state[1]
 for subpath in ctx.substate:
 s = subrepo(ctx, subpath)
 submatch = matchmod.narrowmatcher(subpath, match)
 s.archive(ui, archiver, os.path.join(prefix, self._path), submatch)
+@annotatesubrepoerror
 def dirty(self, ignoreupdate=False):
 r = self._state[1]
 if r == '' and not ignoreupdate: # no state recorded
 return True
 w = self._repo[None]
 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()
 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)
 % (subrelpath(self), srcurl))
 self._repo.pull(other)
 bookmarks.updatefromremote(self._repo.ui, self._repo, other,
 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)
 else:
 mergefunc()
 else:
 mergefunc()
+@annotatesubrepoerror
 def push(self, opts):
 force = opts.get('force')
 newbranch = opts.get('new_branch')
 ssh = opts.get('ssh')
 self._repo.ui.status(_('pushing subrepo %s to %s\n') %
 (subrelpath(self), dsturl))
 other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
 return self._repo.push(other, force, newbranch=newbranch)
+@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 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
 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()
 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
 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):
 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:
 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'):
 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
 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._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()
 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()
 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
 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 '
 ui.progress(_('archiving (%s)') % relpath, i + 1,
 unit=_('files'))
 ui.progress(_('archiving (%s)') % relpath, None)
+@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 [], [], [], [], [], [], []

changeset 18109	9e3910db4e78
parent 18031	54f063acc5ea
child 18263	9aa6bee6e9f9