⚡ finish argparse module

std/argparse.nas

@@ -1,3 +1,7 @@
+# argparse.nas
+# 2023/12/7 by ValKmjolnir
+
+use std.padding;
 
 var new = func(description) {
     var _arg = globals.arg;
@@ -5,8 +9,8 @@ var new = func(description) {
         description: description,
         subparser: [],
         command_list: [],
-        add_command: func(long, short, help) {
+        add_command: func(long, short, help, need_arg = false, need_nargs = false) {
-            return _add_command(parser, long, short, help);
+            return _add_command(parser, long, short, help, need_arg, need_nargs);
         },
         add_subparser: func(name, help) {
             return _add_subparser(parser, name, help);
@@ -26,8 +30,8 @@ var _new_sub_parser = func(description) {
         description: description,
         subparser: [],
         command_list: [],
-        add_command: func(long, short, help) {
+        add_command: func(long, short, help, need_arg = false, need_nargs = false) {
-            return _add_command(parser, long, short, help);
+            return _add_command(parser, long, short, help, need_arg, need_nargs);
         },
         add_subparser: func(name, help) {
             return _add_subparser(parser, name, help);
@@ -41,34 +45,67 @@ var _help = func(parser) {
     println(parser.description, "\n");
     if (size(parser.subparser)>0) {
         println("Subcommand:");
+        var max_pad_length = 0;
+        var info_pairs = [];
         foreach(var cmd; parser.subparser) {
-            println("  ", cmd.name, "\t", cmd.parser.description);
+            var info = "  "~cmd.name;
+            append(info_pairs, {info: info, help: cmd.parser.description});
+            info_length = size(info);
+            max_pad_length = max_pad_length>info_length? max_pad_length:info_length;
+        }
+        foreach(var pair; info_pairs) {
+            println(padding.rightpad(pair.info, max_pad_length), "    ", pair.help);
         }
         println();
     }
     if (size(parser.command_list)>0) {
         println("Options:");
+        var max_pad_length = 0;
+        var info_pairs = [];
         foreach(var cmd; parser.command_list) {
-            println("  ", cmd.full_name, " ", cmd.short_name, "\t", cmd.help);
+            if (cmd.need_nargs) {
+                var info = "  "~cmd.full_name~" [args...] "~cmd.short_name~" [args...]";
+                append(info_pairs, {info: info, help: cmd.help});
+            } elsif (cmd.need_arg) {
+                var info = "  "~cmd.full_name~" arg "~cmd.short_name~" arg";
+                append(info_pairs, {info: info, help: cmd.help});
+            } else {
+                var info = "  "~cmd.full_name~" "~cmd.short_name;
+                append(info_pairs, {info: info, help: cmd.help});
+            }
+            var info_length = size(info);
+            max_pad_length = max_pad_length>info_length? max_pad_length:info_length;
+        }
+        foreach(var pair; info_pairs) {
+            println(padding.rightpad(pair.info, max_pad_length), "    ", pair.help);
         }
     }
 }
 
+var _in_list = func(arginfo, command_list) {
+    foreach(var cmd; command_list) {
+        if (arginfo==cmd.full_name or arginfo==cmd.short_name) {
+            return true;
+        }
+    }
+    return false;
+}
+
 var _parse = func(parser, args, result_hash) {
     if (size(args)==0) {
         println("Require more command, use \"--help\" to get help.\n");
         _help(parser);
         exit(0);
     }
-    var first_arg = args[0];
     foreach(var subparser; parser.subparser) {
-        if (subparser.name==first_arg) {
+        if (subparser.name==args[0]) {
             result_hash[subparser.name] = true;
             _parse(subparser.parser, size(args)>1? args[1:]:[], result_hash);
             return;
         }
     }
-    foreach(var this_arg; args) {
+    for(var i = 0; i<size(args); i += 1) {
+        var this_arg = args[i];
         var find_command_flag = false;
         foreach(var cmd; parser.command_list) {
             if (this_arg=="--help" or this_arg=="-h") {
@@ -76,8 +113,33 @@ var _parse = func(parser, args, result_hash) {
                 exit(0);
             }
             if (this_arg==cmd.full_name or this_arg==cmd.short_name) {
-                result_hash[cmd.full_name] = true;
                 find_command_flag = true;
+                if (cmd.need_nargs) {
+                    i += 1;
+                    var args_collect = [];
+                    while (i<size(args) and !_in_list(args[i], parser.command_list)) {
+                        append(args_collect, args[i]);
+                        i += 1;
+                    }
+                    i -= 1;
+                    if (!size(args_collect)) {
+                        println("Require argument(s) after command `", this_arg, "`.\n");
+                        _help(parser);
+                        exit(0);
+                    }
+                    result_hash[cmd.full_name] = args_collect;
+                } elsif (cmd.need_arg) {
+                    i += 1;
+                    if (i<size(args) and !_in_list(args[i], parser.command_list)) {
+                        result_hash[cmd.full_name] = args[i];
+                    } else {
+                        println("Require argument after command `", this_arg, "`.\n");
+                        _help(parser);
+                        exit(0);
+                    }
+                } else {
+                    result_hash[cmd.full_name] = true;
+                }
             }
         }
         if (!find_command_flag) {
@@ -86,17 +148,16 @@ var _parse = func(parser, args, result_hash) {
             exit(0);
         }
     }
-    # unreachable
+    return;
-    println("Invalid command `", first_arg, "`.\n");
-    _help(parser);
-    exit(0);
 }
 
-var _add_command = func(parser, long, short, help) {
+var _add_command = func(parser, long, short, help, need_arg , need_nargs) {
     var new_command = {
         full_name: long,
         short_name: short,
-        help: help
+        help: help,
+        need_arg: need_arg,
+        need_nargs: need_nargs
     };
     append(parser.command_list, new_command);
 }

std/padding.nas

@@ -1,24 +1,24 @@
 # padding.nas
 # ValKmjolnir 2022/9/4
 
-var leftpad = func(s, len, char=" ") {
+var leftpad = func(input_string, length, char=" ") {
-    if (typeof(s)=="num") {
+    if (typeof(input_string)=="num") {
-        s = str(s);
+        input_string = str(input_string);
     }
-    var strlen = size(s);
+    var strlen = size(input_string);
-    for(var i = strlen; i<len; i += 1) {
+    for(var i = strlen; i<length; i += 1) {
-        s = char~s;
+        input_string = char~input_string;
     }
-    return s;
+    return input_string;
 }
 
-var rightpad = func(s, len, char=" ") {
+var rightpad = func(input_string, length, char=" ") {
-    if (typeof(s)=="num") {
+    if (typeof(input_string)=="num") {
-        s = str(s);
+        input_string = str(input_string);
     }
-    var strlen = size(s);
+    var strlen = size(input_string);
-    for(var i = strlen; i<len; i += 1) {
+    for(var i = strlen; i<length; i += 1) {
-        s ~= char;
+        input_string ~= char;
     }
-    return s;
+    return input_string;
 }

test/argparse_test.nas

@@ -1,12 +1,39 @@
 use std.argparse;
 
+var test_cli = func(args) {
+    globals.arg = args;
     var args = argparse.new("Nasal ArgParse Test CLI");
-args.add_command("--what", "-wa", "what-command");
+    args.add_command(long: "--what", short: "-wa", help: "What-command");
-args.add_command("--who", "-wo", "who-command");
+    args.add_command(long: "--who", short: "-wo", help: "Who-command");
-args.add_command("--where", "-we", "where-command");
+    args.add_command(long: "--where", short: "-we", help: "Where-command");
-var subparser0 = args.add_subparser("subcommand0", "Nasal ArgParse Test CLI Sub-command 0");
+    args.add_command(long: "--test_arg", short: "-ta", help: "Test-single-arg", need_arg: true);
-subparser0.add_command("--sub0-what", "-s0w", "sub0-what-command");
+    args.add_command(long: "--test_args", short: "-tas", help: "Test-multiple-args", need_nargs: true);
-var subparser1 = args.add_subparser("subcommand1", "Nasal ArgParse Test CLI Sub-command 1");
+    var subparser0 = args.add_subparser(name: "subcommand0", help: "Nasal ArgParse Test CLI Sub-Command 0");
-subparser1.add_command("--sub1-what", "-s1w", "sub1-what-command");
+    subparser0.add_command(long: "--sub0-what", short: "-s0w", help: "Sub0-what-command");
+    subparser0.add_command(long: "--test_arg", short: "-ta", help: "Test-single-arg", need_arg: true);
+    subparser0.add_command(long: "--test_args", short: "-tas", help: "Test-multiple-args", need_nargs: true);
+    var subparser1 = args.add_subparser(name: "subcommand1", help: "Nasal ArgParse Test CLI Sub-Command 1");
+    subparser1.add_command(long: "--sub1-what", short: "-s1w", help: "Sub1-what-command");
+    subparser1.add_command(long: "--test_arg", short: "-ta", help: "Test-single-arg", need_arg: true);
+    subparser1.add_command(long: "--test_args", short: "-tas", help: "Test-multiple-args", need_nargs: true);
+    var subparser_test = args.add_subparser(name: "subtest", help: "Test Subcommand");
     var result = args.parse_args();
     println(result);
+}
+
+# should cause error or exit
+# test_cli(["--help"]);
+# test_cli(["subtest"]);
+# test_cli(["--test_args", "--what", "--who", "--where"]);
+# test_cli(["--test_arg", "a", "b", "--what", "--who", "--where"]);
+
+# should be correct
+test_cli(["--test_arg", "a", "--what", "--who", "--where"]);
+test_cli(["--test_args", "a", "--what", "--who", "--where"]);
+test_cli(["--test_args", "a", "b", "c", "--what", "--who", "--where"]);
+test_cli(["subcommand0", "--test_arg", "a", "-s0w"]);
+test_cli(["subcommand0", "--test_args", "a", "-s0w"]);
+test_cli(["subcommand0", "--test_args", "a", "b", "c", "-s0w"]);
+test_cli(["subcommand1", "--test_arg", "a", "-s1w"]);
+test_cli(["subcommand1", "--test_args", "a", "-s1w"]);
+test_cli(["subcommand1", "--test_args", "a", "b", "c", "-s1w"]);