diff options
| author | Can Celik <ogulcancelik@gmail.com> | 2026-04-04 19:22:04 +0300 |
|---|---|---|
| committer | Can Celik <ogulcancelik@gmail.com> | 2026-04-05 01:23:06 +0300 |
| commit | 41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch) | |
| tree | 3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/os/homedir.zig | |
| parent | 55c138263e190a1e79d4b997bfb9397306c0ec1f (diff) | |
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/os/homedir.zig')
| -rw-r--r-- | vendor/libghostty-vt/src/os/homedir.zig | 189 |
1 files changed, 189 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/os/homedir.zig b/vendor/libghostty-vt/src/os/homedir.zig new file mode 100644 index 00000000..9e0420f4 --- /dev/null +++ b/vendor/libghostty-vt/src/os/homedir.zig @@ -0,0 +1,189 @@ +const std = @import("std"); +const builtin = @import("builtin"); +const passwd = @import("passwd.zig"); +const posix = std.posix; +const objc = @import("objc"); + +const Error = error{ + /// The buffer used for output is not large enough to store the value. + BufferTooSmall, +}; + +/// Determine the home directory for the currently executing user. This +/// is generally an expensive process so the value should be cached. +pub inline fn home(buf: []u8) !?[]const u8 { + return switch (builtin.os.tag) { + .linux, .freebsd, .macos => try homeUnix(buf), + .windows => try homeWindows(buf), + + // iOS doesn't have a user-writable home directory + .ios => null, + + else => @compileError("unimplemented"), + }; +} + +fn homeUnix(buf: []u8) !?[]const u8 { + // First: if we have a HOME env var, then we use that. + if (posix.getenv("HOME")) |result| { + if (buf.len < result.len) return Error.BufferTooSmall; + @memcpy(buf[0..result.len], result); + return buf[0..result.len]; + } + + // On macOS: [NSFileManager defaultManager].homeDirectoryForCurrentUser.path + if (builtin.os.tag == .macos) { + const NSFileManager = objc.getClass("NSFileManager").?; + const manager = NSFileManager.msgSend(objc.Object, objc.sel("defaultManager"), .{}); + const homeURL = manager.getProperty(objc.Object, "homeDirectoryForCurrentUser"); + const homePath = homeURL.getProperty(objc.Object, "path"); + + const c_str = homePath.getProperty([*:0]const u8, "UTF8String"); + const result = std.mem.sliceTo(c_str, 0); + + if (buf.len < result.len) return Error.BufferTooSmall; + @memcpy(buf[0..result.len], result); + return buf[0..result.len]; + } + + // Everything below here will require some allocation + var tempBuf: [1024]u8 = undefined; + var fba = std.heap.FixedBufferAllocator.init(&tempBuf); + + // We try passwd. This doesn't work on multi-user mac but we try it anyways. + const pw = try passwd.get(fba.allocator()); + if (pw.home) |result| { + if (buf.len < result.len) return Error.BufferTooSmall; + @memcpy(buf[0..result.len], result); + return buf[0..result.len]; + } + + // If all else fails, have the shell tell us... + fba.reset(); + const run = try std.process.Child.run(.{ + .allocator = fba.allocator(), + .argv = &[_][]const u8{ "/bin/sh", "-c", "cd && pwd" }, + .max_output_bytes = fba.buffer.len / 2, + }); + + if (run.term == .Exited and run.term.Exited == 0) { + const result = trimSpace(run.stdout); + if (buf.len < result.len) return Error.BufferTooSmall; + @memcpy(buf[0..result.len], result); + return buf[0..result.len]; + } + + return null; +} + +fn homeWindows(buf: []u8) !?[]const u8 { + const drive_len = blk: { + var fba_instance = std.heap.FixedBufferAllocator.init(buf); + const fba = fba_instance.allocator(); + const drive = std.process.getEnvVarOwned(fba, "HOMEDRIVE") catch |err| switch (err) { + error.OutOfMemory => return Error.BufferTooSmall, + error.InvalidWtf8, error.EnvironmentVariableNotFound => return null, + }; + // could shift the contents if this ever happens + if (drive.ptr != buf.ptr) @panic("codebug"); + break :blk drive.len; + }; + + const path_len = blk: { + const path_buf = buf[drive_len..]; + var fba_instance = std.heap.FixedBufferAllocator.init(buf[drive_len..]); + const fba = fba_instance.allocator(); + const homepath = std.process.getEnvVarOwned(fba, "HOMEPATH") catch |err| switch (err) { + error.OutOfMemory => return Error.BufferTooSmall, + error.InvalidWtf8, error.EnvironmentVariableNotFound => return null, + }; + // could shift the contents if this ever happens + if (homepath.ptr != path_buf.ptr) @panic("codebug"); + break :blk homepath.len; + }; + + return buf[0 .. drive_len + path_len]; +} + +fn trimSpace(input: []const u8) []const u8 { + return std.mem.trim(u8, input, " \n\t"); +} + +pub const ExpandError = error{ + HomeDetectionFailed, + BufferTooSmall, +}; + +/// Expands a path that starts with a tilde (~) to the home directory of +/// the current user. +/// +/// Errors if `home` fails or if the size of the expanded path is larger +/// than `buf.len`. +pub fn expandHome(path: []const u8, buf: []u8) ExpandError![]const u8 { + return switch (builtin.os.tag) { + .linux, .freebsd, .macos => try expandHomeUnix(path, buf), + + // `~/` is not an idiom generally used on Windows + .windows => return path, + + // iOS doesn't have a user-writable home directory + .ios => return path, + + else => @compileError("unimplemented"), + }; +} + +fn expandHomeUnix(path: []const u8, buf: []u8) ExpandError![]const u8 { + if (!std.mem.startsWith(u8, path, "~/")) return path; + const home_dir: []const u8 = if (home(buf)) |home_| + home_ orelse return error.HomeDetectionFailed + else |_| + return error.HomeDetectionFailed; + const rest = path[1..]; // Skip the ~ + const expanded_len = home_dir.len + rest.len; + + if (expanded_len > buf.len) return Error.BufferTooSmall; + @memcpy(buf[home_dir.len..expanded_len], rest); + + return buf[0..expanded_len]; +} + +test "expandHomeUnix" { + if (builtin.os.tag == .windows) return error.SkipZigTest; + + const testing = std.testing; + const allocator = testing.allocator; + var buf: [std.fs.max_path_bytes]u8 = undefined; + const home_dir = try expandHomeUnix("~/", &buf); + // Joining the home directory `~` with the path `/` + // the result should end with a separator here. (e.g. `/home/user/`) + try testing.expect(home_dir[home_dir.len - 1] == std.fs.path.sep); + + const downloads = try expandHomeUnix("~/Downloads/shader.glsl", &buf); + const expected_downloads = try std.mem.concat(allocator, u8, &[_][]const u8{ home_dir, "Downloads/shader.glsl" }); + defer allocator.free(expected_downloads); + try testing.expectEqualStrings(expected_downloads, downloads); + + try testing.expectEqualStrings("~", try expandHomeUnix("~", &buf)); + try testing.expectEqualStrings("~abc/", try expandHomeUnix("~abc/", &buf)); + try testing.expectEqualStrings("/home/user", try expandHomeUnix("/home/user", &buf)); + try testing.expectEqualStrings("", try expandHomeUnix("", &buf)); + + // Expect an error if the buffer is large enough to hold the home directory, + // but not the expanded path + var small_buf = try allocator.alloc(u8, home_dir.len); + defer allocator.free(small_buf); + try testing.expectError(error.BufferTooSmall, expandHomeUnix( + "~/Downloads", + small_buf[0..], + )); +} + +test { + const testing = std.testing; + + var buf: [1024]u8 = undefined; + const result = try home(&buf); + try testing.expect(result != null); + try testing.expect(result.?.len > 0); +} |
