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(.{
@@ -251,6 +254,7 @@ fn addTests(
         .checks = &.{
             .{ .expect_stderr_match = "error: could not download 'this-is-not-a-valid-url': the URL is invalid (InvalidFormat)" },
         },
+        .use_test_install_dir = false,
     });
 
     tests.addWithClean(.{
@@ -259,8 +263,49 @@ fn addTests(
         .checks = &.{
             .{ .expect_stderr_match = "failed to parse JSON content from index url 'https://ziglang.org' with " },
         },
+        .use_test_install_dir = false,
     });
 
+    tests.addWithClean(.{
+        .name = "test-get-install-dir",
+        .argv = &.{"get-install-dir"},
+    });
+    tests.addWithClean(.{
+        .name = "test-get-install-dir2",
+        .argv = &.{ "--install-dir", "/a/fake/install/dir", "get-install-dir" },
+        .checks = &.{
+            .{ .expect_stdout_exact = "/a/fake/install/dir" },
+        },
+        .use_test_install_dir = false,
+    });
+    tests.addWithClean(.{
+        .name = "test-set-install-dir-relative",
+        .argv = &.{ "set-install-dir", "foo/bar" },
+        .checks = &.{
+            .{ .expect_stderr_match = "error: set-install-dir requires an absolute path" },
+        },
+        .use_test_install_dir = false,
+    });
+
+    {
+        // just has to be an absolute path that exists
+        const install_dir = b.build_root.path.?;
+        const with_install_dir = tests.add(.{
+            .name = "test-set-install-dir",
+            .argv = &.{ "set-install-dir", install_dir },
+            .use_test_install_dir = false,
+        });
+        tests.addWithClean(.{
+            .name = "test-get-install-dir3",
+            .argv = &.{"get-install-dir"},
+            .env = .{ .dir = with_install_dir },
+            .checks = &.{
+                .{ .expect_stdout_exact = install_dir },
+            },
+            .use_test_install_dir = false,
+        });
+    }
+
     tests.addWithClean(.{
         .name = "test-no-default",
         .argv = &.{"default"},
@@ -625,6 +670,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 +698,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,20 @@ 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);
 
+    if (true) {
+        try std.io.getStdErr().writer().writeAll("runtest 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,16 +152,77 @@ 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 {
-    // TODO: maybe support ZIG_INSTALL_DIR environment variable?
-    // TODO: maybe support a file on the filesystem to configure install dir?
+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_path = getSettingsDir(allocator) orelse return null;
+    defer allocator.free(settings_dir_path);
+    const setting_path = std.fs.path.join(allocator, &.{ settings_dir_path, "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();
+    return file.readToEndAlloc(allocator, 9999) catch |err| {
+        std.log.err("read install dir from '{s}' failed with {s}", .{ setting_path, @errorName(err) });
+        return error.AlreadyReported;
+    };
+}
+
+fn saveInstallDir(allocator: Allocator, maybe_dir: ?[]const u8) !void {
+    const settings_dir_path = getSettingsDir(allocator) orelse {
+        std.log.err("cannot save install dir, unable to find a suitable settings directory", .{});
+        return error.AlreadyReported;
+    };
+    defer allocator.free(settings_dir_path);
+    const setting_path = std.fs.path.join(allocator, &.{ settings_dir_path, "install-dir" }) catch |e| oom(e);
+    defer allocator.free(setting_path);
+    if (maybe_dir) |d| {
+        {
+            const file = try std.fs.cwd().createFile(setting_path, .{});
+            defer file.close();
+            try file.writer().writeAll(d);
+        }
+
+        // sanity check, read it back
+        const readback = (try readInstallDir(allocator)) orelse {
+            std.log.err("unable to readback install-dir after saving it", .{});
+            return error.AlreadyReported;
+        };
+        defer allocator.free(readback);
+        if (!std.mem.eql(u8, readback, d)) {
+            std.log.err("saved install dir readback mismatch\nwrote: '{s}'\nread : '{s}'\n", .{ d, readback });
+            return error.AlreadyReported;
+        }
+    } else {
+        std.fs.cwd().deleteFile(setting_path) catch |err| switch (err) {
+            error.FileNotFound => {},
+            else => |e| return e,
+        };
+    }
+}
+
+fn allocInstallDirString(allocator: Allocator) error{AlreadyReported}![]const u8 {
+    if (try readInstallDir(allocator)) |d| return d;
     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" });
+        return std.fs.path.join(allocator, &.{ self_exe_dir, "zig" }) catch |e| oom(e);
     }
     return allocInstallDirStringXdg(allocator);
 }
@@ -205,8 +266,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:
@@ -220,12 +285,16 @@ fn help() void {
         \\  zigup keep VERSION            mark a compiler to be kept during clean
         \\  zigup run VERSION ARGS...     run the given VERSION of the compiler with the given ARGS...
         \\
+        \\  zigup get-install-dir         prints the install directory to stdout
+        \\  zigup set-install-dir PATH    set the default install directory
+        \\
         \\Uncommon Usage:
         \\
         \\  zigup fetch-index             download and print the download index json
         \\
         \\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 +303,9 @@ fn help() void {
     ++ " " ++ default_index_url ++
         \\
         \\
-    ) catch unreachable;
+    ,
+        .{default_install_dir},
+    );
 }
 
 fn getCmdOpt(args: [][:0]u8, i: *usize) ![]const u8 {
@@ -287,7 +358,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,9 +371,35 @@ pub fn main2() !u8 {
         args = args[0..newlen];
     }
     if (args.len == 0) {
-        help();
+        try help(allocator);
         return 1;
     }
+    if (std.mem.eql(u8, "get-install-dir", args[0])) {
+        if (args.len != 1) {
+            std.log.err("get-install-dir does not accept any cmdline arguments", .{});
+            return 1;
+        }
+        const install_dir = getInstallDir(allocator, .{ .create = false }) catch |err| switch (err) {
+            error.AlreadyReported => return 1,
+            else => |e| return e,
+        };
+        try std.io.getStdOut().writer().writeAll(install_dir);
+        return 0;
+    }
+    if (std.mem.eql(u8, "set-install-dir", args[0])) {
+        const set_args = args[1..];
+        if (set_args.len != 1) {
+            std.log.err("set-install-dir requires 1 cmdline arg but got {}", .{set_args.len});
+            return 1;
+        }
+        const path = set_args[0];
+        if (!std.fs.path.isAbsolute(path)) {
+            std.log.err("set-install-dir requires an absolute path", .{});
+            return 1;
+        }
+        try saveInstallDir(allocator, path);
+        return 0;
+    }
     if (std.mem.eql(u8, "fetch-index", args[0])) {
         if (args.len != 1) {
             std.log.err("'index' command requires 0 arguments but got {d}", .{args.len - 1});