def test_force_suffix_value(self):
parser = ArgumentParserEx()
parser.add_argument(prefixes=["-Xclang"])
ns = parser.parse_args(["-Xclangvalue"])
self.assertEqual("value", ns.Xclang)
parser = ArgumentParserEx()
parser.add_argument("-Xclang", prefix=True)
ns = parser.parse_args(["-Xclangvalue"])
self.assertEqual("value", ns.Xclang)
def __init__(self, context, platform=platform.system().lower()):
ParserBase.__init__(self, context)
self.platform = get_platform(platform)
self.program_re = self.platform.get_program_path_re("icupkg")
# https://helpmanual.io/help/icupkg/
self.parser = ArgumentParserEx()
self.parser.set(dest=None, raw_dest="args")
self.parser.add_argument("--type", "-t", choices=["l", "b", "e"])
self.parser.add_argument("--copyright", "-c")
self.parser.add_argument("--comment", "-C")
self.parser.add_argument("--add", "-a")
self.parser.add_argument("--remove", "-r")
self.parser.add_argument("--extract", "-x")
self.parser.add_argument("--writepkg", "-w", action="store_true")
self.parser.add_argument("--matchmode", "-m")
self.parser.add_argument("--auto_toc_prefix", action="store_true")
self.parser.add_argument("--auto_toc_prefix_with_type", action="store_true")
self.parser.add_argument("--sourcedir", "-s", raw_handler=self.input_dir)
self.parser.add_argument("--destdir", "-d", raw_handler=self.input_dir)
self.parser.add_argument("--list", "-l", action="store_true")
self.parser.add_argument("--outlist", "-o", raw_handler=self.output_file)
self.parser.add_argument("infilename", raw_handler=self.input_file)
self.parser.add_argument("outfilename", nargs="?", raw_handler=self.output_file)
def __init__(self, context, platform=None):
self.context = context
self.platform = get_platform(platform)
self.program_re = self.platform.get_program_path_re("cmake")
self.parser = ArgumentParserEx(prog="cmake")
self.parser.add_argument("-E", dest="command", nargs="+")
def __init__(self, context, ignore_compile_flags=None):
CompilerParser.__init__(
self, context, ignore_compile_flags=ignore_compile_flags
)
# Visual Studio rc.exe arguments
# https://docs.microsoft.com/en-us/windows/desktop/menurc/using-rc-the-rc-command-line-
self.parser = ArgumentParserEx(prefix_chars="-/")
self.parser.set_defaults(compile_flags=[], link_flags=[], include_dirs=[])
# TODO: publish all meaningful flags
self.parser.set(ignore_case=True, dest=None, raw_dest="compile_flags")
self.parser.add_argument("/d", raw_format=ReplacePrefixArg("-D"))
self.parser.add_argument("/u", raw_format=ReplacePrefixArg("-U"))
self.parser.add_argument("/ln", raw_format=ReplacePrefixArg("/ln"))
self.parser.add_argument("/l", raw_format=ReplacePrefixArg("/l"))
self.parser.add_argument("/gn", raw_format=ReplacePrefixArg("/gn"))
self.parser.add_argument("/g", raw_format=ReplacePrefixArg("/g"))
self.parser.add_argument(
"/i", action="append", dest="include_dirs", raw_dest=None
)
self.parser.add_argument("/nologo", action="store_true")
self.parser.add_argument(
"/w", action="store_true", raw_format=ReplacePrefixArg("/w")
)
self.parser.add_argument("/fo", prefix=True, dest="output", raw_dest=None)
self.parser.add_argument("infiles", dest="infiles", nargs="*", raw_dest=None)
def test_action_append_const(self):
parser = ArgumentParserEx()
parser.add_argument("-a", action="append_const", const="v")
ns, remaining = parser.parse_known_args(["-a", "1", "-a2", "-a"])
self.assertListEqual(["1", "-a2"], remaining)
self.assertEqual(["v", "v"], ns.a)
def test_case_insensitive_windows_style(self):
parser = ArgumentParserEx(prefix_chars="/")
parser.add_argument("/nologo", action="store_true", ignore_case=True)
ns = parser.parse_args(["/NOLOGO"])
self.assertTrue(ns.nologo)
ns = parser.parse_args(["/nologo"])
self.assertTrue(ns.nologo)
def test_msvc_flag_with_value(self):
parser = ArgumentParserEx(prefix_chars="/-")
parser.set(ignore_case=True)
parser.add_argument("/flag", action="msvc_flag_with_value")
parser.add_argument("/ENABLE",
action="msvc_flag_with_value",
append=True,
dest="list")
ns, remaining = parser.parse_known_args(["/FLAG"])
self.assertListEqual(["/FLAG"], remaining)
self.assertIsNone(vars(ns).get("flag"))
ns, remaining = parser.parse_known_args(["/flag"])
self.assertListEqual(["/flag"], remaining)
self.assertIsNone(vars(ns).get("flag"))
ns, remaining = parser.parse_known_args(["/flag:"])
self.assertListEqual(["/flag:"], remaining)
self.assertIsNone(vars(ns).get("flag"))
ns = parser.parse_args(["/flag:value"])
self.assertEqual("value", ns.flag)
ns = parser.parse_args(["-FLAG:1,2,3"])
self.assertEqual("1,2,3", ns.flag)
ns = parser.parse_args(["/ENABLE:1", "-FlAg:2", "-enable:3"])
self.assertEqual("2", ns.flag)
self.assertEqual(["1", "3"], ns.list)
def test_raw_dest(self):
parser = ArgumentParserEx()
parser.add_argument("-arg1", action="store_true", raw_dest="args")
parser.add_argument("--arg2", "-f", dest=None, raw_dest="args")
parser.add_argument("file", raw_dest="args")
parser.add_argument("files", nargs="*", dest=None, raw_dest="args")
parser.add_argument("-D",
dest=None,
raw_dest="args",
raw_format="".join)
ns = parser.parse_args(["--arg2", "1", "2"])
self.assertListEqual([["--arg2", "1"], "2"], ns.args)
ns = parser.parse_args(["--arg2=1", "1", "-arg1", "2", "3"])
self.assertListEqual(["--arg2=1", "1", "-arg1", "2", "3"], ns.args)
ns, remaining = parser.parse_known_args(
["1", "-fvalue", "2", "-unknown"])
self.assertListEqual(["-unknown"], remaining)
self.assertListEqual(["1", "-fvalue", "2"], ns.args)
ns, remaining = parser.parse_known_args(
["1", "-unknown", "-fvalue", "2"])
self.assertListEqual(["-unknown"], remaining)
self.assertListEqual(["1", "-fvalue", "2"], ns.args)
ns = parser.parse_args(["1", "-D", "2", "3", "-D4"])
self.assertListEqual(["1", "-D2", "3", "-D4"], ns.args)
def test_prefix_chars(self):
parser = ArgumentParserEx(prefix_chars="/-")
parser.add_argument("-attr1", action="store")
ns, remaining = parser.parse_known_args(["/attr1", "val"])
self.assertListEqual([], remaining)
self.assertEqual("val", ns.attr1)
ns, remaining = parser.parse_known_args(["-attr1", "val"])
self.assertListEqual([], remaining)
self.assertEqual("val", ns.attr1)
parser.set(prefix_chars="+")
parser.add_argument("+attr2", action="store")
ns, remaining = parser.parse_known_args(
["-attr1", "val1", "+attr2", "val2"])
self.assertListEqual([], remaining)
self.assertEqual("val1", ns.attr1)
self.assertEqual("val2", ns.attr2)
ns, remaining = parser.parse_known_args(
["/attr1", "val1", "+attr2", "val2"])
self.assertListEqual([], remaining)
self.assertEqual("val1", ns.attr1)
self.assertEqual("val2", ns.attr2)
ns, remaining = parser.parse_known_args(
["+attr1", "val1", "-attr2", "val2"])
self.assertListEqual(["+attr1", "val1", "-attr2", "val2"], remaining)
self.assertIsNone(vars(ns).get("attr1"))
self.assertIsNone(vars(ns).get("attr2"))
def test_unknown_args_dest(self):
parser = ArgumentParserEx()
parser.add_argument("--flag", action="store_true", raw_dest="args")
parser.add_argument("--key", raw_dest="args")
parser.add_argument("infile", raw_dest="args")
ns, unknown = parser.parse_known_args(["--flag"], unknown_dest="args")
self.assertListEqual(["--flag"], ns.args)
self.assertListEqual([], unknown)
ns, unknown = parser.parse_known_args(
["--flag", "--unknownflag", "--key=value"], unknown_dest="args")
self.assertListEqual(["--flag", "--unknownflag", "--key=value"],
ns.args)
self.assertListEqual(["--unknownflag"], unknown)
ns, unknown = parser.parse_known_args(
["--flag", "--unknownflag", "a.txt"], unknown_dest="args")
self.assertListEqual(["--flag", "--unknownflag", "a.txt"], ns.args)
self.assertListEqual(["--unknownflag"], unknown)
ns, unknown = parser.parse_known_args(
["--flag", "a.txt", "--unknownflag"], unknown_dest="args")
self.assertListEqual(["--flag", "a.txt", "--unknownflag"], ns.args)
self.assertListEqual(["--unknownflag"], unknown)
ns, unknown = parser.parse_known_args(["--unknown"],
unknown_dest=["args", "extra"])
self.assertListEqual(["--unknown"], ns.args)
self.assertListEqual(["--unknown"], ns.extra)
self.assertListEqual(["--unknown"], unknown)
def test_intermixed_args(self):
parser = ArgumentParserEx()
parser.add_argument("files", action="append")
parser.add_argument("-D", action="append", dest="definitions")
ns = parser.parse_args(["-DA=1", "a.cpp", "-DB=2", "b.cpp"])
# standard ArgumentParser won't append 'b.cpp' here
self.assertListEqual(["a.cpp", "b.cpp"], ns.files)
self.assertListEqual(["A=1", "B=2"], ns.definitions)
def test_disable_concatenation(self):
self.skipTest("not implemented yet")
parser = ArgumentParserEx()
parser.enable_flag_concatenation(False)
parser.add_argument("-a", action="store_true")
parser.add_argument("-b", action="store_true")
ns, remaining = parser.parse_args(["-ab"])
self.assertListEqual(["-ab"], remaining)
def test_strict_parsing(self):
parser = ArgumentParserEx()
parser.add_argument("arg1")
self.assertRaisesRegexp(ValueError, "Required attribute not found",
parser.parse_args, [])
self.assertRaisesRegexp(ValueError, "Unparsed tokens",
parser.parse_args, ["--option"])
ns = parser.parse_args(["val"])
self.assertEqual("val", ns.arg1)
parser = ArgumentParserEx()
parser.add_argument("--arg1", "-a", required=True)
self.assertRaisesRegexp(ValueError, "Required attribute not found",
parser.parse_args, [])
self.assertRaisesRegexp(ValueError, "Unparsed tokens",
parser.parse_args, ["--arg1="])
self.assertRaisesRegexp(ValueError, "Unparsed tokens",
parser.parse_args, ["-a"])
ns = parser.parse_args(["-aval"])
self.assertEqual("val", ns.arg1)
parser = ArgumentParserEx()
parser.add_argument("arg1", nargs=2)
self.assertRaisesRegexp(ValueError, "Required attribute not found",
parser.parse_args, [])
self.assertRaisesRegexp(ValueError, "Not enough values",
parser.parse_args, ["a"])
self.assertRaisesRegexp(ValueError, "Unparsed tokens",
parser.parse_args, ["a", "b", "c"])
ns = parser.parse_args(["a", "b"])
self.assertEqual(["a", "b"], ns.arg1)
parser = ArgumentParserEx()
parser.add_argument("--arg1", "-a", required=True, nargs=2)
self.assertRaisesRegexp(ValueError, "Required attribute not found",
parser.parse_args, [])
self.assertRaisesRegexp(ValueError, "Unparsed tokens",
parser.parse_args, ["--arg1", "val"])
self.assertRaisesRegexp(ValueError, "Unparsed tokens",
parser.parse_args, ["-a", "val"])
ns = parser.parse_args(["--arg1", "a", "b"])
self.assertEqual(["a", "b"], ns.arg1)
def test_concatenate_flags(self):
self.skipTest("not implemented yet")
parser = ArgumentParserEx()
parser.add_argument("-a", action="store_true")
parser.add_argument("-b", action="store_true")
ns = parser.parse_args(["-ab"])
self.assertTrue(ns.a)
self.assertTrue(ns.b)
def test_deepcopy_1(self):
parser = ArgumentParserEx()
parser.add_argument("-a")
parser = deepcopy(parser)
ns = parser.parse_args(["-a", "1"])
self.assertEqual("1", ns.a)
def test_single_hyphen_multichar_flag(self):
parser = ArgumentParserEx()
parser.add_argument("-flag")
ns = parser.parse_args(["-flag", "value"])
self.assertEqual("value", ns.flag)
ns = parser.parse_args(["-flag=value"])
self.assertEqual("value", ns.flag)
def test_action_store_const(self):
parser = ArgumentParserEx()
parser.add_argument("-a", action="store_const", const="a")
ns, remaining = parser.parse_known_args([])
self.assertListEqual([], remaining)
self.assertIsNone(vars(ns).get("a"))
ns, remaining = parser.parse_known_args(["-a"])
self.assertListEqual([], remaining)
self.assertEqual("a", ns.a)
parser = ArgumentParserEx()
parser.add_argument("-a", action="store_const", const="a", default="b")
ns, remaining = parser.parse_known_args([])
self.assertListEqual([], remaining)
self.assertEqual("b", ns.a)
def test_action_default(self):
parser = ArgumentParserEx()
parser.add_argument("attr1")
parser.add_argument("--attr2")
ns, remaining = parser.parse_known_args(["--attr2", "val1", "val2"])
self.assertListEqual([], remaining)
self.assertEqual("val2", ns.attr1)
self.assertEqual("val1", ns.attr2)
def test_msvc_flag_with_value_with_append(self):
parser = ArgumentParserEx(prefix_chars="/-")
parser.set(ignore_case=True)
parser.add_argument("/flag",
action="msvc_flag_with_value",
dest="flags",
append=True)
ns = parser.parse_args(["/flag:a", "/flag:b"])
self.assertListEqual(["a", "b"], ns.flags)
def test_shortening(self):
parser = ArgumentParserEx()
parser.add_argument("--abc")
parser.add_argument("--a")
# standard ArgumentParser will parse --ab as --abc
ns, remaining = parser.parse_known_args(
["--abc", "1", "--ab", "2", "--a", "3"])
self.assertListEqual(["--ab", "2"], remaining)
self.assertEqual("1", ns.abc)
self.assertEqual("3", ns.a)
def test_action_store_false(self):
parser = ArgumentParserEx()
parser.add_argument("-a", action="store_false")
ns, remaining = parser.parse_known_args([])
self.assertListEqual([], remaining)
self.assertTrue(ns.a)
ns, remaining = parser.parse_known_args(["-a"])
self.assertListEqual([], remaining)
self.assertFalse(ns.a)
def test_correct_list_order(self):
parser = ArgumentParserEx(prefix_chars="-/")
parser.set_defaults(definitions=[])
parser.add_argument("/c", action="store_true", dest="compile_only")
parser.add_argument("-D", action="append", dest="definitions")
parser.add_argument("-I", action="append", dest="include_dirs")
parser.add_argument("-U", action="append", dest="definitions")
parser.add_argument("files", nargs="*")
ns = parser.parse_args(
["/c", "-D1", "/U", "2", "/D3", "-I.", "-U4", "a.cpp"])
self.assertListEqual(["1", "2", "3", "4"], ns.definitions)
def __init__(self, context, ignore_compile_flags=None):
CompilerParser.__init__(self,
context,
ignore_compile_flags=ignore_compile_flags)
# NASM arguments
# https://www.nasm.us/doc/nasmdoc2.html#section-2.1
self.parser = ArgumentParserEx()
self.parser.set_defaults(compile_flags=[], include_dirs=[])
# TODO: publish all meaningful flags
self.parser.set(dest=None, raw_dest="compile_flags")
# Define a Macro
self.parser.add_argument("-D",
raw_format=format_flag_gnu,
ignore_case=True)
# Select Debug Information Format
self.parser.add_argument(
"-F",
raw_format=format_flag_gnu,
)
# Output File Format
self.parser.add_argument("-f",
required=True,
raw_format=format_flag_gnu)
# Enabling Debug Information
self.parser.add_argument("-g", action="store_true")
# Include File Search Directories
self.parser.add_argument("-I",
action="append",
dest="include_dirs",
ignore_case=True,
raw_dest=None)
# Assemble and Generate Dependencies
self.parser.add_argument("-MD", raw_dest=None)
# Multipass Optimization
self.parser.add_argument("-O")
# Output File Name
self.parser.add_argument("-o", dest="output", raw_dest=None)
# Pre-Include a File
self.parser.add_argument(
"-P",
"--include",
action="append",
default=[],
dest="preincludes",
raw_dest=None,
)
# Undefine a Macro
self.parser.add_argument("-U",
raw_format=format_flag_gnu,
ignore_case=True)
# Warnings
self.parser.add_argument("-W", "-w")
self.parser.add_argument("infile", dest="infile", raw_dest=None)
def test_action_store_positional(self):
parser = ArgumentParserEx()
parser.add_argument("attr", action="store")
ns, remaining = parser.parse_known_args(["-val"])
self.assertListEqual(["-val"], remaining)
self.assertIsNone(vars(ns).get("attr"))
ns, remaining = parser.parse_known_args(["val"])
self.assertListEqual([], remaining)
self.assertEqual("val", ns.attr)
def test_optional_positional_argument(self):
parser = ArgumentParserEx()
parser.add_argument("infile")
parser.add_argument("outfile", nargs="?")
ns = parser.parse_args(["inout.txt"])
self.assertEqual("inout.txt", ns.infile)
ns = parser.parse_args(["in.txt", "out.txt"])
self.assertEqual("in.txt", ns.infile)
self.assertEqual(["out.txt"], ns.outfile)
def test_no_prefix_chars(self):
parser = ArgumentParserEx()
parser.add_argument("-D", action="append", dest="definitions")
parser.add_argument(
flags=["cmd"],
action="append",
nargs="+",
dest="commands",
args_regexp=re.compile(r"^(?!cmd)"),
)
ns = parser.parse_args(
["-DA=1", "cmd", "cl.exe", "cmd", "gcc", "/c", "a.cpp"])
self.assertListEqual(["A=1"], ns.definitions)
self.assertListEqual([["cl.exe"], ["gcc", "/c", "a.cpp"]], ns.commands)
def test_default_values(self):
parser = ArgumentParserEx()
parser.add_argument("arg1", default="default")
ns = parser.parse_args([])
self.assertEqual("default", ns.arg1)
ns = parser.parse_args(["value"])
self.assertEqual("value", ns.arg1)
parser = ArgumentParserEx()
parser.add_argument("-a", default=[], action="append")
ns = parser.parse_args([])
self.assertEqual([], ns.a)
ns.a.append("value")
ns = parser.parse_args([])
self.assertEqual([], ns.a)
ns = parser.parse_args(["-aval"])
self.assertEqual(["val"], ns.a)
def test_values_starting_with_prefix(self):
# standard ArgumentParser does not accept values starting with prefix_chars
parser = ArgumentParserEx()
parser.add_argument("-Xclang")
ns = parser.parse_args(["-Xclang", "-no-color-output"])
self.assertEqual("-no-color-output", ns.Xclang)
parser = ArgumentParserEx()
parser.add_argument("-f", nargs="2")
ns = parser.parse_args(["-f", "-1", "-2"])
self.assertListEqual(["-1", "-2"], ns.f)
parser = ArgumentParserEx()
parser.add_argument("-f", nargs="2", action="append")
parser.add_argument("--enable", action="store_true")
ns = parser.parse_args(["-f", "-1", "-2"])
self.assertListEqual([["-1", "-2"]], ns.f)
parser.add_argument("-f", nargs="2", action="append")
ns = parser.parse_args(["-f", "-1", "-2", "-f", "-3", "-4"])
self.assertListEqual([["-1", "-2"], ["-3", "-4"]], ns.f)
ns, remaining = parser.parse_known_args(["-f", "-1", "-2", "-f", "-3"])
self.assertListEqual(["-f", "-3"], remaining)
self.assertListEqual([["-1", "-2"]], ns.f)
ns, remaining = parser.parse_known_args(
["-f", "-1", "-2", "-f", "-3", "--enable", "-4"])
self.assertListEqual(["-4"], remaining)
self.assertListEqual([["-1", "-2"], ["-3", "--enable"]], ns.f)
self.assertFalse(ns.enable)
self.assertRaisesRegexp(
ValueError,
"Unparsed tokens",
parser.parse_args,
["-f", "-1", "-2", "-f", "-3"],
)
parser = ArgumentParserEx()
parser.add_argument("f", nargs="*")
ns, remaining = parser.parse_known_args(["-1"])
self.assertListEqual(["-1"], remaining)
ns, remaining = parser.parse_known_args(["1", "2", "-3"])
self.assertListEqual(["-3"], remaining)
self.assertListEqual(["1", "2"], ns.f)
ns, remaining = parser.parse_known_args(["1", "-2", "3"])
self.assertListEqual(["-2"], remaining)
self.assertListEqual(["1", "3"], ns.f)
parser = ArgumentParserEx()
parser.add_argument("f", nargs="+")
ns, remaining = parser.parse_known_args(["-1", "-2"])
self.assertListEqual(["-1", "-2"], remaining)
parser = ArgumentParserEx()
parser.add_argument("-f", nargs="+")
ns, remaining = parser.parse_known_args(["-f", "-1", "-2"])
self.assertListEqual(["-2"], remaining)
self.assertListEqual(["-1"], ns.f)
def test_positionals_do_not_consume_optionals(self):
parser = ArgumentParserEx()
parser.add_argument("positional")
parser.add_argument("-optional", action="store_true")
ns, remaining = parser.parse_known_args(["-optional"])
self.assertListEqual([], remaining)
self.assertTrue(ns.optional)
self.assertIsNone(ns.positional)
parser = ArgumentParserEx()
parser.add_argument("positional", nargs="+")
parser.add_argument("-optional", action="store_true")
ns, remaining = parser.parse_known_args(["-optional"])
self.assertListEqual([], remaining)
self.assertTrue(ns.optional)
self.assertIsNone(ns.positional)
parser = ArgumentParserEx()
parser.add_argument("positional", nargs="*")
parser.add_argument("-optional", action="store_true")
ns, remaining = parser.parse_known_args(["-optional"])
self.assertListEqual([], remaining)
self.assertTrue(ns.optional)
self.assertEqual([], ns.positional)
def test_conditional_arguments(self):
self.skipTest("not implemented yet")
parser = ArgumentParserEx()
arg = parser.add_argument("-a")
parser.add_argument("-b", after=[arg])
ns = parser.parse_args(["-a", "1", "-b", "2"])
self.assertEqual("1", ns.a)
self.assertEqual("2", ns.b)
ns = parser.parse_args(["-a", "1"])
self.assertEqual("1", ns.a)
ns, remaining = parser.parse_known_args(["-b", "1"])
self.assertListEqual(["-b", "1"], remaining)
self.assertIsNone(vars(ns).get("b"))