add persistent install-dir setting

Author: marler8997

build.zig

@@ -228,11 +228,13 @@ fn addTests(
         .name = "test-usage-h",
         .argv = &.{"-h"},
         .check = .{ .expect_stderr_match = "Usage" },
+        .use_test_install_dir = false,
     });
     tests.addWithClean(.{
         .name = "test-usage-help",
         .argv = &.{"--help"},
         .check = .{ .expect_stderr_match = "Usage" },
+        .use_test_install_dir = false,
     });
 
     tests.addWithClean(.{
@@ -243,6 +245,7 @@ fn addTests(
             .{ .expect_stdout_match = "version" },
             .{ .expect_stdout_match = "0.13.0" },
         },
+        .use_test_install_dir = false,
     });
 
     tests.addWithClean(.{
@@ -625,6 +628,7 @@ const TestOptions = struct {
     argv: []const []const u8,
     check: ?std.Build.Step.Run.StdIo.Check = null,
     checks: []const std.Build.Step.Run.StdIo.Check = &.{},
+    use_test_install_dir: bool = true,
 };
 
 const Tests = struct {
@@ -652,6 +656,7 @@ const Tests = struct {
         run.addArtifactArg(tests.runtest_exe);
         run.addArg(opt.name);
         run.addArg(if (opt.add_path) "--with-path" else "--no-path");
+        run.addArg(if (opt.use_test_install_dir) "--with-test-install-dir" else "--no-test-install-dir");
         if (opt.env) |env| {
             run.addDirectoryArg(env.dir);
         } else {

runtest.zig

@@ -17,13 +17,14 @@ pub fn main() !void {
 
     const test_name = all_args[1];
     const add_path_option = all_args[2];
-    const in_env_dir = all_args[3];
-    const with_compilers = compilersArg(all_args[4]);
-    const keep_compilers = compilersArg(all_args[5]);
-    const out_env_dir = all_args[6];
-    const setup_option = all_args[7];
-    const zigup_exe = all_args[8];
-    const zigup_args = all_args[9..];
+    const install_dir_option = all_args[3];
+    const in_env_dir = all_args[4];
+    const with_compilers = compilersArg(all_args[5]);
+    const keep_compilers = compilersArg(all_args[6]);
+    const out_env_dir = all_args[7];
+    const setup_option = all_args[8];
+    const zigup_exe = all_args[9];
+    const zigup_args = all_args[10..];
 
     const add_path = blk: {
         if (std.mem.eql(u8, add_path_option, "--with-path")) break :blk true;
@@ -32,6 +33,13 @@ pub fn main() !void {
         std.process.exit(0xff);
     };
 
+    const use_test_install_dir = blk: {
+        if (std.mem.eql(u8, install_dir_option, "--with-test-install-dir")) break :blk true;
+        if (std.mem.eql(u8, install_dir_option, "--no-test-install-dir")) break :blk false;
+        std.log.err("expected '--with-test-install-dir' or '--no-test-install-dir' but got '{s}'", .{install_dir_option});
+        std.process.exit(0xff);
+    };
+
     try fixdeletetree.deleteTree(std.fs.cwd(), out_env_dir);
     try std.fs.cwd().makeDir(out_env_dir);
 
@@ -94,10 +102,18 @@ pub fn main() !void {
     try argv.append(zigup_exe);
     try argv.append("--path-link");
     try argv.append(path_link);
-    try argv.append("--install-dir");
-    try argv.append(install_dir);
+    if (use_test_install_dir) {
+        try argv.append("--install-dir");
+        try argv.append(install_dir);
+    }
     try argv.appendSlice(zigup_args);
 
+    try std.io.getStdErr().writer().writeAll("ZIGUP EXEC:");
+    for (argv.items) |arg| {
+        try std.io.getStdErr().writer().print(" {s}", .{arg});
+    }
+    try std.io.getStdErr().writer().writeAll("\n");
+
     var child = std.process.Child.init(argv.items, arena);
 
     if (add_path) {

zigup.zig

@@ -131,7 +131,7 @@ fn ignoreHttpCallback(request: []const u8) void {
     _ = request;
 }
 
-fn allocInstallDirStringXdg(allocator: Allocator) ![]const u8 {
+fn allocInstallDirStringXdg(allocator: Allocator) error{AlreadyReported}![]const u8 {
     // see https://specifications.freedesktop.org/basedir-spec/latest/#variables
     // try $XDG_DATA_HOME/zigup first
     xdg_var: {
@@ -141,7 +141,7 @@ fn allocInstallDirStringXdg(allocator: Allocator) ![]const u8 {
             std.log.err("$XDG_DATA_HOME environment variable '{s}' is not an absolute path", .{xdg_data_home});
             return error.AlreadyReported;
         }
-        return std.fs.path.join(allocator, &[_][]const u8{ xdg_data_home, "zigup" });
+        return std.fs.path.join(allocator, &[_][]const u8{ xdg_data_home, "zigup" }) catch |e| oom(e);
     }
     // .. then fallback to $HOME/.local/share/zigup
     const home = std.posix.getenv("HOME") orelse {
@@ -152,14 +152,47 @@ fn allocInstallDirStringXdg(allocator: Allocator) ![]const u8 {
         std.log.err("$HOME environment variable '{s}' is not an absolute path", .{home});
         return error.AlreadyReported;
     }
-    return std.fs.path.join(allocator, &[_][]const u8{ home, ".local", "share", "zigup" });
+    return std.fs.path.join(allocator, &[_][]const u8{ home, ".local", "share", "zigup" }) catch |e| oom(e);
 }
 
-fn allocInstallDirString(allocator: Allocator) ![]const u8 {
+fn getSettingsDir(allocator: Allocator) ?[]const u8 {
+    return std.fs.getAppDataDir(allocator, "zigup") catch |err| switch (err) {
+        error.OutOfMemory => |e| oom(e),
+        error.AppDataDirUnavailable => return null,
+    };
+}
+
+fn readInstallDir(allocator: Allocator) !?[]const u8 {
+    const settings_dir = getSettingsDir(allocator) orelse return null;
+    defer allocator.free(settings_dir);
+
+    const setting_path = std.fs.path.join(
+        allocator,
+        &.{ settings_dir, "install-dir" },
+    ) catch |e| oom(e);
+    defer allocator.free(setting_path);
+    var file = std.fs.cwd().openFile(setting_path, .{}) catch |err| switch (err) {
+        error.FileNotFound => return null,
+        else => |e| {
+            std.log.err("open '{s}' failed with {s}", .{ setting_path, @errorName(e) });
+            return error.AlreadyReported;
+        },
+    };
+    defer file.close();
+
+    std.debug.panic("TODO: read install-dir from '{s}'", .{setting_path});
+}
+
+fn allocInstallDirString(allocator: Allocator) error{AlreadyReported}![]const u8 {
     // TODO: maybe support ZIG_INSTALL_DIR environment variable?
+    if (try readInstallDir(allocator)) |d| return d;
+
     // TODO: maybe support a file on the filesystem to configure install dir?
     if (builtin.os.tag == .windows) {
-        const self_exe_dir = try std.fs.selfExeDirPathAlloc(allocator);
+        const self_exe_dir = std.fs.selfExeDirPathAlloc(allocator) catch |e| {
+            std.log.err("failed to get exe dir path with {s}", .{@errorName(e)});
+            return error.AlreadyReported;
+        };
         defer allocator.free(self_exe_dir);
         return std.fs.path.join(allocator, &.{ self_exe_dir, "zig" });
     }
@@ -205,8 +238,12 @@ fn toAbsolute(allocator: Allocator, path: []const u8) ![]u8 {
     return std.fs.path.join(allocator, &[_][]const u8{ cwd, path });
 }
 
-fn help() void {
-    std.io.getStdErr().writeAll(
+fn help(allocator: Allocator) !void {
+    const default_install_dir = allocInstallDirString(allocator) catch |err| switch (err) {
+        error.AlreadyReported => "unknown (see error printed above)",
+    };
+
+    try std.io.getStdErr().writer().print(
         \\Download and manage zig compilers.
         \\
         \\Common Usage:
@@ -226,6 +263,7 @@ fn help() void {
         \\
         \\Common Options:
         \\  --install-dir DIR             override the default install location
+        \\                                default: {s}
         \\  --path-link PATH              path to the `zig` symlink that points to the default compiler
         \\                                this will typically be a file path within a PATH directory so
         \\                                that the user can just run `zig`
@@ -234,7 +272,9 @@ fn help() void {
     ++ " " ++ default_index_url ++
         \\
         \\
-    ) catch unreachable;
+    ,
+        .{default_install_dir},
+    );
 }
 
 fn getCmdOpt(args: [][:0]u8, i: *usize) ![]const u8 {
@@ -287,7 +327,7 @@ pub fn main2() !u8 {
             } else if (std.mem.eql(u8, "--index", arg)) {
                 index_url = try getCmdOpt(args, &i);
             } else if (std.mem.eql(u8, "-h", arg) or std.mem.eql(u8, "--help", arg)) {
-                help();
+                try help(allocator);
                 return 0;
             } else {
                 if (newlen == 0 and std.mem.eql(u8, "run", arg)) {
@@ -300,7 +340,7 @@ pub fn main2() !u8 {
         args = args[0..newlen];
     }
     if (args.len == 0) {
-        help();
+        try help(allocator);
         return 1;
     }
     if (std.mem.eql(u8, "fetch-index", args[0])) {