mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 16:31:02 +03:00
4c1a9f7e16
This makes it much easier to enable some anti-foot-shooting features (like update --check) by default, because now all boolean flags can be explicitly disabled on the command line without having to use HGPLAIN or similar. Flags which don't deserve this treatment can be removed from consideration by adding them to the nevernegate set in fancyopts. This doesn't make it any easier to identify when a flag is set: opts still always gets filled in, either with the user-specified flag value or with the default from the flags list in the command table. Improving that would probably clean things up a bit, but for now if you want a boolean flag and care if it was explicitly false or default false (or true, but nobody uses that functionality because before now it was nonsense) you need to use None as your default rather than True or False. This doesn't (yet) update help output, because I'm not quite sure how to do that cleanly.
160 lines
4.6 KiB
Python
160 lines
4.6 KiB
Python
# 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
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
from __future__ import absolute_import
|
|
|
|
from .i18n import _
|
|
from . import (
|
|
error,
|
|
pycompat,
|
|
)
|
|
|
|
# Set of flags to not apply boolean negation logic on
|
|
nevernegate = set([
|
|
# 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',
|
|
])
|
|
|
|
def gnugetopt(args, options, longoptions):
|
|
"""Parse options mostly like getopt.gnu_getopt.
|
|
|
|
This is different from getopt.gnu_getopt in that an argument of - will
|
|
become an argument of - instead of vanishing completely.
|
|
"""
|
|
extraargs = []
|
|
if '--' in args:
|
|
stopindex = args.index('--')
|
|
extraargs = args[stopindex + 1:]
|
|
args = args[:stopindex]
|
|
opts, parseargs = pycompat.getoptb(args, options, longoptions)
|
|
args = []
|
|
while parseargs:
|
|
arg = parseargs.pop(0)
|
|
if arg and arg[0] == '-' and len(arg) > 1:
|
|
parseargs.insert(0, arg)
|
|
topts, newparseargs = pycompat.getoptb(parseargs,\
|
|
options, longoptions)
|
|
opts = opts + topts
|
|
parseargs = newparseargs
|
|
else:
|
|
args.append(arg)
|
|
args.extend(extraargs)
|
|
return opts, args
|
|
|
|
|
|
def fancyopts(args, options, state, gnu=False):
|
|
"""
|
|
read args, parse options, and store options in state
|
|
|
|
each option is a tuple of:
|
|
|
|
short option or ''
|
|
long option
|
|
default value
|
|
description
|
|
option value label(optional)
|
|
|
|
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
|
|
|
|
non-option args are returned
|
|
"""
|
|
namelist = []
|
|
shortlist = ''
|
|
argmap = {}
|
|
defmap = {}
|
|
negations = {}
|
|
alllong = set(o[1] for o in options)
|
|
|
|
for option in options:
|
|
if len(option) == 5:
|
|
short, name, default, comment, dummy = option
|
|
else:
|
|
short, name, default, comment = option
|
|
# convert opts to getopt format
|
|
oname = name
|
|
name = name.replace('-', '_')
|
|
|
|
argmap['-' + short] = argmap['--' + oname] = name
|
|
defmap[name] = default
|
|
|
|
# copy defaults to state
|
|
if isinstance(default, list):
|
|
state[name] = default[:]
|
|
elif callable(default):
|
|
state[name] = None
|
|
else:
|
|
state[name] = default
|
|
|
|
# does it take a parameter?
|
|
if not (default is None or default is True or default is False):
|
|
if short:
|
|
short += ':'
|
|
if oname:
|
|
oname += '='
|
|
elif oname not in nevernegate:
|
|
if oname.startswith('no-'):
|
|
insert = oname[3:]
|
|
else:
|
|
insert = 'no-' + oname
|
|
# 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 ('--' + oname) not in negations
|
|
negations['--' + insert] = '--' + oname
|
|
namelist.append(insert)
|
|
if short:
|
|
shortlist += short
|
|
if name:
|
|
namelist.append(oname)
|
|
|
|
# parse arguments
|
|
if gnu:
|
|
parse = gnugetopt
|
|
else:
|
|
parse = pycompat.getoptb
|
|
opts, args = parse(args, shortlist, namelist)
|
|
|
|
# transfer result to state
|
|
for opt, val in opts:
|
|
boolval = True
|
|
negation = negations.get(opt, False)
|
|
if negation:
|
|
opt = negation
|
|
boolval = False
|
|
name = argmap[opt]
|
|
obj = defmap[name]
|
|
t = type(obj)
|
|
if callable(obj):
|
|
state[name] = defmap[name](val)
|
|
elif t is type(1):
|
|
try:
|
|
state[name] = int(val)
|
|
except ValueError:
|
|
raise error.Abort(_('invalid value %r for option %s, '
|
|
'expected int') % (val, opt))
|
|
elif t is type(''):
|
|
state[name] = val
|
|
elif t is type([]):
|
|
state[name].append(val)
|
|
elif t is type(None) or t is type(False):
|
|
state[name] = boolval
|
|
|
|
# return unparsed args
|
|
return args
|