mercurial-scm/hg: comparison mercurial/commands.py

equal deleted inserted replaced

-:21733e8c924f
+:8d72e29ad1e0
 dryrun = opts.get('dry_run')
 abortstate = cmdutil.getunfinishedstate(repo)
 if not abortstate:
 raise error.Abort(_(b'no operation in progress'))
 if not abortstate.abortfunc:
-raise error.Abort(
+raise error.InputError(
 (
 _(b"%s in progress but does not support 'hg abort'")
 % (abortstate._opname)
 ),
 hint=abortstate.hint(),
 Returns 0 on success.
 """
 opts = pycompat.byteskwargs(opts)
 if not pats:
-raise error.Abort(_(b'at least one filename or pattern is required'))
+raise error.InputError(
+_(b'at least one filename or pattern is required')
+)
 if opts.get(b'follow'):
 # --follow is deprecated and now just an alias for -f/--file
 # to mimic the behavior of Mercurial before version 1.5
 opts[b'file'] = True
 if (
 linenumber
 and (not opts.get(b'changeset'))
 and (not opts.get(b'number'))
 ):
-raise error.Abort(_(b'at least one of -n/-c is required for -l'))
+raise error.InputError(_(b'at least one of -n/-c is required for -l'))
 rev = opts.get(b'rev')
 if rev:
 repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
 ctx = scmutil.revsingle(repo, rev)
 rev = opts.get(b'rev')
 if rev:
 repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
 ctx = scmutil.revsingle(repo, rev)
 if not ctx:
-raise error.Abort(_(b'no working directory: please specify a revision'))
+raise error.InputError(
+_(b'no working directory: please specify a revision')
+)
 node = ctx.node()
 dest = cmdutil.makefilename(ctx, dest)
 if os.path.realpath(dest) == repo.root:
-raise error.Abort(_(b'repository root cannot be destination'))
+raise error.InputError(_(b'repository root cannot be destination'))
 kind = opts.get(b'type') or archival.guesskind(dest) or b'files'
 prefix = opts.get(b'prefix')
 if dest == b'-':
 if kind == b'files':
-raise error.Abort(_(b'cannot archive plain files to stdout'))
+raise error.InputError(_(b'cannot archive plain files to stdout'))
 dest = cmdutil.makefileobj(ctx, dest)
 if not prefix:
 prefix = os.path.basename(repo.root) + b'-%h'
 prefix = cmdutil.makefilename(ctx, prefix)
 def _dobackout(ui, repo, node=None, rev=None, **opts):
 cmdutil.check_incompatible_arguments(opts, 'no_commit', ['commit', 'merge'])
 opts = pycompat.byteskwargs(opts)
 if rev and node:
-raise error.Abort(_(b"please specify just one revision"))
+raise error.InputError(_(b"please specify just one revision"))
 if not rev:
 rev = node
 if not rev:
-raise error.Abort(_(b"please specify a revision to backout"))
+raise error.InputError(_(b"please specify a revision to backout"))
 date = opts.get(b'date')
 if date:
 opts[b'date'] = dateutil.parsedate(date)
 ctx = scmutil.revsingle(repo, rev)
 node = ctx.node()
 op1, op2 = repo.dirstate.parents()
 if not repo.changelog.isancestor(node, op1):
-raise error.Abort(_(b'cannot backout change that is not an ancestor'))
+raise error.InputError(
+_(b'cannot backout change that is not an ancestor')
+)
 p1, p2 = repo.changelog.parents(node)
 if p1 == nullid:
-raise error.Abort(_(b'cannot backout a change with no parents'))
+raise error.InputError(_(b'cannot backout a change with no parents'))
 if p2 != nullid:
 if not opts.get(b'parent'):
-raise error.Abort(_(b'cannot backout a merge changeset'))
+raise error.InputError(_(b'cannot backout a merge changeset'))
 p = repo.lookup(opts[b'parent'])
 if p not in (p1, p2):
-raise error.Abort(
+raise error.InputError(
 _(b'%s is not a parent of %s') % (short(p), short(node))
 )
 parent = p
 else:
 if opts.get(b'parent'):
-raise error.Abort(_(b'cannot use --parent on non-merge changeset'))
+raise error.InputError(
+_(b'cannot use --parent on non-merge changeset')
+)
 parent = p1
 # the backout should appear on the same branch
 branch = repo.dirstate.branch()
 bheads = repo.branchheads(branch)
 elif cmd == b"bad":
 bad = True
 else:
 reset = True
 elif extra:
-raise error.Abort(_(b'incompatible arguments'))
+raise error.InputError(_(b'incompatible arguments'))
 incompatibles = {
 b'--bad': bad,
 b'--command': bool(command),
 b'--extend': extend,
 }
 enabled = [x for x in incompatibles if incompatibles[x]]
 if len(enabled) > 1:
-raise error.Abort(
+raise error.InputError(
 _(b'%s and %s are incompatible') % tuple(sorted(enabled)[0:2])
 )
 if reset:
 hbisect.resetstate(repo)
 cmdutil.check_incompatible_arguments(
 opts, b'inactive', [b'delete', b'list']
 )
 if not names and action in {b'add', b'delete'}:
-raise error.Abort(_(b"bookmark name required"))
+raise error.InputError(_(b"bookmark name required"))
 if action in {b'add', b'delete', b'rename', b'inactive'}:
 with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr:
 if action == b'delete':
 names = pycompat.maplist(repo._bookmarks.expandname, names)
 bookmarks.delete(repo, tr, names)
 elif action == b'rename':
 if not names:
-raise error.Abort(_(b"new bookmark name required"))
+raise error.InputError(_(b"new bookmark name required"))
 elif len(names) > 1:
-raise error.Abort(_(b"only one new bookmark name allowed"))
+raise error.InputError(
+_(b"only one new bookmark name allowed")
+)
 oldname = repo._bookmarks.expandname(opts[b'rename'])
 bookmarks.rename(repo, tr, oldname, names[0], force, inactive)
 elif action == b'add':
 bookmarks.addbookmarks(repo, tr, names, rev, force, inactive)
 elif action == b'inactive':
 if label:
 label = label.strip()
 if not opts.get(b'clean') and not label:
 if revs:
-raise error.Abort(_(b"no branch name specified for the revisions"))
+raise error.InputError(
+_(b"no branch name specified for the revisions")
+)
 ui.write(b"%s\n" % repo.dirstate.branch())
 return
 with repo.wlock():
 if opts.get(b'clean'):
 if revs:
 return cmdutil.changebranch(ui, repo, revs, label, opts)
 if not opts.get(b'force') and label in repo.branchmap():
 if label not in [p.branch() for p in repo[None].parents()]:
-raise error.Abort(
+raise error.InputError(
 _(b'a branch of the same name already exists'),
 # i18n: "it" refers to an existing branch
 hint=_(b"use 'hg update' to switch to it"),
 )
 revs = None
 if b'rev' in opts:
 revstrings = opts[b'rev']
 revs = scmutil.revrange(repo, revstrings)
 if revstrings and not revs:
-raise error.Abort(_(b'no commits to bundle'))
+raise error.InputError(_(b'no commits to bundle'))
 bundletype = opts.get(b'type', b'bzip2').lower()
 try:
 bundlespec = bundlecaches.parsebundlespec(
 repo, bundletype, strict=False
 )
 except error.UnsupportedBundleSpecification as e:
-raise error.Abort(
+raise error.InputError(
 pycompat.bytestr(e),
 hint=_(b"see 'hg help bundlespec' for supported values for --type"),
 )
 cgversion = bundlespec.contentopts[b"cg.version"]
 # Packed bundles are a pseudo bundle format for now.
 if cgversion == b's1':
-raise error.Abort(
+raise error.InputError(
 _(b'packed bundles cannot be produced by "hg bundle"'),
 hint=_(b"use 'hg debugcreatestreamclonebundle'"),
 )
 if opts.get(b'all'):
 if dest:
-raise error.Abort(
+raise error.InputError(
 _(b"--all is incompatible with specifying a destination")
 )
 if opts.get(b'base'):
 ui.warn(_(b"ignoring --base because --all was specified\n"))
 base = [nullrev]
 _(b"repository does not support bundle version %s") % cgversion
 )
 if base:
 if dest:
-raise error.Abort(
+raise error.InputError(
 _(b"--base is incompatible with specifying a destination")
 )
 common = [repo[rev].node() for rev in base]
 heads = [repo[r].node() for r in revs] if revs else None
 outgoing = discovery.outgoing(repo, common, heads)
 extra = {}
 if opts.get(b'close_branch') or opts.get(b'force_close_branch'):
 extra[b'close'] = b'1'
 if repo[b'.'].closesbranch():
-raise error.Abort(
+raise error.InputError(
 _(b'current revision is already a branch closing head')
 )
 elif not bheads:
-raise error.Abort(_(b'branch "%s" has no heads to close') % branch)
+raise error.InputError(
+_(b'branch "%s" has no heads to close') % branch
+)
 elif (
 branch == repo[b'.'].branch()
 and repo[b'.'].node() not in bheads
 and not opts.get(b'force_close_branch')
 ):
 hint = _(
 b'use --force-close-branch to close branch from a non-head'
 b' changeset'
 )
-raise error.Abort(_(b'can only close branch heads'), hint=hint)
+raise error.InputError(_(b'can only close branch heads'), hint=hint)
 elif opts.get(b'amend'):
 if (
 repo[b'.'].p1().branch() != branch
 and repo[b'.'].p2().branch() != branch
 ):
-raise error.Abort(_(b'can only close branch heads'))
+raise error.InputError(_(b'can only close branch heads'))
 if opts.get(b'amend'):
 if ui.configbool(b'ui', b'commitsubrepos'):
-raise error.Abort(_(b'cannot amend with ui.commitsubrepos enabled'))
+raise error.InputError(
+_(b'cannot amend with ui.commitsubrepos enabled')
+)
 old = repo[b'.']
 rewriteutil.precheck(repo, [old.rev()], b'amend')
 # Currently histedit gets confused if an amend happens while histedit
 editopts = (b'edit', b'local', b'global', b'shared', b'non_shared')
 if any(opts.get(o) for o in editopts):
 cmdutil.check_at_most_one_arg(opts, *editopts[1:])
 if opts.get(b'local'):
 if not repo:
-raise error.Abort(_(b"can't use --local outside a repository"))
+raise error.InputError(
+_(b"can't use --local outside a repository")
+)
 paths = [repo.vfs.join(b'hgrc')]
 elif opts.get(b'global'):
 paths = rcutil.systemrcpath()
 elif opts.get(b'shared'):
 if not repo.shared():
-raise error.Abort(
+raise error.InputError(
 _(b"repository is not shared; can't use --shared")
 )
 if requirements.SHARESAFE_REQUIREMENT not in repo.requirements:
-raise error.Abort(
+raise error.InputError(
 _(
 b"share safe feature not unabled; "
 b"unable to edit shared source repository config"
 )
 )
 fp.close()
 editor = ui.geteditor()
 ui.system(
 b"%s \"%s\"" % (editor, f),
-onerr=error.Abort,
+onerr=error.InputError,
 errprefix=_(b"edit failed"),
 blockedtag=b'config_edit',
 )
 return
 ui.pager(b'config')
 cmdutil.check_at_most_one_arg(opts, b'rev', b'bookmark')
 if bookmark:
 if bookmark not in repo._bookmarks:
-raise error.Abort(_(b"bookmark '%s' not found") % bookmark)
+raise error.InputError(_(b"bookmark '%s' not found") % bookmark)
 revs = scmutil.bookmarkrevs(repo, bookmark)
 else:
 if not changesets:
 changesets = [b'.']
 repo = scmutil.unhidehashlikerevs(repo, changesets, b'nowarn')
 revs = scmutil.revrange(repo, changesets)
 if not revs:
-raise error.Abort(_(b"export requires at least one changeset"))
+raise error.InputError(_(b"export requires at least one changeset"))
 if len(revs) > 1:
 ui.note(_(b'exporting patches:\n'))
 else:
 ui.note(_(b'exporting patch:\n'))
 Returns 0 on success.
 """
 opts = pycompat.byteskwargs(opts)
 if not pats:
-raise error.Abort(_(b'no files specified'))
+raise error.InputError(_(b'no files specified'))
 m = scmutil.match(repo[None], pats, opts)
 dryrun, interactive = opts.get(b'dry_run'), opts.get(b'interactive')
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 rejected = cmdutil.forget(
 )
 return cmdutil.abortgraft(ui, repo, graftstate)
 elif opts.get(b'continue'):
 cont = True
 if revs:
-raise error.Abort(_(b"can't specify --continue and revisions"))
+raise error.InputError(_(b"can't specify --continue and revisions"))
 # read in unfinished revisions
 if graftstate.exists():
 statedata = cmdutil.readgraftstate(repo, graftstate)
 if statedata.get(b'date'):
 opts[b'date'] = statedata[b'date']
 revs = [repo[node].rev() for node in nodes]
 else:
 cmdutil.wrongtooltocontinue(repo, _(b'graft'))
 else:
 if not revs:
-raise error.Abort(_(b'no revisions specified'))
+raise error.InputError(_(b'no revisions specified'))
 cmdutil.checkunfinished(repo)
 cmdutil.bailifchanged(repo)
 revs = scmutil.revrange(repo, revs)
 skipped = set()
 skipped.add(rev)
 revs = [r for r in revs if r not in skipped]
 if not revs:
 return -1
 if basectx is not None and len(revs) != 1:
-raise error.Abort(_(b'only one revision allowed with --base '))
+raise error.InputError(_(b'only one revision allowed with --base '))
 # Don't check in the --continue case, in effect retaining --force across
 # --continues. That's because without --force, any revisions we decided to
 # skip would have been filtered out here, so they wouldn't have made their
 # way to the graftstate. With --force, any revisions we would have otherwise
 Returns 0 if successful.
 """
 opts = pycompat.byteskwargs(opts)
 if not repo and not source:
-raise error.Abort(
+raise error.InputError(
 _(b"there is no Mercurial repository here (.hg not found)")
 )
 default = not (num or id or branch or tags or bookmarks)
 output = []
 fm = ui.formatter(b'identify', opts)
 fm.startitem()
 if not repo:
 if num or branch or tags:
-raise error.Abort(
+raise error.InputError(
 _(b"can't query remote revision number, branch, or tags")
 )
 if not rev and revs:
 rev = revs[0]
 if not rev:
 opts, 'no_commit', ['bypass', 'secret']
 )
 cmdutil.check_incompatible_arguments(opts, 'exact', ['edit', 'prefix'])
 opts = pycompat.byteskwargs(opts)
 if not patch1:
-raise error.Abort(_(b'need at least one patch to import'))
+raise error.InputError(_(b'need at least one patch to import'))
 patches = (patch1,) + patches
 date = opts.get(b'date')
 if date:
 exact = opts.get(b'exact')
 update = not opts.get(b'bypass')
 try:
 sim = float(opts.get(b'similarity') or 0)
 except ValueError:
-raise error.Abort(_(b'similarity must be a number'))
+raise error.InputError(_(b'similarity must be a number'))
 if sim < 0 or sim > 100:
-raise error.Abort(_(b'similarity must be between 0 and 100'))
+raise error.InputError(_(b'similarity must be between 0 and 100'))
 if sim and not update:
-raise error.Abort(_(b'cannot use --similarity with --bypass'))
+raise error.InputError(_(b'cannot use --similarity with --bypass'))
 base = opts[b"base"]
 msgs = []
 ret = 0
 )
 ret = 1
 break
 if not haspatch:
-raise error.Abort(_(b'%s: no diffs found') % patchurl)
+raise error.InputError(_(b'%s: no diffs found') % patchurl)
 if msgs:
 repo.savecommitmessage(b'\n* * *\n'.join(msgs))
 return ret
 """
 opts = pycompat.byteskwargs(opts)
 linerange = opts.get(b'line_range')
 if linerange and not opts.get(b'follow'):
-raise error.Abort(_(b'--line-range requires --follow'))
+raise error.InputError(_(b'--line-range requires --follow'))
 if linerange and pats:
 # TODO: take pats as patterns with no line-range filter
-raise error.Abort(
+raise error.InputError(
 _(b'FILE arguments are not compatible with --line-range option')
 )
 repo = scmutil.unhidehashlikerevs(repo, opts.get(b'rev'), b'nowarn')
 revs, differ = logcmdutil.getrevs(
 opts = pycompat.byteskwargs(opts)
 fm = ui.formatter(b'manifest', opts)
 if opts.get(b'all'):
 if rev or node:
-raise error.Abort(_(b"can't specify a revision with --all"))
+raise error.InputError(_(b"can't specify a revision with --all"))
 res = set()
 for rev in repo:
 ctx = repo[rev]
 res |= set(ctx.files())
 fm.write(b"path", b'%s\n', f)
 fm.end()
 return
 if rev and node:
-raise error.Abort(_(b"please specify just one revision"))
+raise error.InputError(_(b"please specify just one revision"))
 if not node:
 node = rev
 char = {b'l': b'@', b'x': b'*', b'': b'', b't': b'd'}
 raise error.Abort(
 _(b'cannot abort merge with %s in progress') % (state._opname),
 hint=state.hint(),
 )
 if node:
-raise error.Abort(_(b"cannot specify a node with --abort"))
+raise error.InputError(_(b"cannot specify a node with --abort"))
 return hg.abortmerge(repo.ui, repo)
 if opts.get(b'rev') and node:
-raise error.Abort(_(b"please specify just one revision"))
+raise error.InputError(_(b"please specify just one revision"))
 if not node:
 node = opts.get(b'rev')
 if node:
 ctx = scmutil.revsingle(repo, node)
 else:
 if ui.configbool(b'commands', b'merge.require-rev'):
-raise error.Abort(
+raise error.InputError(
 _(
 b'configuration requires specifying revision to merge '
 b'with'
 )
 )
 ctx = repo[destutil.destmerge(repo)]
 if ctx.node() is None:
-raise error.Abort(_(b'merging with the working copy has no effect'))
+raise error.InputError(
+_(b'merging with the working copy has no effect')
+)
 if opts.get(b'preview'):
 # find nodes that are ancestors of p2 but not of p1
 p1 = repo[b'.'].node()
 p2 = ctx.node()
 ctx = scmutil.revsingle(repo, rev, None)
 if file_:
 m = scmutil.match(ctx, (file_,), opts)
 if m.anypats() or len(m.files()) != 1:
-raise error.Abort(_(b'can only specify an explicit filename'))
+raise error.InputError(_(b'can only specify an explicit filename'))
 file_ = m.files()[0]
 filenodes = []
 for cp in ctx.parents():
 if not cp:
 continue
 try:
 filenodes.append(cp.filenode(file_))
 except error.LookupError:
 pass
 if not filenodes:
-raise error.Abort(_(b"'%s' not found in manifest!") % file_)
+raise error.InputError(_(b"'%s' not found in manifest!") % file_)
 p = []
 for fn in filenodes:
 fctx = repo.filectx(file_, fileid=fn)
 p.append(fctx.node())
 else:
 # search for a unique phase argument
 targetphase = None
 for idx, name in enumerate(phases.cmdphasenames):
 if opts[name]:
 if targetphase is not None:
-raise error.Abort(_(b'only one phase can be specified'))
+raise error.InputError(_(b'only one phase can be specified'))
 targetphase = idx
 # look for specified revision
 revs = list(revs)
 revs.extend(opts[b'rev'])
 ui.write(b'%i: %s\n' % (ctx.rev(), ctx.phasestr()))
 else:
 with repo.lock(), repo.transaction(b"phase") as tr:
 # set phase
 if not revs:
-raise error.Abort(_(b'empty revision set'))
+raise error.InputError(_(b'empty revision set'))
 nodes = [repo[r].node() for r in revs]
 # moving revision from public to draft may hide them
 # We have to check result on an unfiltered repository
 unfi = repo.unfiltered()
 getphase = unfi._phasecache.phase
 if ui.configbool(b'commands', b'update.requiredest') and opts.get(
 b'update'
 ):
 msg = _(b'update destination required by configuration')
 hint = _(b'use hg pull followed by hg update DEST')
-raise error.Abort(msg, hint=hint)
+raise error.InputError(msg, hint=hint)
 source, branches = hg.parseurl(ui.expandpath(source), opts.get(b'branch'))
 ui.status(_(b'pulling from %s\n') % util.hidepassword(source))
 other = hg.peer(repo, opts, source)
 try:
 remotebookmarks = bookmarks.unhexlifybookmarks(remotebookmarks)
 pullopargs[b'remotebookmarks'] = remotebookmarks
 for b in opts.get(b'bookmark', []):
 b = repo._bookmarks.expandname(b)
 if b not in remotebookmarks:
-raise error.Abort(_(b'remote bookmark %s not found!') % b)
+raise error.InputError(
+_(b'remote bookmark %s not found!') % b
+)
 nodes.append(remotebookmarks[b])
 for i, rev in enumerate(revs):
 node = fnodes[i].result()
 nodes.append(node)
 if rev == checkout:
 other = hg.peer(repo, opts, dest)
 if revs:
 revs = [repo[r].node() for r in scmutil.revrange(repo, revs)]
 if not revs:
-raise error.Abort(
+raise error.InputError(
 _(b"specified revisions evaluate to an empty set"),
 hint=_(b"use different revision arguments"),
 )
 elif path.pushrev:
 # It doesn't make any sense to specify ancestor revisions. So limit
 # to DAG heads to make discovery simpler.
 expr = revsetlang.formatspec(b'heads(%r)', path.pushrev)
 revs = scmutil.revrange(repo, [expr])
 revs = [repo[rev].node() for rev in revs]
 if not revs:
-raise error.Abort(
+raise error.InputError(
 _(b'default push revset for path evaluates to an empty set')
 )
 elif ui.configbool(b'commands', b'push.require-revs'):
-raise error.Abort(
+raise error.InputError(
 _(b'no revisions specified to push'),
 hint=_(b'did you mean "hg push -r ."?'),
 )
 repo._subtoppath = dest
 opts = pycompat.byteskwargs(opts)
 after, force = opts.get(b'after'), opts.get(b'force')
 dryrun = opts.get(b'dry_run')
 if not pats and not after:
-raise error.Abort(_(b'no files specified'))
+raise error.InputError(_(b'no files specified'))
 m = scmutil.match(repo[None], pats, opts)
 subrepos = opts.get(b'subrepos')
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 return cmdutil.remove(
 flaglist = b'all mark unmark list no_status re_merge'.split()
 all, mark, unmark, show, nostatus, remerge = [opts.get(o) for o in flaglist]
 actioncount = len(list(filter(None, [show, mark, unmark, remerge])))
 if actioncount > 1:
-raise error.Abort(_(b"too many actions specified"))
+raise error.InputError(_(b"too many actions specified"))
 elif actioncount == 0 and ui.configbool(
 b'commands', b'resolve.explicit-re-merge'
 ):
 hint = _(b'use --mark, --unmark, --list or --re-merge')
-raise error.Abort(_(b'no action specified'), hint=hint)
+raise error.InputError(_(b'no action specified'), hint=hint)
 if pats and all:
-raise error.Abort(_(b"can't specify --all and patterns"))
+raise error.InputError(_(b"can't specify --all and patterns"))
 if not (all or pats or show or mark or unmark):
-raise error.Abort(
+raise error.InputError(
 _(b'no files or directories specified'),
 hint=b'use --all to re-merge all unresolved files',
 )
 if confirm:
 opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"])
 parent, p2 = repo.dirstate.parents()
 if not opts.get(b'rev') and p2 != nullid:
 # revert after merge is a trap for new users (issue2915)
-raise error.Abort(
+raise error.InputError(
 _(b'uncommitted merge with no revision specified'),
 hint=_(b"use 'hg update' or see 'hg help revert'"),
 )
 rev = opts.get(b'rev')
 if p2 != nullid:
 hint = _(
 b"uncommitted merge, use --all to discard all changes,"
 b" or 'hg update -C .' to abort the merge"
 )
-raise error.Abort(msg, hint=hint)
+raise error.InputError(msg, hint=hint)
 dirty = any(repo.status())
 node = ctx.node()
 if node != parent:
 if dirty:
 hint = (
 )
 elif dirty:
 hint = _(b"uncommitted changes, use --all to discard all changes")
 else:
 hint = _(b"use --all to revert all files")
-raise error.Abort(msg, hint=hint)
+raise error.InputError(msg, hint=hint)
 return cmdutil.revert(ui, repo, ctx, *pats, **pycompat.strkwargs(opts))
 @command(
 """
 cmdutil.check_incompatible_arguments(opts, 'stdio', ['cmdserver'])
 opts = pycompat.byteskwargs(opts)
 if opts[b"print_url"] and ui.verbose:
-raise error.Abort(_(b"cannot use --print-url with --verbose"))
+raise error.InputError(_(b"cannot use --print-url with --verbose"))
 if opts[b"stdio"]:
 if repo is None:
 raise error.RepoError(
 _(b"there is no Mercurial repository here (.hg not found)")
 def checkopt(opt):
 if opts.get(opt):
 for i, allowable in allowables:
 if opts[i] and opt not in allowable:
-raise error.Abort(
+raise error.InputError(
 _(
 b"options '--%s' and '--%s' may not be "
 b"used together"
 )
 % (opt, i)
 )
 return True
 if checkopt(b'cleanup'):
 if pats:
-raise error.Abort(_(b"cannot specify names when using '--cleanup'"))
+raise error.InputError(
+_(b"cannot specify names when using '--cleanup'")
+)
 return shelvemod.cleanupcmd(ui, repo)
 elif checkopt(b'delete'):
 return shelvemod.deletecmd(ui, repo, pats)
 elif checkopt(b'list'):
 return shelvemod.listcmd(ui, repo, pats, opts)
 else:
 terse = ui.config(b'commands', b'status.terse')
 if revs and terse:
 msg = _(b'cannot use --terse with --rev')
-raise error.Abort(msg)
+raise error.InputError(msg)
 elif change:
 repo = scmutil.unhidehashlikerevs(repo, [change], b'nowarn')
 ctx2 = scmutil.revsingle(repo, change, None)
 ctx1 = ctx2.p1()
 else:
 opts = pycompat.byteskwargs(opts)
 with repo.wlock(), repo.lock():
 rev_ = b"."
 names = [t.strip() for t in (name1,) + names]
 if len(names) != len(set(names)):
-raise error.Abort(_(b'tag names must be unique'))
+raise error.InputError(_(b'tag names must be unique'))
 for n in names:
 scmutil.checknewlabel(repo, n, b'tag')
 if not n:
-raise error.Abort(
+raise error.InputError(
 _(b'tag names cannot consist entirely of whitespace')
 )
 if opts.get(b'rev'):
 rev_ = opts[b'rev']
 message = opts.get(b'message')
 for n in names:
 if repo.tagtype(n) == b'global':
 alltags = tagsmod.findglobaltags(ui, repo)
 if alltags[n][0] == nullid:
-raise error.Abort(_(b"tag '%s' is already removed") % n)
+raise error.InputError(
+_(b"tag '%s' is already removed") % n
+)
 if not repo.tagtype(n):
-raise error.Abort(_(b"tag '%s' does not exist") % n)
+raise error.InputError(_(b"tag '%s' does not exist") % n)
 if repo.tagtype(n) != expectedtype:
 if expectedtype == b'global':
-raise error.Abort(
+raise error.InputError(
 _(b"tag '%s' is not a global tag") % n
 )
 else:
-raise error.Abort(_(b"tag '%s' is not a local tag") % n)
+raise error.InputError(
+_(b"tag '%s' is not a local tag") % n
+)
 rev_ = b'null'
 if not message:
 # we don't translate commit messages
 message = b'Removed tag %s' % b', '.join(names)
 elif not opts.get(b'force'):
 for n in names:
 if n in repo.tags():
-raise error.Abort(
+raise error.InputError(
 _(b"tag '%s' already exists (use -f to force)") % n
 )
 if not opts.get(b'local'):
 p1, p2 = repo.dirstate.parents()
 if p2 != nullid:
 raise error.Abort(_(b'uncommitted merge'))
 bheads = repo.branchheads()
 if not opts.get(b'force') and bheads and p1 not in bheads:
-raise error.Abort(
+raise error.InputError(
 _(
 b'working directory is not at a branch head '
 b'(use -f to force)'
 )
 )
 # don't allow tagging the null rev
 if (
 not opts.get(b'remove')
 and scmutil.revsingle(repo, rev_).rev() == nullrev
 ):
-raise error.Abort(_(b"cannot tag null revision"))
+raise error.InputError(_(b"cannot tag null revision"))
 tagsmod.tag(
 repo,
 names,
 node,
 with repo.lock():
 for fname in fnames:
 f = hg.openpath(ui, fname)
 gen = exchange.readbundle(ui, f, fname)
 if isinstance(gen, streamclone.streamcloneapplier):
-raise error.Abort(
+raise error.InputError(
 _(
 b'packed bundles cannot be applied with '
 b'"hg unbundle"'
 ),
 hint=_(b'use "hg debugapplystreamclonebundle"'),
 date = opts.get('date')
 clean = opts.get('clean')
 check = opts.get('check')
 merge = opts.get('merge')
 if rev and node:
-raise error.Abort(_(b"please specify just one revision"))
+raise error.InputError(_(b"please specify just one revision"))
 if ui.configbool(b'commands', b'update.requiredest'):
 if not node and not rev and not date:
-raise error.Abort(
+raise error.InputError(
 _(b'you must specify a destination'),
 hint=_(b'for example: hg update ".::"'),
 )
 if rev is None or rev == b'':
 rev = node
 if date and rev is not None:
-raise error.Abort(_(b"you can't specify a revision and a date"))
+raise error.InputError(_(b"you can't specify a revision and a date"))
 updatecheck = None
 if check:
 updatecheck = b'abort'
 elif merge:

changeset 45827	8d72e29ad1e0
parent 45819	d6279c43fc60
child 45840	527ce85c2e60