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')])