mercurial-scm/hg: comparison hgext/rebase.py

equal deleted inserted replaced

-:230f73019e49
+:9989a276712f
 # Empty src or already obsoleted - Do not return a destination
 if not src or src in obsoleted:
 return smartset.baseset()
 dests = destutil.orphanpossibledestination(repo, src)
 if len(dests) > 1:
-raise error.Abort(
+raise error.StateError(
 _(b"ambiguous automatic rebase: %r could end up on any of %r")
 % (src, dests)
 )
 # We have zero or one destination, so we can just return here.
 return smartset.baseset(dests)
 (self.originalwd, self.destmap, self.state) = result
 if self.collapsef:
 dests = set(self.destmap.values())
 if len(dests) != 1:
-raise error.Abort(
+raise error.InputError(
 _(b'--collapse does not work with multiple destinations')
 )
 destrev = next(iter(dests))
 destancestors = self.repo.changelog.ancestors(
 [destrev], inclusive=True
 if self.collapsef:
 branches = set()
 for rev in self.state:
 branches.add(repo[rev].branch())
 if len(branches) > 1:
-raise error.Abort(
+raise error.InputError(
 _(b'cannot collapse multiple named branches')
 )
 # Calculate self.obsoletenotrebased
 obsrevs = _filterobsoleterevs(self.repo, self.state)
 elif action == b'stop':
 rbsrt = rebaseruntime(repo, ui)
 with repo.wlock(), repo.lock():
 rbsrt.restorestatus()
 if rbsrt.collapsef:
-raise error.Abort(_(b"cannot stop in --collapse session"))
+raise error.StateError(_(b"cannot stop in --collapse session"))
 allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
 if not (rbsrt.keepf or allowunstable):
-raise error.Abort(
+raise error.StateError(
 _(
 b"cannot remove original changesets with"
 b" unrebased descendants"
 ),
 hint=_(
 b"interactive history editing is supported by the "
 b"'histedit' extension (see \"%s\")"
 )
 % help
 )
-raise error.Abort(msg)
+raise error.InputError(msg)
 if rbsrt.collapsemsg and not rbsrt.collapsef:
-raise error.Abort(_(b'message can only be specified with collapse'))
+raise error.InputError(
+_(b'message can only be specified with collapse')
+)
 if action:
 if rbsrt.collapsef:
-raise error.Abort(
+raise error.InputError(
 _(b'cannot use collapse with continue or abort')
 )
 if action == b'abort' and opts.get(b'tool', False):
 ui.warn(_(b'tool option will be ignored\n'))
 if action == b'continue':
 cmdutil.checkunfinished(repo)
 if not inmemory:
 cmdutil.bailifchanged(repo)
 if ui.configbool(b'commands', b'rebase.requiredest') and not destf:
-raise error.Abort(
+raise error.InputError(
 _(b'you must specify a destination'),
 hint=_(b'use: hg rebase -d REV'),
 )
 dest = None
 % (b'+'.join(bytes(repo[r]) for r in base), dest)
 )
 return None
 if wdirrev in rebaseset:
-raise error.Abort(_(b'cannot rebase the working copy'))
+raise error.InputError(_(b'cannot rebase the working copy'))
 rebasingwcp = repo[b'.'].rev() in rebaseset
 ui.log(
 b"rebase",
 b"rebasing working copy parent: %r\n",
 rebasingwcp,
 if size == 1:
 destmap[r] = destset.first()
 elif size == 0:
 ui.note(_(b'skipping %s - empty destination\n') % repo[r])
 else:
-raise error.Abort(
+raise error.InputError(
 _(b'rebase destination for %s is not unique') % repo[r]
 )
 if dest is not None:
 # single-dest case: assign dest to each rev in rebaseset
 parents.add(p.rev())
 if not parents:
 return nullrev
 if len(parents) == 1:
 return parents.pop()
-raise error.Abort(
+raise error.StateError(
 _(
 b'unable to collapse on top of %d, there is more '
 b'than one external parent: %s'
 )
 % (max(destancestors), b', '.join(b"%d" % p for p in sorted(parents)))
 msg = _(b"this rebase will cause divergences from: %s")
 h = _(
 b"to force the rebase please set "
 b"experimental.evolution.allowdivergence=True"
 )
-raise error.Abort(msg % (b",".join(divhashes),), hint=h)
+raise error.StateError(msg % (b",".join(divhashes),), hint=h)
 def successorrevs(unfi, rev):
 """yield revision numbers for successors of rev"""
 assert unfi.filtername is None
 #
 #     C    # rebase -r C -d D
 #    /|    # None of A and B will be changed to D and rebase fails.
 #   A B D
 if set(newps) == set(oldps) and dest not in newps:
-raise error.Abort(
+raise error.InputError(
 _(
 b'cannot rebase %d:%s without '
 b'moving at least one of its parents'
 )
 % (rev, repo[rev])
 # Source should not be ancestor of dest. The check here guarantees it's
 # impossible. With multi-dest, the initial check does not cover complex
 # cases since we don't have abstractions to dry-run rebase cheaply.
 if any(p != nullrev and isancestor(rev, p) for p in newps):
-raise error.Abort(_(b'source is ancestor of destination'))
+raise error.InputError(_(b'source is ancestor of destination'))
 # Check if the merge will contain unwanted changes. That may happen if
 # there are multiple special (non-changelog ancestor) merge bases, which
 # cannot be handled well by the 3-way merge algorithm. For example:
 #
 b', '.join(b'%d:%s' % (r, repo[r]) for r in revs)
 for revs in unwanted
 if revs is not None
 )
 )
-raise error.Abort(
+raise error.InputError(
 _(b'rebasing %d:%s will include unwanted changes from %s')
 % (rev, repo[rev], unwanteddesc)
 )
 # newps[0] should match merge base if possible. Currently, if newps[i]
 result = []
 for r in srclist:
 if destmap[r] not in srcset:
 result.append(r)
 if not result:
-raise error.Abort(_(b'source and destination form a cycle'))
+raise error.InputError(_(b'source and destination form a cycle'))
 srcset -= set(result)
 yield result
 def buildstate(repo, destmap, collapse):
 # applied patch. But it prevents messing up the working directory when
 # a partially completed rebase is blocked by mq.
 if b'qtip' in repo.tags():
 mqapplied = {repo[s.node].rev() for s in repo.mq.applied}
 if set(destmap.values()) & mqapplied:
-raise error.Abort(_(b'cannot rebase onto an applied mq patch'))
+raise error.StateError(_(b'cannot rebase onto an applied mq patch'))
 # Get "cycle" error early by exhausting the generator.
 sortedsrc = list(sortsource(destmap))  # a list of sorted revs
 if not sortedsrc:
-raise error.Abort(_(b'no matching revisions'))
+raise error.InputError(_(b'no matching revisions'))
 # Only check the first batch of revisions to rebase not depending on other
 # rebaseset. This means "source is ancestor of destination" for the second
 # (and following) batches of revisions are not checked here. We rely on
 # "defineparents" to do that check.
 roots = list(repo.set(b'roots(%ld)', sortedsrc[0]))
 if not roots:
-raise error.Abort(_(b'no matching revisions'))
+raise error.InputError(_(b'no matching revisions'))
 def revof(r):
 return r.rev()
 roots = sorted(roots, key=revof)
 emptyrebase = len(sortedsrc) == 1
 for root in roots:
 dest = repo[destmap[root.rev()]]
 commonbase = root.ancestor(dest)
 if commonbase == root:
-raise error.Abort(_(b'source is ancestor of destination'))
+raise error.InputError(_(b'source is ancestor of destination'))
 if commonbase == dest:
 wctx = repo[None]
 if dest == wctx.p1():
 # when rebasing to '.', it will use the current wd branch name
 samebranch = root.branch() == wctx.branch()
 """Call rebase after pull if the latter has been invoked with --rebase"""
 if opts.get('rebase'):
 if ui.configbool(b'commands', b'rebase.requiredest'):
 msg = _(b'rebase destination required by configuration')
 hint = _(b'use hg pull followed by hg rebase -d DEST')
-raise error.Abort(msg, hint=hint)
+raise error.InputError(msg, hint=hint)
 with repo.wlock(), repo.lock():
 if opts.get('update'):
 del opts['update']
 ui.debug(
 # not passing argument to get the bare update behavior
 # with warning and trumpets
 commands.update(ui, repo)
 else:
 if opts.get('tool'):
-raise error.Abort(_(b'--tool can only be used with --rebase'))
+raise error.InputError(_(b'--tool can only be used with --rebase'))
 ret = orig(ui, repo, *args, **opts)
 return ret

changeset 46632	9989a276712f
parent 46362	24a32dea6955
child 46677	7ed7b13fc00a