def test_pattern_flat():
assert Required(OneOrMore(Argument('N')),
Option('-a'), Argument('M')).flat() == \
[Argument('N'), Option('-a'), Argument('M')]
assert Required(Optional(OptionsShortcut()),
Optional(Option('-a', None))).flat(OptionsShortcut) == \
[OptionsShortcut()]
def test_pattern_fix_identities_2():
pattern = Required(NotRequired(Argument("X"), Argument("N")),
Argument("N"))
assert pattern.children[0].children[1] == pattern.children[1]
assert pattern.children[0].children[1] is not pattern.children[1]
pattern.fix_identities()
assert pattern.children[0].children[1] is pattern.children[1]
def _addGroupArgumentToDependencies(self, arg, ancestors, optional=False):
# Add mutex choice group arg to dependency tree
# group_arg contains members as dependency arguments
options = arg.children[0].children
p_node = self._getDependencyParentNode(ancestors)
members = [
self._generateDependencyArgument(option) for option in options
]
pretty_names = [member["name"] for member in members]
names = [arg.name for arg in arg.children[0].children]
gdesc = "Group key for mutex choices: {0}".format(" and ".join(names))
for name in [name for name in names if name in self.all_desc_and_type]:
gdesc = gdesc.replace(
name, "{0} ({1})".format(name,
self.all_desc_and_type[name]['desc']))
gname = "<{0}>".format("_".join(pretty_names))
grp_arg = Argument(gname)
grp_arg.parse(gname)
self.all_desc_and_type[gname] = {'desc': gdesc}
self._addArgumentToDependencies(grp_arg,
ancestors=ancestors,
optional=optional,
members=members)
ancestors.append(grp_arg.name)
return ancestors
def test_option_match():
assert Option('-a').match([Option('-a')]) == (True, [], [])
assert Option('-a').match([Option('-x')]) == (False, [Option('-x')], [])
assert Option('-a').match([Argument('N')]) == (False, [Argument('N')], [])
assert Option('-a').match([Option('-x'), Option('-a'), Argument('N')]) == \
(True, [Option('-x'), Argument('N')], [])
assert Option('-a', None, False).match([Option('-a', None, False)]) == \
(True, [], [])
def _loadInputsFromUsage(self, usage):
ancestors = []
for arg in usage.children:
# Traverse usage args and add them to dependencies tree
arg_type = type(arg).__name__
if hasattr(arg, "children"):
fchild_type = type(arg.children[0]).__name__
# Has sub-arguments, maybe recurse into _loadRtrctnsFrmUsg
# but have to deal with children in subtype
if arg_type == "Optional" and fchild_type == "AnyOptions":
for option in arg.children[0].children:
self._addArgumentToDependencies(option,
ancestors=ancestors,
optional=True)
elif arg_type == "OneOrMore":
list_name = "<list_of_{0}>".format(
self._getParamName(arg.children[0].name))
list_arg = Argument(list_name)
list_arg.parse(list_name)
self.all_desc_and_type[list_name] = {
'desc':
"List of {0}".format(
self._getParamName(arg.children[0].name))
}
self._addArgumentToDependencies(list_arg,
ancestors=ancestors,
isList=True)
ancestors.append(list_name)
elif arg_type == "Optional" and fchild_type == "Option":
for option in arg.children:
self._addArgumentToDependencies(option,
ancestors=ancestors,
optional=True)
elif arg_type == "Optional" and fchild_type == "Either":
# Mutex choices group, add group to dependencies tree
# add choices args to group
ancestors = self._addGroupArgumentToDependencies(
arg, ancestors, optional=True)
elif arg_type == "Required" and fchild_type == "Either":
# Mutex choices group, add group to dependencies tree
# add choices args to group
ancestors = self._addGroupArgumentToDependencies(
arg, ancestors)
elif arg_type == "Command":
self._addArgumentToDependencies(arg, ancestors=ancestors)
ancestors.append(arg.name)
elif arg_type == "Argument":
self._addArgumentToDependencies(arg, ancestors=ancestors)
ancestors.append(arg.name)
elif arg_type == "Option":
self._addArgumentToDependencies(arg,
ancestors=ancestors,
optional=True)
ancestors.append(arg.name)
else:
raise_error(
ImportError,
"Non implemented docopt arg.type: {0}".format(arg_type))
def test_optional_match():
assert NotRequired(Option("-a")).match([Option("-a")]) == (True, [], [Option("-a")])
assert NotRequired(Option("-a")).match([]) == (True, [], [])
assert NotRequired(Option("-a")).match([Option("-x")]) == (True, [Option("-x")], [])
assert NotRequired(Option("-a"), Option("-b")).match([Option("-a")]) == (True, [], [Option("-a")])
assert NotRequired(Option("-a"), Option("-b")).match([Option("-b")]) == (True, [], [Option("-b")])
assert NotRequired(Option("-a"), Option("-b")).match([Option("-x")]) == (True, [Option("-x")], [])
assert NotRequired(Argument("N")).match([Argument(None, 9)]) == (True, [], [Argument("N", 9)])
assert NotRequired(Option("-a"), Option("-b")).match([Option("-b"), Option("-x"), Option("-a")]) == (True, [Option("-x")], [Option("-a"), Option("-b")])
def test_command_match():
assert Command('c').match([Argument(None, 'c')]) == (
True, [], [Command('c', True)])
assert Command('c').match([Option('-x')]) == (False, [Option('-x')], [])
assert Command('c').match([Option('-x'), Option('-a'),
Argument(None, 'c')]) == (
True, [Option('-x'), Option('-a')], [Command('c', True)])
assert Either(Command('add', False), Command('rm', False)).match(
[Argument(None, 'rm')]) == (True, [], [Command('rm', True)])
def test_pattern_fix_repeating_arguments():
assert Option('-a').fix_repeating_arguments() == Option('-a')
assert Argument('N', None).fix_repeating_arguments() == Argument('N', None)
assert Required(Argument('N'),
Argument('N')).fix_repeating_arguments() == \
Required(Argument('N', []), Argument('N', []))
assert Either(Argument('N'),
OneOrMore(Argument('N'))).fix() == \
Either(Argument('N', []), OneOrMore(Argument('N', [])))
def test_pattern_fix_repeating_arguments():
assert Required(Option("-a")).fix_repeating_arguments() == Required(
Option("-a"))
assert Required(Argument("N", None)).fix_repeating_arguments() == Required(
Argument("N", None))
assert Required(Argument("N"),
Argument("N")).fix_repeating_arguments() == Required(
Argument("N", []), Argument("N", []))
assert Either(Argument("N"), OneOrMore(Argument("N"))).fix() == Either(
Argument("N", []), OneOrMore(Argument("N", [])))
def test_pattern_flat():
assert Required(
OneOrMore(Argument("N")), Option("-a"),
Argument("M")).flat() == [Argument("N"),
Option("-a"),
Argument("M")]
assert Required(NotRequired(OptionsShortcut()),
NotRequired(Option("-a", None))).flat(OptionsShortcut) == [
OptionsShortcut()
]
def test_pattern_either():
assert transform(Option("-a")) == Either(Required(Option("-a")))
assert transform(Argument("A")) == Either(Required(Argument("A")))
assert transform(Required(Either(Option("-a"), Option("-b")), Option("-c"))) == Either(
Required(Option("-a"), Option("-c")), Required(Option("-b"), Option("-c"))
)
assert transform(NotRequired(Option("-a"), Either(Option("-b"), Option("-c")))) == Either(
Required(Option("-b"), Option("-a")), Required(Option("-c"), Option("-a"))
)
assert transform(Either(Option("-x"), Either(Option("-y"), Option("-z")))) == Either(Required(Option("-x")), Required(Option("-y")), Required(Option("-z")))
assert transform(OneOrMore(Argument("N"), Argument("M"))) == Either(Required(Argument("N"), Argument("M"), Argument("N"), Argument("M")))
def test_command_match():
assert Command("c").match([Argument(None, "c")]) == (True, [],
[Command("c", True)])
assert Command("c").match([Option("-x")]) == (False, [Option("-x")], [])
assert Command("c").match(
[Option("-x"), Option("-a"),
Argument(None, "c")]) == (True, [Option("-x"),
Option("-a")], [Command("c", True)])
assert Either(Command("add", False),
Command("rm", False)).match([Argument(None, "rm")
]) == (True, [],
[Command("rm", True)])
def test_option_match():
assert Option("-a").match([Option("-a", value=True)
]) == (True, [], [Option("-a", value=True)])
assert Option("-a").match([Option("-x")]) == (False, [Option("-x")], [])
assert Option("-a").match([Argument("N")]) == (False, [Argument("N")], [])
assert Option("-a").match([Option("-x"),
Option("-a"),
Argument("N")
]) == (True, [Option("-x"),
Argument("N")], [Option("-a")])
assert Option("-a").match([Option("-a", value=True),
Option("-a")]) == (True, [Option("-a")],
[Option("-a", value=True)])
def test_optional_match():
assert Optional(Option('-a')).match([Option('-a')]) == (True, [], [])
assert Optional(Option('-a')).match([]) == (True, [], [])
assert Optional(Option('-a')).match([Option('-x')]) == (
True, [Option('-x')], [])
assert Optional(Option('-a'), Option('-b')).match([Option('-a')]) == (
True, [], [])
assert Optional(Option('-a'), Option('-b')).match([Option('-b')]) == (
True, [], [])
assert Optional(Option('-a'), Option('-b')).match([Option('-x')]) == (
True, [Option('-x')], [])
assert Optional(Argument('N')).match([Argument(None, 9)]) == (
True, [], [Argument('N', 9)])
def test_parse_argv():
o = [Option("-h"), Option("-v", "--verbose"), Option("-f", "--file", 1)]
TS = lambda s: Tokens(s, error=DocoptExit)
assert parse_argv(TS(""), options=o) == []
assert parse_argv(TS("-h"), options=o) == [Option("-h", None, 0, True)]
assert parse_argv(TS("-h --verbose"), options=o) == [Option("-h", None, 0, True), Option("-v", "--verbose", 0, True)]
assert parse_argv(TS("-h --file f.txt"), options=o) == [Option("-h", None, 0, True), Option("-f", "--file", 1, "f.txt")]
assert parse_argv(TS("-h --file f.txt arg"), options=o) == [Option("-h", None, 0, True), Option("-f", "--file", 1, "f.txt"), Argument(None, "arg")]
assert parse_argv(TS("-h --file f.txt arg arg2"), options=o) == [
Option("-h", None, 0, True),
Option("-f", "--file", 1, "f.txt"),
Argument(None, "arg"),
Argument(None, "arg2"),
]
assert parse_argv(TS("-h arg -- -v"), options=o) == [Option("-h", None, 0, True), Argument(None, "arg"), Argument(None, "--"), Argument(None, "-v")]
def loadDescriptionAndType(self):
# using docopt code to extract description and type from args
for line in (self._parse_section('arguments:', self.docopt_str) +
self._parse_section('options:', self.docopt_str)):
_, _, s = line.partition(':') # get rid of "options:"
split = re.split(r'\n[ \t]*(-\S+?)', '\n' + s)[1:] if\
line in self._parse_section('options:', self.docopt_str) else\
re.split(r'\n[ \t]*(<\S+?)', '\n' + s)[1:]
split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])]
# parse each line of Arguments and Options
for arg_str in [
s for s in split
if (s.startswith('-') or s.startswith('<'))
]:
arg = Option.parse(arg_str) if arg_str.startswith('-')\
else Argument.parse(arg_str)
arg_segs = arg_str.partition(' ')
# Add desc and type to all_desc_and_type
# key is initial id/name
self.all_desc_and_type[arg.name] = {
"desc":
arg_segs[-1].replace('\n', ' ').replace(" ", '').strip()
}
if hasattr(arg, "value") and arg.value is not None and\
arg.value is not False:
self.all_desc_and_type[arg.name]['default-value'] =\
arg.value
if type(arg) is Option and arg.argcount > 0:
for typ in [
seg
for seg in arg_segs[0].replace(',', ' ').replace(
'=', ' ').split() if seg[0] != "-"
]:
self.all_desc_and_type[arg.name]["type"] = typ
def test_basic_pattern_matching():
# ( -a N [ -x Z ] )
pattern = Required(Option("-a"), Argument("N"), NotRequired(Option("-x"), Argument("Z")))
# -a N
assert pattern.match([Option("-a"), Argument(None, 9)]) == (True, [], [Option("-a"), Argument("N", 9)])
# -a -x N Z
assert pattern.match([Option("-a"), Option("-x"), Argument(None, 9), Argument(None, 5)]) == (
True,
[],
[Option("-a"), Argument("N", 9), Option("-x"), Argument("Z", 5)],
)
# -x N Z # BZZ!
assert pattern.match([Option("-x"), Argument(None, 9), Argument(None, 5)]) == (False, [Option("-x"), Argument(None, 9), Argument(None, 5)], [])
def test_parse_pattern():
o = [Option("-h"), Option("-v", "--verbose"), Option("-f", "--file", 1)]
assert parse_pattern("[ -h ]", options=o) == Required(NotRequired(Option("-h")))
assert parse_pattern("[ ARG ... ]", options=o) == Required(NotRequired(OneOrMore(Argument("ARG"))))
assert parse_pattern("[ -h | -v ]", options=o) == Required(NotRequired(Either(Option("-h"), Option("-v", "--verbose"))))
assert parse_pattern("( -h | -v [ --file <f> ] )", options=o) == Required(
Required(Either(Option("-h"), Required(Option("-v", "--verbose"), NotRequired(Option("-f", "--file", 1, None)))))
)
assert parse_pattern("(-h|-v[--file=<f>]N...)", options=o) == Required(
Required(Either(Option("-h"), Required(Option("-v", "--verbose"), NotRequired(Option("-f", "--file", 1, None)), OneOrMore(Argument("N")))))
)
assert parse_pattern("(N [M | (K | L)] | O P)", options=[]) == Required(
Required(
Either(
Required(Argument("N"), NotRequired(Either(Argument("M"), Required(Either(Argument("K"), Argument("L")))))),
Required(Argument("O"), Argument("P")),
)
)
)
assert parse_pattern("[ -h ] [N]", options=o) == Required(NotRequired(Option("-h")), NotRequired(Argument("N")))
assert parse_pattern("[options]", options=o) == Required(NotRequired(OptionsShortcut()))
assert parse_pattern("[options] A", options=o) == Required(NotRequired(OptionsShortcut()), Argument("A"))
assert parse_pattern("-v [options]", options=o) == Required(Option("-v", "--verbose"), NotRequired(OptionsShortcut()))
assert parse_pattern("ADD", options=o) == Required(Argument("ADD"))
assert parse_pattern("<add>", options=o) == Required(Argument("<add>"))
assert parse_pattern("add", options=o) == Required(Command("add"))
def test_pattern_any_option():
assert AnyOptions().match([Option('-a')]) == (True, [], [])
assert AnyOptions().match([Option('-b')]) == (True, [], [])
assert AnyOptions().match([Option('-l', '--long')]) == (True, [], [])
assert AnyOptions().match([Option(None, '--long')]) == (True, [], [])
assert AnyOptions().match([Option('-a'), Option('-b')]) == (True, [], [])
assert AnyOptions().match([Option('-a'),
Option(None, '-long')]) == (True, [], [])
assert not AnyOptions().match([Argument('N')])[0]
def test_docopt_ng_more_magic_spellcheck_and_expansion():
o = [Option("-h"), Option("-v", "--verbose"), Option(None, "--file", 1)]
TS = lambda s: Tokens(s, error=DocoptExit)
assert parse_argv(TS(""), options=o) == []
assert parse_argv(TS("-h"), options=o) == [Option("-h", None, 0, True)]
assert parse_argv(TS("-h --File f.txt"), options=o, more_magic=True) == [
Option("-h", None, 0, True),
Option(None, "--file", 1, "f.txt")
]
assert parse_argv(TS("-h --fiLe f.txt arg"), options=o,
more_magic=True) == [
Option("-h", None, 0, True),
Option(None, "--file", 1, "f.txt"),
Argument(None, "arg"),
]
assert parse_argv(TS("-h -f f.txt arg arg2"), options=o,
more_magic=True) == [
Option("-h", None, 0, True),
Option(None, "--file", 1, "f.txt"),
Argument(None, "arg"),
Argument(None, "arg2"),
]
def test_pattern_either():
assert Option('-a').either == Either(Required(Option('-a')))
assert Argument('A').either == Either(Required(Argument('A')))
assert Required(Either(Option('-a'), Option('-b')), Option('-c')).either ==\
Either(Required(Option('-a'), Option('-c')),
Required(Option('-b'), Option('-c')))
assert Optional(Option('-a'), Either(Option('-b'), Option('-c'))).either ==\
Either(Required(Option('-b'), Option('-a')),
Required(Option('-c'), Option('-a')))
assert Either(Option('-x'), Either(Option('-y'), Option('-z'))).either == \
Either(Required(Option('-x')),
Required(Option('-y')),
Required(Option('-z')))
assert OneOrMore(Argument('N'), Argument('M')).either == \
Either(Required(Argument('N'), Argument('M'),
Argument('N'), Argument('M')))
def test_either_match():
assert Either(Option('-a'), Option('-b')).match(
[Option('-a')]) == (True, [], [])
assert Either(Option('-a'), Option('-b')).match(
[Option('-a'), Option('-b')]) == (True, [Option('-b')], [])
assert Either(Option('-a'), Option('-b')).match(
[Option('-x')]) == (False, [Option('-x')], [])
assert Either(Option('-a'), Option('-b'), Option('-c')).match(
[Option('-x'), Option('-b')]) == (True, [Option('-x')], [])
assert Either(Argument('M'),
Required(Argument('N'), Argument('M'))).match(
[Argument(None, 1), Argument(None, 2)]) == \
(True, [], [Argument('N', 1), Argument('M', 2)])
def test_either_match():
assert Either(Option("-a"), Option("-b")).match([Option("-a")]) == (True, [], [Option("-a")])
assert Either(Option("-a"), Option("-b")).match([Option("-a"), Option("-b")]) == (True, [Option("-b")], [Option("-a")])
assert Either(Option("-a"), Option("-b")).match([Option("-x")]) == (False, [Option("-x")], [])
assert Either(Option("-a"), Option("-b"), Option("-c")).match([Option("-x"), Option("-b")]) == (True, [Option("-x")], [Option("-b")])
assert Either(Argument("M"), Required(Argument("N"), Argument("M"))).match([Argument(None, 1), Argument(None, 2)]) == (
True,
[],
[Argument("N", 1), Argument("M", 2)],
)
def test_pattern_either():
assert transform(Option('-a')) == Either(Required(Option('-a')))
assert transform(Argument('A')) == Either(Required(Argument('A')))
assert transform(Required(Either(Option('-a'), Option('-b')),
Option('-c'))) == \
Either(Required(Option('-a'), Option('-c')),
Required(Option('-b'), Option('-c')))
assert transform(Optional(Option('-a'), Either(Option('-b'),
Option('-c')))) == \
Either(Required(Option('-b'), Option('-a')),
Required(Option('-c'), Option('-a')))
assert transform(Either(Option('-x'),
Either(Option('-y'), Option('-z')))) == \
Either(Required(Option('-x')),
Required(Option('-y')),
Required(Option('-z')))
assert transform(OneOrMore(Argument('N'), Argument('M'))) == \
Either(Required(Argument('N'), Argument('M'),
Argument('N'), Argument('M')))
def test_parse_args():
o = [Option('-h'), Option('-v', '--verbose'), Option('-f', '--file', 1)]
assert parse_args('', options=o) == []
assert parse_args('-h', options=o) == [Option('-h', None, 0, True)]
assert parse_args('-h --verbose', options=o) == \
[Option('-h', None, 0, True), Option('-v', '--verbose', 0, True)]
assert parse_args('-h --file f.txt', options=o) == \
[Option('-h', None, 0, True), Option('-f', '--file', 1, 'f.txt')]
assert parse_args('-h --file f.txt arg', options=o) == \
[Option('-h', None, 0, True),
Option('-f', '--file', 1, 'f.txt'),
Argument(None, 'arg')]
assert parse_args('-h --file f.txt arg arg2', options=o) == \
[Option('-h', None, 0, True),
Option('-f', '--file', 1, 'f.txt'),
Argument(None, 'arg'),
Argument(None, 'arg2')]
assert parse_args('-h arg -- -v', options=o) == \
[Option('-h', None, 0, True),
Argument(None, 'arg'),
Argument(None, '--'),
Argument(None, '-v')]
def test_parse_argv():
o = [Option('-h'), Option('-v', '--verbose'), Option('-f', '--file', 1)]
TS = lambda s: Tokens(s, error=DocoptExit)
assert parse_argv(TS(''), options=o) == []
assert parse_argv(TS('-h'), options=o) == [Option('-h', None, 0, True)]
assert parse_argv(TS('-h --verbose'), options=o) == \
[Option('-h', None, 0, True), Option('-v', '--verbose', 0, True)]
assert parse_argv(TS('-h --file f.txt'), options=o) == \
[Option('-h', None, 0, True), Option('-f', '--file', 1, 'f.txt')]
assert parse_argv(TS('-h --file f.txt arg'), options=o) == \
[Option('-h', None, 0, True),
Option('-f', '--file', 1, 'f.txt'),
Argument(None, 'arg')]
assert parse_argv(TS('-h --file f.txt arg arg2'), options=o) == \
[Option('-h', None, 0, True),
Option('-f', '--file', 1, 'f.txt'),
Argument(None, 'arg'),
Argument(None, 'arg2')]
assert parse_argv(TS('-h arg -- -v'), options=o) == \
[Option('-h', None, 0, True),
Argument(None, 'arg'),
Argument(None, '--'),
Argument(None, '-v')]
def test_basic_pattern_matching():
# ( -a N [ -x Z ] )
pattern = Required(Option('-a'), Argument('N'),
Optional(Option('-x'), Argument('Z')))
# -a N
assert pattern.match([Option('-a'), Argument(None, 9)]) == \
(True, [], [Option('-a'), Argument('N', 9)])
# -a -x N Z
assert pattern.match([Option('-a'), Option('-x'),
Argument(None, 9), Argument(None, 5)]) == \
(True, [], [Option('-a'), Argument('N', 9),
Option('-x'), Argument('Z', 5)])
# -x N Z # BZZ!
assert pattern.match([Option('-x'),
Argument(None, 9),
Argument(None, 5)]) == \
(False, [Option('-x'), Argument(None, 9), Argument(None, 5)], [])
def test_pattern_fix_identities_2():
pattern = Required(Optional(Argument('X'), Argument('N')), Argument('N'))
assert pattern.children[0].children[1] == pattern.children[1]
assert pattern.children[0].children[1] is not pattern.children[1]
pattern.fix_identities()
assert pattern.children[0].children[1] is pattern.children[1]
def test_pattern_fix_identities_1():
pattern = Required(Argument('N'), Argument('N'))
assert pattern.children[0] == pattern.children[1]
assert pattern.children[0] is not pattern.children[1]
pattern.fix_identities()
assert pattern.children[0] is pattern.children[1]
def test_set():
assert Argument('N') == Argument('N')
assert set([Argument('N'), Argument('N')]) == set([Argument('N')])
