Switch from clap to yazap

This is compatible with the latest 0.16.0 nightly build.
It is also a bit less magic than clap.

2 files changed, 65 insertions, 57 deletions

diff --git a/src/main.zig b/src/main.zig
index ea188fb..367cb62 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1,67 +1,68 @@
 const std = @import("std");
 const zits = @import("zits");
-const clap = @import("clap");
+const yazap = @import("yazap");
 
 const Message = zits.MessageParser.Message;
 const Server = zits.Server;
 
-const SubCommands = enum {
-    help,
-    serve,
-    @"pub",
-};
-
-const main_parsers = .{
-    .command = clap.parsers.enumeration(SubCommands),
-};
-
-// The parameters for `main`. Parameters for the subcommands are specified further down.
-const main_params = clap.parseParamsComptime(
-    \\-h, --help  Display this help and exit.
-    \\<command>
-    \\
-);
-
-// To pass around arguments returned by clap, `clap.Result` and `clap.ResultEx` can be used to
-// get the return type of `clap.parse` and `clap.parseEx`.
-pub const MainArgs = clap.ResultEx(clap.Help, &main_params, main_parsers);
-
 pub fn main() !void {
     var dba: std.heap.DebugAllocator(.{}) = .init;
     defer _ = dba.deinit();
     const gpa = dba.allocator();
 
-    var iter = try std.process.ArgIterator.initWithAllocator(gpa);
-    defer iter.deinit();
-
-    _ = iter.next();
-
-    var diag = clap.Diagnostic{};
-    var res = clap.parseEx(clap.Help, &main_params, main_parsers, &iter, .{
-        .diagnostic = &diag,
-        .allocator = gpa,
-
-        // Terminate the parsing of arguments after parsing the first positional (0 is passed
-        // here because parsed positionals are, like slices and arrays, indexed starting at 0).
-        //
-        // This will terminate the parsing after parsing the subcommand enum and leave `iter`
-        // not fully consumed. It can then be reused to parse the arguments for subcommands.
-        .terminating_positional = 0,
-    }) catch |err| {
-        try diag.reportToFile(.stderr(), err);
-        return err;
-    };
-    defer res.deinit();
-    std.debug.print("res: {any}\n", .{res});
-
-    if (res.args.help != 0)
-        return clap.helpToFile(.stderr(), clap.Help, &main_params, .{});
-
-    const command = res.positionals[0] orelse return error.MissingCommand;
-    switch (command) {
-        .help => return clap.helpToFile(.stderr(), clap.Help, &main_params, .{}),
-        .serve => try Server.main(gpa, &iter, res),
-        .@"pub" => unreachable,
+    var app = yazap.App.init(gpa, "zits", "High performance NATS compatible client and server.");
+    defer app.deinit();
+
+    var zits_app = app.rootCommand();
+
+    var server_cmd = app.createCommand("serve", "Run a high performance NATS compatible server.");
+    try server_cmd.addArgs(&[_]yazap.Arg{
+        yazap.Arg.singleValueOption(
+            "addr",
+            'a',
+            std.fmt.comptimePrint(
+                "Address to bind to (default: {s})",
+                .{std.meta.fieldInfo(zits.Server.ServerInfo, .host).defaultValue().?},
+            ),
+        ),
+        yazap.Arg.singleValueOption(
+            "port",
+            'p',
+            std.fmt.comptimePrint(
+                "Port to listen on (default: {d})",
+                .{std.meta.fieldInfo(zits.Server.ServerInfo, .port).defaultValue().?},
+            ),
+        ),
+        yazap.Arg.singleValueOption(
+            "name",
+            'n',
+            "Server name (default: auto)",
+        ),
+    });
+    try zits_app.addSubcommand(server_cmd);
+
+    const pub_cmd = app.createCommand("pub", "Publish a message.");
+    try zits_app.addSubcommand(pub_cmd);
+
+    const matches = try app.parseProcess();
+
+    if (matches.subcommandMatches("serve")) |serve_matches| {
+        var info: zits.Server.ServerInfo = .{
+            .server_id = zits.Server.createId(),
+            .server_name = zits.Server.createName(),
+            .version = "zits-master",
+            .max_payload = 99999,
+        };
+        if (serve_matches.getSingleValue("port")) |port| {
+            info.port = std.fmt.parseUnsigned(@TypeOf(info.port), port, 10) catch |err| std.process.fatal("Could not parse port ({s}): {}\n", .{ port, err });
+        }
+
+        if (serve_matches.getSingleValue("name")) |name| {
+            info.server_name = name;
+        }
+
+        try Server.main(gpa, info);
+        return;
     }
 }
 
diff --git a/src/server/main.zig b/src/server/main.zig
index e0058a7..b26f4b0 100644
--- a/src/server/main.zig
+++ b/src/server/main.zig
@@ -3,7 +3,7 @@ const Message = @import("./message_parser.zig");
 
 const ClientState = @import("./client.zig");
 
-const ServerInfo = struct {
+pub const ServerInfo = struct {
     /// The unique identifier of the NATS server.
     server_id: []const u8,
     /// The name of the NATS server.
@@ -18,7 +18,7 @@ const ServerInfo = struct {
     host: []const u8 = "0.0.0.0",
     /// The port number the NATS server is configured
     /// to listen on.
-    port: u16 = 6868,
+    port: u16 = 4222,
     /// Whether the server supports headers.
     headers: bool = false,
     /// Maximum payload size, in bytes, that the server
@@ -36,9 +36,8 @@ clients: std.AutoHashMapUnmanaged(u64, ClientState) = .empty,
 /// Map of subjects to client IDs that are subscribed to that subject.
 subscriptions: std.StringHashMapUnmanaged(std.ArrayList(u64)),
 
-pub fn main(gpa: std.mem.Allocator, iter: *std.process.ArgIterator, main_args: anytype) !void {
+pub fn main(gpa: std.mem.Allocator, main_args: anytype) !void {
     _ = gpa;
-    _ = iter;
     _ = main_args;
 }
 
@@ -107,3 +106,11 @@ fn writeInfo(out: *std.Io.Writer, info: ServerInfo) !void {
     _ = try out.write("\r\n");
     try out.flush();
 }
+
+pub fn createId() []const u8 {
+    return "SERVERID";
+}
+
+pub fn createName() []const u8 {
+    return "SERVERNAME";
+}