Add std.fs.path.resolveRelative helper fn

`std.fs.path.resolveRelative` function is like `std.fs.path.resolve`
however it resolves relative paths **only**, and they are always
resolved to wrt ".". If the final path is resolved to "." or beyond,
`null` is returned instead to signify this. Also, if an absolute
path is passed as an argument, `ResolveRelativeError.AbsolutePath`
is thrown. This function is particularly useful for Capsicum-like
targets such as WASI.

This commit also tweaks `std.cache_hash.CacheHash` to use either
`std.fs.path.resolveat` or `std.fs.path.resolveRelative` (the latter
used when targeting WASI). This way, we essentially got rid of any
mention of CWD, and hence, it is now possible to use `CacheHash`
struct in WASI. As a result, all tests in the said module have
been enabled for WASI.

Author: kubkon

lib/std/cache_hash.zig

@@ -1,10 +1,12 @@
-const std = @import("std.zig");
+const builtin = @import("builtin");
+const std = @import("std");
 const Blake3 = std.crypto.Blake3;
 const fs = std.fs;
 const base64 = std.base64;
 const ArrayList = std.ArrayList;
 const assert = std.debug.assert;
 const testing = std.testing;
+const tmpDir = testing.tmpDir;
 const mem = std.mem;
 const fmt = std.fmt;
 const Allocator = std.mem.Allocator;
@@ -53,7 +55,6 @@ pub const CacheHash = struct {
         return CacheHash{
             .allocator = allocator,
             .blake3 = Blake3.init(),
-            // TODO should claim ownership of `work_dir`?
             .work_dir = work_dir,
             .manifest_dir = try work_dir.makeOpenPath(manifest_dir_path, .{}),
             .manifest_file = null,
@@ -103,7 +104,13 @@ pub const CacheHash = struct {
         assert(self.manifest_file == null);
 
         try self.files.ensureCapacity(self.files.items.len + 1);
-        const resolved_path = try fs.path.resolveat(self.allocator, self.work_dir, &[_][]const u8{file_path});
+
+        var resolved_path: []u8 = undefined;
+        if (builtin.os.tag == .wasi) {
+            resolved_path = (try fs.path.resolveRelative(self.allocator, &[_][]const u8{file_path})) orelse unreachable;
+        } else {
+            resolved_path = try fs.path.resolveat(self.allocator, self.work_dir, &[_][]const u8{file_path});
+        }
 
         const idx = self.files.items.len;
         self.files.addOneAssumeCapacity().* = .{
@@ -325,7 +332,12 @@ pub const CacheHash = struct {
     pub fn addFilePostFetch(self: *CacheHash, file_path: []const u8, max_file_size: usize) ![]u8 {
         assert(self.manifest_file != null);
 
-        const resolved_path = try fs.path.resolveat(self.allocator, self.work_dir, &[_][]const u8{file_path});
+        var resolved_path: []u8 = undefined;
+        if (builtin.os.tag == .wasi) {
+            resolved_path = (try fs.path.resolveRelative(self.allocator, &[_][]const u8{file_path})) orelse unreachable;
+        } else {
+            resolved_path = try fs.path.resolveat(self.allocator, self.work_dir, &[_][]const u8{file_path});
+        }
         errdefer self.allocator.free(resolved_path);
 
         const new_ch_file = try self.files.addOne();
@@ -350,7 +362,12 @@ pub const CacheHash = struct {
     pub fn addFilePost(self: *CacheHash, file_path: []const u8) !void {
         assert(self.manifest_file != null);
 
-        const resolved_path = try fs.path.resolveat(self.allocator, self.work_dir, &[_][]const u8{file_path});
+        var resolved_path: []u8 = undefined;
+        if (builtin.os.tag == .wasi) {
+            resolved_path = (try fs.path.resolveRelative(self.allocator, &[_][]const u8{file_path})) orelse unreachable;
+        } else {
+            resolved_path = try fs.path.resolveat(self.allocator, self.work_dir, &[_][]const u8{file_path});
+        }
         errdefer self.allocator.free(resolved_path);
 
         const new_ch_file = try self.files.addOne();
@@ -473,16 +490,13 @@ fn isProblematicTimestamp(fs_clock: i128) bool {
 }
 
 test "cache file and then recall it" {
-    if (std.Target.current.os.tag == .wasi) {
-        // https://github.com/ziglang/zig/issues/5437
-        return error.SkipZigTest;
-    }
-    const cwd = fs.cwd();
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
 
     const temp_file = "test.txt";
     const temp_manifest_dir = "temp_manifest_dir";
 
-    try cwd.writeFile(temp_file, "Hello, world!\n");
+    try tmp.dir.writeFile(temp_file, "Hello, world!\n");
 
     while (isProblematicTimestamp(std.time.nanoTimestamp())) {
         std.time.sleep(1);
@@ -492,7 +506,7 @@ test "cache file and then recall it" {
     var digest2: [BASE64_DIGEST_LEN]u8 = undefined;
 
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add(true);
@@ -506,7 +520,7 @@ test "cache file and then recall it" {
         digest1 = ch.final();
     }
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add(true);
@@ -520,8 +534,8 @@ test "cache file and then recall it" {
 
     testing.expectEqual(digest1, digest2);
 
-    try cwd.deleteTree(temp_manifest_dir);
-    try cwd.deleteFile(temp_file);
+    try tmp.dir.deleteTree(temp_manifest_dir);
+    try tmp.dir.deleteFile(temp_file);
 }
 
 test "give problematic timestamp" {
@@ -537,18 +551,15 @@ test "give nonproblematic timestamp" {
 }
 
 test "check that changing a file makes cache fail" {
-    if (std.Target.current.os.tag == .wasi) {
-        // https://github.com/ziglang/zig/issues/5437
-        return error.SkipZigTest;
-    }
-    const cwd = fs.cwd();
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
 
     const temp_file = "cache_hash_change_file_test.txt";
     const temp_manifest_dir = "cache_hash_change_file_manifest_dir";
     const original_temp_file_contents = "Hello, world!\n";
     const updated_temp_file_contents = "Hello, world; but updated!\n";
 
-    try cwd.writeFile(temp_file, original_temp_file_contents);
+    try tmp.dir.writeFile(temp_file, original_temp_file_contents);
 
     while (isProblematicTimestamp(std.time.nanoTimestamp())) {
         std.time.sleep(1);
@@ -558,7 +569,7 @@ test "check that changing a file makes cache fail" {
     var digest2: [BASE64_DIGEST_LEN]u8 = undefined;
 
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -572,14 +583,14 @@ test "check that changing a file makes cache fail" {
         digest1 = ch.final();
     }
 
-    try cwd.writeFile(temp_file, updated_temp_file_contents);
+    try tmp.dir.writeFile(temp_file, updated_temp_file_contents);
 
     while (isProblematicTimestamp(std.time.nanoTimestamp())) {
         std.time.sleep(1);
     }
 
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -596,24 +607,22 @@ test "check that changing a file makes cache fail" {
 
     testing.expect(!mem.eql(u8, digest1[0..], digest2[0..]));
 
-    try cwd.deleteTree(temp_manifest_dir);
-    try cwd.deleteFile(temp_file);
+    try tmp.dir.deleteTree(temp_manifest_dir);
+    try tmp.dir.deleteFile(temp_file);
 }
 
 test "no file inputs" {
-    if (std.Target.current.os.tag == .wasi) {
-        // https://github.com/ziglang/zig/issues/5437
-        return error.SkipZigTest;
-    }
-    const cwd = fs.cwd();
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
+
     const temp_manifest_dir = "no_file_inputs_manifest_dir";
-    defer cwd.deleteTree(temp_manifest_dir) catch unreachable;
+    defer tmp.dir.deleteTree(temp_manifest_dir) catch unreachable;
 
     var digest1: [BASE64_DIGEST_LEN]u8 = undefined;
     var digest2: [BASE64_DIGEST_LEN]u8 = undefined;
 
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -624,7 +633,7 @@ test "no file inputs" {
         digest1 = ch.final();
     }
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -636,18 +645,15 @@ test "no file inputs" {
 }
 
 test "CacheHashes with files added after initial hash work" {
-    if (std.Target.current.os.tag == .wasi) {
-        // https://github.com/ziglang/zig/issues/5437
-        return error.SkipZigTest;
-    }
-    const cwd = fs.cwd();
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
 
     const temp_file1 = "cache_hash_post_file_test1.txt";
     const temp_file2 = "cache_hash_post_file_test2.txt";
     const temp_manifest_dir = "cache_hash_post_file_manifest_dir";
 
-    try cwd.writeFile(temp_file1, "Hello, world!\n");
-    try cwd.writeFile(temp_file2, "Hello world the second!\n");
+    try tmp.dir.writeFile(temp_file1, "Hello, world!\n");
+    try tmp.dir.writeFile(temp_file2, "Hello world the second!\n");
 
     while (isProblematicTimestamp(std.time.nanoTimestamp())) {
         std.time.sleep(1);
@@ -658,7 +664,7 @@ test "CacheHashes with files added after initial hash work" {
     var digest3: [BASE64_DIGEST_LEN]u8 = undefined;
 
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -672,7 +678,7 @@ test "CacheHashes with files added after initial hash work" {
         digest1 = ch.final();
     }
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -683,14 +689,14 @@ test "CacheHashes with files added after initial hash work" {
     testing.expect(mem.eql(u8, &digest1, &digest2));
 
     // Modify the file added after initial hash
-    try cwd.writeFile(temp_file2, "Hello world the second, updated\n");
+    try tmp.dir.writeFile(temp_file2, "Hello world the second, updated\n");
 
     while (isProblematicTimestamp(std.time.nanoTimestamp())) {
         std.time.sleep(1);
     }
 
     {
-        var ch = try CacheHash.init(testing.allocator, cwd, temp_manifest_dir);
+        var ch = try CacheHash.init(testing.allocator, tmp.dir, temp_manifest_dir);
         defer ch.release();
 
         ch.add("1234");
@@ -706,7 +712,7 @@ test "CacheHashes with files added after initial hash work" {
 
     testing.expect(!mem.eql(u8, &digest1, &digest3));
 
-    try cwd.deleteTree(temp_manifest_dir);
-    try cwd.deleteFile(temp_file1);
-    try cwd.deleteFile(temp_file2);
+    try tmp.dir.deleteTree(temp_manifest_dir);
+    try tmp.dir.deleteFile(temp_file1);
+    try tmp.dir.deleteFile(temp_file2);
 }

lib/std/fs/path.zig

@@ -652,10 +652,62 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
     return allocator.shrink(result, result_index);
 }
 
+pub const ResolveRelativeError = error{AbsolutePath} || Allocator.Error;
+
+/// This function is like a series of `cd` statements executed one after another.
+/// It resolves "." and ".." relative to ".".
+/// The result does not have a trailing path separator.
+/// It does not dereference symlinks, and always returns a relative path. If the
+/// resolution leads to ".", returns null instead.
+pub fn resolveRelative(allocator: *Allocator, paths: []const []const u8) ResolveRelativeError!?[]u8 {
+    var max_size: usize = 0;
+    for (paths) |p, i| {
+        if (isAbsolute(p)) {
+            return ResolveRelativeError.AbsolutePath;
+        }
+        max_size += p.len + 1;
+    }
+
+    var result_index: usize = 0;
+    var result = try allocator.alloc(u8, max_size);
+    errdefer allocator.free(result);
+
+    for (paths) |p, i| {
+        var it = mem.tokenize(p, "/");
+        while (it.next()) |component| {
+            if (mem.eql(u8, component, ".")) {
+                continue;
+            } else if (mem.eql(u8, component, "..")) {
+                while (true) {
+                    if (result_index == 0)
+                        break;
+                    result_index -= 1;
+                    if (result[result_index] == '/')
+                        break;
+                }
+            } else {
+                if (result_index > 0) {
+                    result[result_index] = '/';
+                    result_index += 1;
+                }
+                mem.copy(u8, result[result_index..], component);
+                result_index += component.len;
+            }
+        }
+    }
+
+    if (result_index == 0) {
+        allocator.free(result);
+        return null;
+    }
+
+    return allocator.shrink(result, result_index);
+}
+
 /// Similar to `resolve`, however, resolves the paths with respect to the provided
 /// `Dir` handle.
-/// This function, unlike `resolve`, will perform one syscall to get the path of
-/// the specified `dir` handle.
+/// Unlike `resolve`, will perform one syscall to get the path of the
+/// specified `dir` handle.
 pub fn resolveat(allocator: *Allocator, dir: fs.Dir, paths: []const []const u8) ![]u8 {
     var buffer: [fs.MAX_PATH_BYTES]u8 = undefined;
     const dir_path = try std.os.realpathat(dir.fd, "", &buffer);
@@ -760,6 +812,45 @@ fn testResolvePosix(paths: []const []const u8, expected: []const u8) !void {
     return testing.expect(mem.eql(u8, actual, expected));
 }
 
+test "resolveRelative" {
+    try testResolveRelative(&[_][]const u8{ "a/b", "c" }, "a/b/c");
+    try testResolveRelative(&[_][]const u8{ "a/b", "./../" }, "a");
+    try testResolveRelative(&[_][]const u8{ "a/b", "..", ".." }, null);
+    try testResolveRelative(&[_][]const u8{"./"}, null);
+    try testResolveRelative(&[_][]const u8{ "..", "../" }, null);
+    try testResolveRelative(&[_][]const u8{ "./a", "/" }, ResolveRelativeError.AbsolutePath);
+}
+
+fn testResolveRelative(paths: []const []const u8, expected: var) !void {
+    const res = resolveRelative(testing.allocator, paths);
+
+    if (@typeInfo(@TypeOf(expected)) == .ErrorSet) {
+        return testing.expectError(expected, res);
+    }
+
+    const actual = try res;
+    defer if (actual) |a| testing.allocator.free(a);
+
+    return switch (@typeInfo(@TypeOf(expected))) {
+        .Null => testing.expectEqual(actual, expected),
+        else => |_| testing.expect(mem.eql(u8, actual.?, expected)),
+    };
+}
+
+test "resolveat" {
+    if (builtin.os.tag == .wasi) return error.SkipZigTest;
+
+    const cwd = fs.cwd();
+
+    const a = try resolveat(testing.allocator, cwd, &[_][]const u8{});
+    defer testing.allocator.free(a);
+
+    const b = try resolve(testing.allocator, &[_][]const u8{});
+    defer testing.allocator.free(b);
+
+    testing.expect(mem.eql(u8, a, b));
+}
+
 /// If the path is a file in the current directory (no directory component)
 /// then returns null
 pub fn dirname(path: []const u8) ?[]const u8 {