ArgPullParser

A pull parser for command line arguments.

Notes: The input is given as a string[]. This mostly only matters for ArgTokenType.Text values. This is because the parser does not split up plain text by spaces like a shell would.

e.g. There will be different results between ArgPullParser(["env set OAUTH_SECRET 29ef"]) and ArgPullParser(["env", "set", "OAUTH_SECRET", "29ef"])

The former is given back as a single token containing the entire string. The latter will return 4 tokens, containing the individual strings.

This behaviour is used because this parser is designed to take its input directly from the main function's args, which have already been processed by a shell.

Argument Formats: The following named argument formats are supported.

'-n' - Shorthand with no argument. (returns ArgTokenTypes.ShortHandArgument) '-n ARG' - Shorthand with argument. (ArgTokenTypes.ShortHandArgument and ArgTokenTypes.Text) '-n=ARG' - Shorthand with argument with an equals sign. The equals sign is removed from the token output. (ArgTokenTypes.ShortHandArgument and ArgTokenTypes.Text) '-nARG - Shorthand with argument with no space between them. (ArgTokenTypes.ShortHandArgument and ArgTokenTypes.Text)

'--name' - Longhand with no argument. '--name ARG' - Longhand with argument. '--name=ARG' - Longhand with argument with an equals sign. The equals sign is removed from the token output.

@safe

struct ArgPullParser {

ArgPullParser save();

string[] unparsedArgs [@property getter];

}

Constructors

this this(string[] args)

Members

Functions

empty bool empty()
front ArgToken front()
popFront void popFront(): Parses the next token.
save ArgPullParser save()

Properties

unparsedArgs string[] unparsedArgs [@property getter]

Examples

1 import std.array : array;
2 
3 auto args = 
4 [
5     // Some plain text.
6     "env", "set", 
7 
8     // Long hand named arguments.
9     "--config=MyConfig.json", "--config MyConfig.json",
10 
11     // Short hand named arguments.
12     "-cMyConfig.json", "-c=MyConfig.json", "-c MyConfig.json",
13 
14     // Simple example to prove that you don't need the arg name and value in the same string.
15     "-c", "MyConfig.json",
16 
17     // Plain text.
18     "Some Positional Argument",
19 
20     // Raw Nameless named args
21     "- a", "-", "a",
22     "-- a", "--", "a"
23 ];
24 auto tokens = ArgPullParser(args).array;
25 
26 // import std.stdio;
27 // writeln(tokens);
28 
29 // Plain text.
30 assert(tokens[0]  == ArgToken("env",                         ArgTokenType.Text));
31 assert(tokens[1]  == ArgToken("set",                         ArgTokenType.Text));
32 
33 // Long hand named arguments.
34 assert(tokens[2]  == ArgToken("config",                      ArgTokenType.LongHandArgument));
35 assert(tokens[3]  == ArgToken("MyConfig.json",               ArgTokenType.Text));
36 assert(tokens[4]  == ArgToken("config",                      ArgTokenType.LongHandArgument));
37 assert(tokens[5]  == ArgToken("MyConfig.json",               ArgTokenType.Text));
38 
39 // Short hand named arguments.
40 assert(tokens[6]  == ArgToken("c",                           ArgTokenType.ShortHandArgument));
41 assert(tokens[7]  == ArgToken("MyConfig.json",               ArgTokenType.Text));
42 assert(tokens[8]  == ArgToken("c",                           ArgTokenType.ShortHandArgument));
43 assert(tokens[9]  == ArgToken("MyConfig.json",               ArgTokenType.Text));
44 assert(tokens[10] == ArgToken("c",                           ArgTokenType.ShortHandArgument));
45 assert(tokens[11] == ArgToken("MyConfig.json",               ArgTokenType.Text));
46 assert(tokens[12] == ArgToken("c",                           ArgTokenType.ShortHandArgument));
47 assert(tokens[13] == ArgToken("MyConfig.json",               ArgTokenType.Text));
48 
49 // Plain text.
50 assert(tokens[14] == ArgToken("Some Positional Argument",    ArgTokenType.Text));
51 
52 // Raw Nameless named args.
53 assert(tokens[15] == ArgToken("", ArgTokenType.ShortHandArgument));
54 assert(tokens[16] == ArgToken("a", ArgTokenType.Text));
55 assert(tokens[17] == ArgToken("", ArgTokenType.ShortHandArgument));
56 assert(tokens[18] == ArgToken("a", ArgTokenType.Text));
57 assert(tokens[19] == ArgToken("", ArgTokenType.LongHandArgument));
58 assert(tokens[20] == ArgToken("a", ArgTokenType.Text));
59 assert(tokens[21] == ArgToken("", ArgTokenType.LongHandArgument));
60 assert(tokens[22] == ArgToken("a", ArgTokenType.Text));