unix2db: first stab at flag parsing

src/unix2db/main.zig

@@ -1,10 +1,85 @@
 const std = @import("std");
-const flags = @import("../flags.zig");
+const fs = std.fs;
+const io = std.io;
+const mem = std.mem;
+const os = std.os;
+const ArrayList = std.ArrayList;
+const Allocator = std.mem.Allocator;
+const GeneralPurposeAllocator = std.heap.GeneralPurposeAllocator;
 
-pub fn main() !void {}
+const flags = @import("../flags.zig");
+const User = @import("../User.zig");
+
+const usage =
+    \\usage: turbonss-unix2db [options]
+    \\
+    \\  -h          Print this help message and exit
+    \\  --passwd    Path to passwd file (default: ./passwd)
+    \\  --group     Path to group file (default: ./group)
+    \\
+;
+
+pub fn main() !void {
+    // This line is here because of https://github.com/ziglang/zig/issues/7807
+    const argv: []const [*:0]const u8 = os.argv;
+    const gpa = GeneralPurposeAllocator(.{});
+
+    const return_code = execute(gpa, argv[1..]) catch |err| {
+        try io.getStdErr().writeAll("uncaught error: {s}\n", @intToError(err));
+        os.exit(1);
+    };
+
+    os.exit(return_code);
+}
+
+fn execute(
+    allocator: Allocator,
+    stderr: anytype,
+    argv: []const [*:0]const u8,
+) !u8 {
+    const result = flags.parse(argv, &[_]flags.Flag{
+        .{ .name = "-h", .kind = .boolean },
+        .{ .name = "--passwd", .kind = .arg },
+        .{ .name = "--group", .kind = .arg },
+    }) catch {
+        try stderr.writeAll(usage);
+        return 1;
+    };
+
+    if (result.boolFlag("-h")) {
+        try io.getStdOut().writeAll(usage);
+        return 0;
+    }
+
+    if (result.args.len != 0) {
+        try stderr.print("ERROR: unknown option '{s}'\n", .{result.args[0]});
+        try stderr.writeAll(usage);
+        return 1;
+    }
+
+    const passwd = result.argFlag("--passwd") orelse "./passwd";
+    const group = result.argFlag("--group") orelse "./group";
+
+    var passwdFile = try fs.cwd().openFile(passwd, .{ .mode = .read_only });
+    defer passwdFile.close();
+    var groupFile = try fs.cwd().openFile(group, .{ .mode = .read_only });
+    defer groupFile.close();
+
+    var users = try User.fromReader(allocator, passwdFile.reader());
+
+    try stderr.print("read {d} users\n", .{users.len});
+    return 0;
+}
 
 const testing = std.testing;
 
-test "stub" {
-    _ = flags;
+test "invalid argument" {
+    const allocator = testing.allocator;
+    const args = &[_][*:0]const u8{"--invalid-argument"};
+    var stderr = ArrayList(u8).init(allocator);
+    defer stderr.deinit();
+
+    const exit_code = try execute(allocator, stderr.writer(), args[0..]);
+    try testing.expectEqual(@as(u8, 1), exit_code);
+    try testing.expect(mem.startsWith(u8, stderr.items, "ERROR: unknown "));
 }