add persistent install-dir setting

marler8997 · marler8997 · commit b3428e8e091d · 2025-04-20T12:09:42.000-06:00
diff --git a/README.md b/README.md
@@ -43,11 +43,10 @@ zigup run <version> <args>...
 
 # How the compilers are managed
 
-zigup stores each compiler in a global "install directory" in a versioned subdirectory.  On posix systems the "install directory" is `$HOME/.local/share/zigup` (or `$XDG_DATA_HOME/zigup`; see below) and on windows the install directory will be a directory named "zig" in the same directory as the "zigup.exe".
+zigup stores each compiler in a global "install directory" in a versioned subdirectory. Run `zigup get-install-dir` to see what this PATH is on your system. You can change this default with `zigup set-install-dir PATH`.
 
 zigup makes the zig program available by creating an entry in a directory that occurs in the `PATH` environment variable.  On posix systems this entry is a symlink to one of the `zig` executables in the install directory.  On windows this is an executable that forwards invocations to one of the `zig` executables in the install directory.
 
-Both the "install directory" and "path link" are configurable through command-line options `--install-dir` and `--path-link` respectively.  On posix systems the default "install directory" follows the [XDG basedir spec](https://specifications.freedesktop.org/basedir-spec/latest/#variables), ie. `$XDG_DATA_HOME/zigup` or `$HOME/.local/share/zigup` if `XDG_DATA_HOME` environment variable is empty or undefined.
 # Building
 
 Run `zig build` to build, `zig build test` to test and install with:
diff --git a/build.zig b/build.zig
@@ -261,6 +261,47 @@ fn addTests(
         },
     });
 
+    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\n" },
+        },
+    });
+    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" },
+        },
+    });
+
+    {
+        // 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 },
+        });
+        tests.addWithClean(.{
+            .name = "test-get-install-dir3",
+            .argv = &.{"get-install-dir"},
+            .env = .{ .dir = with_install_dir },
+            .checks = &.{
+                .{ .expect_stdout_exact = b.fmt("{s}\n", .{install_dir}) },
+            },
+        });
+        tests.addWithClean(.{
+            .name = "test-revert-install-dir",
+            .argv = &.{"set-install-dir"},
+            .env = .{ .dir = with_install_dir },
+        });
+    }
+
     tests.addWithClean(.{
         .name = "test-no-default",
         .argv = &.{"default"},
diff --git a/runtest.zig b/runtest.zig
@@ -45,11 +45,20 @@ pub fn main() !void {
     //     try file.writer().print("this file marks this directory as the output for test: {s}\n", .{test_name});
     // }
 
+    const appdata = try std.fs.path.join(arena, &.{ out_env_dir, "appdata" });
     const path_link = try std.fs.path.join(arena, &.{ out_env_dir, "zig" ++ exe_ext });
     const install_dir = try std.fs.path.join(arena, &.{ out_env_dir, "install" });
+    const install_dir_parsed = parseInstallDir(install_dir);
+
+    const install_dir_setting_path = try std.fs.path.join(arena, &.{ appdata, "install-dir" });
+    defer arena.free(install_dir_setting_path);
 
     if (std.mem.eql(u8, in_env_dir, "--no-input-environment")) {
         try std.fs.cwd().makeDir(install_dir);
+        try std.fs.cwd().makeDir(appdata);
+        var file = try std.fs.cwd().createFile(install_dir_setting_path, .{});
+        defer file.close();
+        try file.writer().writeAll(install_dir);
     } else {
         var shared_sibling_state: SharedSiblingState = .{};
         try copyEnvDir(
@@ -61,6 +70,25 @@ pub fn main() !void {
             .{ .with_compilers = with_compilers },
             &shared_sibling_state,
         );
+
+        // we need to patch the old install dir
+        const input_install_dir = blk: {
+            var file = try std.fs.cwd().openFile(install_dir_setting_path, .{});
+            defer file.close();
+            break :blk try file.readToEndAlloc(arena, std.math.maxInt(usize));
+        };
+        defer arena.free(input_install_dir);
+
+        if (std.mem.startsWith(u8, install_dir, input_install_dir)) {
+            // the install dir has been customized, we'll keep it
+        } else {
+            // otherwise, just write our new default install directory
+            const input_install_dir_parsed = parseInstallDir(input_install_dir);
+            std.debug.assert(std.mem.eql(u8, install_dir_parsed.cache_o, input_install_dir_parsed.cache_o));
+            var file = try std.fs.cwd().createFile(install_dir_setting_path, .{});
+            defer file.close();
+            try file.writer().writeAll(install_dir);
+        }
     }
 
     var maybe_second_bin_dir: ?[]const u8 = null;
@@ -92,12 +120,20 @@ pub fn main() !void {
 
     var argv = std.ArrayList([]const u8).init(arena);
     try argv.append(zigup_exe);
+    try argv.append("--appdata");
+    try argv.append(appdata);
     try argv.append("--path-link");
     try argv.append(path_link);
-    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) {
@@ -156,6 +192,31 @@ pub fn main() !void {
     }
 }
 
+const ParsedInstallDir = struct {
+    test_name: []const u8,
+    hash: []const u8,
+    cache_o: []const u8,
+};
+fn badInstallDir(install_dir: []const u8, reason: []const u8) noreturn {
+    std.debug.panic("invalid install directory '{s}': {s}", .{ install_dir, reason });
+}
+fn parseInstallDir(install_dir: []const u8) ParsedInstallDir {
+    {
+        const name = std.fs.path.basename(install_dir);
+        if (!std.mem.eql(u8, name, "install"))
+            badInstallDir(install_dir, "did not end with 'install'");
+    }
+    const test_dir = std.fs.path.dirname(install_dir) orelse badInstallDir(install_dir, "missing test dir");
+    const test_name = std.fs.path.basename(test_dir);
+    const cache_dir = std.fs.path.dirname(test_dir) orelse badInstallDir(install_dir, "missing cache/hash dir");
+    const hash = std.fs.path.basename(cache_dir);
+    return .{
+        .test_name = test_name,
+        .hash = hash,
+        .cache_o = std.fs.path.dirname(cache_dir) orelse badInstallDir(install_dir, "missing cache o dir"),
+    };
+}
+
 fn containsCompiler(compilers: []const u8, compiler: []const u8) bool {
     var it = std.mem.splitScalar(u8, compilers, ',');
     while (it.next()) |c| {
diff --git a/zigup.zig b/zigup.zig
@@ -26,6 +26,7 @@ const url_platform = os ++ "-" ++ arch;
 const json_platform = arch ++ "-" ++ os;
 const archive_ext = if (builtin.os.tag == .windows) "zip" else "tar.xz";
 
+var global_override_appdata: ?[]const u8 = null; // only used for testing
 var global_optional_install_dir: ?[]const u8 = null;
 var global_optional_path_link: ?[]const u8 = null;
 
@@ -131,7 +132,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 +142,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,21 +153,89 @@ 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 {
+    const appdata: ?[]const u8 = std.fs.getAppDataDir(allocator, "zigup") catch |err| switch (err) {
+        error.OutOfMemory => |e| oom(e),
+        error.AppDataDirUnavailable => null,
+    };
+    // just used for testing, but note we still test getting the builtin appdata dir either way
+    if (global_override_appdata) |appdata_override| {
+        if (appdata) |a| allocator.free(a);
+        return allocator.dupe(u8, appdata_override) catch |e| oom(e);
+    }
+    return appdata;
+}
+
+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);
 }
 const GetInstallDirOptions = struct {
     create: bool,
+    log: bool = true,
 };
 fn getInstallDir(allocator: Allocator, options: GetInstallDirOptions) ![]const u8 {
     var optional_dir_to_free_on_error: ?[]const u8 = null;
@@ -178,7 +247,9 @@ fn getInstallDir(allocator: Allocator, options: GetInstallDirOptions) ![]const u
         break :init optional_dir_to_free_on_error.?;
     };
     std.debug.assert(std.fs.path.isAbsolute(install_dir));
-    loginfo("install directory '{s}'", .{install_dir});
+    if (options.log) {
+        loginfo("install directory '{s}'", .{install_dir});
+    }
     if (options.create) {
         loggyMakePath(install_dir) catch |e| switch (e) {
             error.PathAlreadyExists => {},
@@ -205,8 +276,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 +295,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, no PATH reverts to the builtin default
+        \\
         \\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 +313,9 @@ fn help() void {
     ++ " " ++ default_index_url ++
         \\
         \\
-    ) catch unreachable;
+    ,
+        .{default_install_dir},
+    );
 }
 
 fn getCmdOpt(args: [][:0]u8, i: *usize) ![]const u8 {
@@ -287,8 +368,11 @@ 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 (std.mem.eql(u8, "--appdata", arg)) {
+                // NOTE: this is a private option just used for testing
+                global_override_appdata = try getCmdOpt(args, &i);
             } else {
                 if (newlen == 0 and std.mem.eql(u8, "run", arg)) {
                     return try runCompiler(allocator, args[i + 1 ..]);
@@ -300,9 +384,41 @@ 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, .log = false }) catch |err| switch (err) {
+            error.AlreadyReported => return 1,
+            else => |e| return e,
+        };
+        try std.io.getStdOut().writer().writeAll(install_dir);
+        try std.io.getStdOut().writer().writeAll("\n");
+        return 0;
+    }
+    if (std.mem.eql(u8, "set-install-dir", args[0])) {
+        const set_args = args[1..];
+        switch (set_args.len) {
+            0 => try saveInstallDir(allocator, null),
+            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);
+            },
+            else => |set_arg_count| {
+                std.log.err("set-install-dir requires 0 or 1 cmdline arg but got {}", .{set_arg_count});
+                return 1;
+            },
+        }
+        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});
