fancyopts.py
368 lines
| 10.9 KiB
| text/x-python
|
PythonLexer
/ mercurial / fancyopts.py
|
r8230 | # fancyopts.py - better command line parsing | ||
# | ||||
# Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r8230 | |||
|
r25947 | from __future__ import absolute_import | ||
|
r36373 | import abc | ||
|
r35179 | import functools | ||
|
r25947 | from .i18n import _ | ||
|
r30578 | from . import ( | ||
error, | ||||
pycompat, | ||||
) | ||||
|
r0 | |||
|
r29947 | # Set of flags to not apply boolean negation logic on | ||
|
r32291 | nevernegate = { | ||
|
r29947 | # avoid --no-noninteractive | ||
'noninteractive', | ||||
# These two flags are special because they cause hg to do one | ||||
# thing and then exit, and so aren't suitable for use in things | ||||
# like aliases anyway. | ||||
'help', | ||||
'version', | ||||
|
r32291 | } | ||
|
r29947 | |||
|
r35179 | def _earlyoptarg(arg, shortlist, namelist): | ||
"""Check if the given arg is a valid unabbreviated option | ||||
Returns (flag_str, has_embedded_value?, embedded_value, takes_value?) | ||||
>>> def opt(arg): | ||||
... return _earlyoptarg(arg, b'R:q', [b'cwd=', b'debugger']) | ||||
long form: | ||||
>>> opt(b'--cwd') | ||||
('--cwd', False, '', True) | ||||
>>> opt(b'--cwd=') | ||||
('--cwd', True, '', True) | ||||
>>> opt(b'--cwd=foo') | ||||
('--cwd', True, 'foo', True) | ||||
>>> opt(b'--debugger') | ||||
('--debugger', False, '', False) | ||||
>>> opt(b'--debugger=') # invalid but parsable | ||||
('--debugger', True, '', False) | ||||
short form: | ||||
>>> opt(b'-R') | ||||
('-R', False, '', True) | ||||
>>> opt(b'-Rfoo') | ||||
('-R', True, 'foo', True) | ||||
>>> opt(b'-q') | ||||
('-q', False, '', False) | ||||
>>> opt(b'-qfoo') # invalid but parsable | ||||
('-q', True, 'foo', False) | ||||
unknown or invalid: | ||||
>>> opt(b'--unknown') | ||||
('', False, '', False) | ||||
>>> opt(b'-u') | ||||
('', False, '', False) | ||||
>>> opt(b'-ufoo') | ||||
('', False, '', False) | ||||
>>> opt(b'--') | ||||
('', False, '', False) | ||||
>>> opt(b'-') | ||||
('', False, '', False) | ||||
>>> opt(b'-:') | ||||
('', False, '', False) | ||||
>>> opt(b'-:foo') | ||||
('', False, '', False) | ||||
""" | ||||
if arg.startswith('--'): | ||||
flag, eq, val = arg.partition('=') | ||||
if flag[2:] in namelist: | ||||
return flag, bool(eq), val, False | ||||
if flag[2:] + '=' in namelist: | ||||
return flag, bool(eq), val, True | ||||
elif arg.startswith('-') and arg != '-' and not arg.startswith('-:'): | ||||
flag, val = arg[:2], arg[2:] | ||||
i = shortlist.find(flag[1:]) | ||||
if i >= 0: | ||||
return flag, bool(val), val, shortlist.startswith(':', i + 1) | ||||
return '', False, '', False | ||||
def earlygetopt(args, shortlist, namelist, gnu=False, keepsep=False): | ||||
"""Parse options like getopt, but ignores unknown options and abbreviated | ||||
forms | ||||
If gnu=False, this stops processing options as soon as a non/unknown-option | ||||
argument is encountered. Otherwise, option and non-option arguments may be | ||||
intermixed, and unknown-option arguments are taken as non-option. | ||||
If keepsep=True, '--' won't be removed from the list of arguments left. | ||||
This is useful for stripping early options from a full command arguments. | ||||
>>> def get(args, gnu=False, keepsep=False): | ||||
... return earlygetopt(args, b'R:q', [b'cwd=', b'debugger'], | ||||
... gnu=gnu, keepsep=keepsep) | ||||
default parsing rules for early options: | ||||
>>> get([b'x', b'--cwd', b'foo', b'-Rbar', b'-q', b'y'], gnu=True) | ||||
([('--cwd', 'foo'), ('-R', 'bar'), ('-q', '')], ['x', 'y']) | ||||
>>> get([b'x', b'--cwd=foo', b'y', b'-R', b'bar', b'--debugger'], gnu=True) | ||||
([('--cwd', 'foo'), ('-R', 'bar'), ('--debugger', '')], ['x', 'y']) | ||||
>>> get([b'--unknown', b'--cwd=foo', b'--', '--debugger'], gnu=True) | ||||
([('--cwd', 'foo')], ['--unknown', '--debugger']) | ||||
restricted parsing rules (early options must come first): | ||||
>>> get([b'--cwd', b'foo', b'-Rbar', b'x', b'-q', b'y'], gnu=False) | ||||
([('--cwd', 'foo'), ('-R', 'bar')], ['x', '-q', 'y']) | ||||
>>> get([b'--cwd=foo', b'x', b'y', b'-R', b'bar', b'--debugger'], gnu=False) | ||||
([('--cwd', 'foo')], ['x', 'y', '-R', 'bar', '--debugger']) | ||||
>>> get([b'--unknown', b'--cwd=foo', b'--', '--debugger'], gnu=False) | ||||
|
r35227 | ([], ['--unknown', '--cwd=foo', '--', '--debugger']) | ||
|
r35179 | |||
stripping early options (without loosing '--'): | ||||
>>> get([b'x', b'-Rbar', b'--', '--debugger'], gnu=True, keepsep=True)[1] | ||||
['x', '--', '--debugger'] | ||||
last argument: | ||||
>>> get([b'--cwd']) | ||||
([], ['--cwd']) | ||||
>>> get([b'--cwd=foo']) | ||||
([('--cwd', 'foo')], []) | ||||
>>> get([b'-R']) | ||||
([], ['-R']) | ||||
>>> get([b'-Rbar']) | ||||
([('-R', 'bar')], []) | ||||
>>> get([b'-q']) | ||||
([('-q', '')], []) | ||||
>>> get([b'-q', b'--']) | ||||
([('-q', '')], []) | ||||
|
r35227 | '--' may be a value: | ||
>>> get([b'-R', b'--', b'x']) | ||||
([('-R', '--')], ['x']) | ||||
>>> get([b'--cwd', b'--', b'x']) | ||||
([('--cwd', '--')], ['x']) | ||||
|
r35179 | value passed to bool options: | ||
>>> get([b'--debugger=foo', b'x']) | ||||
([], ['--debugger=foo', 'x']) | ||||
>>> get([b'-qfoo', b'x']) | ||||
([], ['-qfoo', 'x']) | ||||
short option isn't separated with '=': | ||||
>>> get([b'-R=bar']) | ||||
([('-R', '=bar')], []) | ||||
':' may be in shortlist, but shouldn't be taken as an option letter: | ||||
>>> get([b'-:', b'y']) | ||||
([], ['-:', 'y']) | ||||
'-' is a valid non-option argument: | ||||
>>> get([b'-', b'y']) | ||||
([], ['-', 'y']) | ||||
""" | ||||
parsedopts = [] | ||||
parsedargs = [] | ||||
pos = 0 | ||||
|
r35227 | while pos < len(args): | ||
|
r35179 | arg = args[pos] | ||
|
r35227 | if arg == '--': | ||
pos += not keepsep | ||||
break | ||||
|
r35179 | flag, hasval, val, takeval = _earlyoptarg(arg, shortlist, namelist) | ||
|
r35227 | if not hasval and takeval and pos + 1 >= len(args): | ||
|
r35179 | # missing last argument | ||
break | ||||
if not flag or hasval and not takeval: | ||||
# non-option argument or -b/--bool=INVALID_VALUE | ||||
if gnu: | ||||
parsedargs.append(arg) | ||||
pos += 1 | ||||
else: | ||||
break | ||||
elif hasval == takeval: | ||||
# -b/--bool or -s/--str=VALUE | ||||
parsedopts.append((flag, val)) | ||||
pos += 1 | ||||
else: | ||||
# -s/--str VALUE | ||||
parsedopts.append((flag, args[pos + 1])) | ||||
pos += 2 | ||||
|
r35227 | parsedargs.extend(args[pos:]) | ||
|
r35179 | return parsedopts, parsedargs | ||
|
r36373 | class customopt(object): | ||
"""Manage defaults and mutations for any type of opt.""" | ||||
__metaclass__ = abc.ABCMeta | ||||
def __init__(self, defaultvalue): | ||||
self.defaultvalue = defaultvalue | ||||
def _isboolopt(self): | ||||
return False | ||||
@abc.abstractmethod | ||||
def newstate(self, oldstate, newparam, abort): | ||||
"""Adds newparam to oldstate and returns the new state. | ||||
On failure, abort can be called with a string error message.""" | ||||
class _simpleopt(customopt): | ||||
def _isboolopt(self): | ||||
|
r36401 | return isinstance(self.defaultvalue, (bool, type(None))) | ||
|
r36373 | |||
def newstate(self, oldstate, newparam, abort): | ||||
return newparam | ||||
class _callableopt(customopt): | ||||
def __init__(self, callablefn): | ||||
self.callablefn = callablefn | ||||
super(_callableopt, self).__init__(None) | ||||
def newstate(self, oldstate, newparam, abort): | ||||
return self.callablefn(newparam) | ||||
class _listopt(customopt): | ||||
def newstate(self, oldstate, newparam, abort): | ||||
oldstate.append(newparam) | ||||
return oldstate | ||||
class _intopt(customopt): | ||||
def newstate(self, oldstate, newparam, abort): | ||||
try: | ||||
return int(newparam) | ||||
except ValueError: | ||||
abort(_('expected int')) | ||||
def _defaultopt(default): | ||||
"""Returns a default opt implementation, given a default value.""" | ||||
if isinstance(default, customopt): | ||||
return default | ||||
elif callable(default): | ||||
return _callableopt(default) | ||||
elif isinstance(default, list): | ||||
return _listopt(default[:]) | ||||
elif type(default) is type(1): | ||||
return _intopt(default) | ||||
else: | ||||
return _simpleopt(default) | ||||
|
r35223 | def fancyopts(args, options, state, gnu=False, early=False, optaliases=None): | ||
|
r5638 | """ | ||
read args, parse options, and store options in state | ||||
each option is a tuple of: | ||||
short option or '' | ||||
long option | ||||
default value | ||||
description | ||||
|
r11321 | option value label(optional) | ||
|
r5638 | |||
option types include: | ||||
boolean or none - option sets variable in state to true | ||||
string - parameter string is stored in state | ||||
list - parameter string is added to a list | ||||
integer - parameter strings is stored as int | ||||
function - call function with parameter | ||||
|
r36373 | customopt - subclass of 'customopt' | ||
|
r0 | |||
|
r35223 | optaliases is a mapping from a canonical option name to a list of | ||
additional long options. This exists for preserving backward compatibility | ||||
of early options. If we want to use it extensively, please consider moving | ||||
the functionality to the options table (e.g separate long options by '|'.) | ||||
|
r5638 | non-option args are returned | ||
""" | ||||
|
r35223 | if optaliases is None: | ||
optaliases = {} | ||||
|
r5638 | namelist = [] | ||
shortlist = '' | ||||
argmap = {} | ||||
defmap = {} | ||||
|
r29947 | negations = {} | ||
alllong = set(o[1] for o in options) | ||||
|
r5638 | |||
|
r11321 | for option in options: | ||
if len(option) == 5: | ||||
short, name, default, comment, dummy = option | ||||
else: | ||||
short, name, default, comment = option | ||||
|
r5638 | # convert opts to getopt format | ||
|
r35223 | onames = [name] | ||
onames.extend(optaliases.get(name, [])) | ||||
|
r5638 | name = name.replace('-', '_') | ||
|
r35223 | argmap['-' + short] = name | ||
for n in onames: | ||||
argmap['--' + n] = name | ||||
|
r36373 | defmap[name] = _defaultopt(default) | ||
|
r5638 | |||
# copy defaults to state | ||||
|
r36373 | state[name] = defmap[name].defaultvalue | ||
|
r0 | |||
|
r5638 | # does it take a parameter? | ||
|
r36373 | if not defmap[name]._isboolopt(): | ||
|
r10282 | if short: | ||
short += ':' | ||||
|
r35223 | onames = [n + '=' for n in onames] | ||
elif name not in nevernegate: | ||||
for n in onames: | ||||
if n.startswith('no-'): | ||||
insert = n[3:] | ||||
else: | ||||
insert = 'no-' + n | ||||
# backout (as a practical example) has both --commit and | ||||
# --no-commit options, so we don't want to allow the | ||||
# negations of those flags. | ||||
if insert not in alllong: | ||||
assert ('--' + n) not in negations | ||||
negations['--' + insert] = '--' + n | ||||
namelist.append(insert) | ||||
|
r5638 | if short: | ||
shortlist += short | ||||
if name: | ||||
|
r35223 | namelist.extend(onames) | ||
|
r5638 | |||
# parse arguments | ||||
|
r35179 | if early: | ||
parse = functools.partial(earlygetopt, gnu=gnu) | ||||
elif gnu: | ||||
|
r35226 | parse = pycompat.gnugetoptb | ||
|
r7772 | else: | ||
|
r30578 | parse = pycompat.getoptb | ||
|
r7772 | opts, args = parse(args, shortlist, namelist) | ||
|
r0 | |||
|
r5638 | # transfer result to state | ||
for opt, val in opts: | ||||
|
r29947 | boolval = True | ||
negation = negations.get(opt, False) | ||||
if negation: | ||||
opt = negation | ||||
boolval = False | ||||
|
r5638 | name = argmap[opt] | ||
|
r25563 | obj = defmap[name] | ||
|
r36373 | if obj._isboolopt(): | ||
|
r29947 | state[name] = boolval | ||
|
r36373 | else: | ||
def abort(s): | ||||
raise error.Abort( | ||||
_('invalid value %r for option %s, %s') % (val, opt, s)) | ||||
state[name] = defmap[name].newstate(state[name], val, abort) | ||||
|
r209 | |||
|
r5638 | # return unparsed args | ||
|
r0 | return args | ||