const std = @import("std");const builtin = @import("builtin");const file_picker_path = @import("../input/file_picker_path.zig");const file_index = @import("file_index.zig");const io_mod = @import("../shared/io.zig");const pathing = @import("pathing.zig");const text_utils = @import("../shared/text_utils.zig"); pub const QueryMode = enum { workspace_index, explicit_path,}; pub const Error = error{ NoSpaceLeft, PathUnavailable,}; const ParsedQuery = struct { parent: []const u8, display_prefix: []const u8, basename_prefix: []const u8,}; pub fn queryMode(query: []const u8) QueryMode { for (query) |byte| { if (std.fs.path.isSep(byte)) return .explicit_path; } return .workspace_index;} pub fn complete( workspace_root: []const u8, query: []const u8, out: []file_index.SearchResult, match_spans: []file_index.MatchSpan, path_storage: []u8,) Error!usize { if (out.len == 0) return 0; const parsed = parseExplicitQuery(query) orelse return 0; const slot_len: usize = file_index.max_path_len; if (out.len > path_storage.len / slot_len) return error.NoSpaceLeft; var resolve_storage: [file_index.max_path_len * 4]u8 = undefined; var resolve_fba = std.heap.FixedBufferAllocator.init(&resolve_storage); const resolved = pathing.resolveWorkspaceOrExternalPath( resolve_fba.allocator(), workspace_root, parsed.parent, ) catch |err| switch (err) { error.OutOfMemory => return error.NoSpaceLeft, else => return error.PathUnavailable, }; const io = io_mod.getIo(); var dir = std.Io.Dir.openDirAbsolute(io, resolved, .{ .iterate = true }) catch return error.PathUnavailable; defer dir.close(io); var count: usize = 0; var iterator = dir.iterate(); while (iterator.next(io) catch return error.PathUnavailable) |entry| { if (!std.ascii.startsWithIgnoreCase(entry.name, parsed.basename_prefix)) continue; if (!text_utils.isTerminalSafe(entry.name)) continue; const kind = candidateKind(&dir, entry.name, entry.kind) orelse continue; var candidate_storage: [file_index.max_path_len]u8 = undefined; const candidate_len = parsed.display_prefix.len + entry.name.len; if (candidate_len > candidate_storage.len) continue; @memcpy(candidate_storage[0..parsed.display_prefix.len], parsed.display_prefix); @memcpy(candidate_storage[parsed.display_prefix.len..candidate_len], entry.name); const candidate = candidate_storage[0..candidate_len]; if (!text_utils.isTerminalSafe(candidate)) continue; if (!file_picker_path.isRepresentable(candidate)) continue; count = insertCandidate(out, path_storage, count, candidate, kind); } var spans_used: usize = 0; for (out[0..count]) |*result| { if (parsed.basename_prefix.len == 0) { result.matched_spans = match_spans[0..0]; continue; } if (spans_used >= match_spans.len) return error.NoSpaceLeft; match_spans[spans_used] = .{ .byte_start = @intCast(parsed.display_prefix.len), .byte_end = @intCast(parsed.display_prefix.len + parsed.basename_prefix.len), }; result.matched_spans = match_spans[spans_used .. spans_used + 1]; spans_used += 1; } return count;} pub fn isCurrentCandidateKind( workspace_root: []const u8, path: []const u8, expected_kind: file_index.CandidateKind,) bool { if (!text_utils.isTerminalSafe(path)) return false; var resolve_storage: [file_index.max_path_len * 4]u8 = undefined; var resolve_fba = std.heap.FixedBufferAllocator.init(&resolve_storage); const resolved = pathing.resolveWorkspaceOrExternalPath( resolve_fba.allocator(), workspace_root, path, ) catch return false; const stat = std.Io.Dir.cwd().statFile( io_mod.getIo(), resolved, .{ .follow_symlinks = true }, ) catch return false; return kindMatchesStat(expected_kind, stat.kind);} fn parseExplicitQuery(query: []const u8) ?ParsedQuery { var separator_index: ?usize = null; for (query, 0..) |byte, index| { if (std.fs.path.isSep(byte)) separator_index = index; } const separator = separator_index orelse return null; const parent = if (separator == 0) query[0..1] else query[0..separator]; return .{ .parent = parent, .display_prefix = query[0 .. separator + 1], .basename_prefix = query[separator + 1 ..], };} fn candidateKind( dir: *std.Io.Dir, name: []const u8, observed_kind: std.Io.File.Kind,) ?file_index.CandidateKind { return switch (observed_kind) { .file => .file, .directory => .directory, .sym_link, .unknown => { const stat = dir.statFile(io_mod.getIo(), name, .{ .follow_symlinks = true }) catch return null; return kindFromStat(stat.kind); }, else => null, };} fn kindFromStat(kind: std.Io.File.Kind) ?file_index.CandidateKind { return switch (kind) { .file => .file, .directory => .directory, else => null, };} fn kindMatchesStat(expected: file_index.CandidateKind, actual: std.Io.File.Kind) bool { return switch (expected) { .file => actual == .file, .directory => actual == .directory, };} fn insertCandidate( out: []file_index.SearchResult, path_storage: []u8, count: usize, path: []const u8, kind: file_index.CandidateKind,) usize { var insertion_index: usize = 0; while (insertion_index < count and std.mem.order(u8, path, out[insertion_index].path) != .lt) : (insertion_index += 1) {} if (insertion_index >= out.len) return count; const next_count = @min(count + 1, out.len); var index = next_count - 1; while (index > insertion_index) : (index -= 1) { const previous = out[index - 1]; const slot = pathSlot(path_storage, index); @memcpy(slot[0..previous.path.len], previous.path); out[index] = .{ .path = slot[0..previous.path.len], .kind = previous.kind, .matched_spans = &.{}, }; } const slot = pathSlot(path_storage, insertion_index); @memcpy(slot[0..path.len], path); out[insertion_index] = .{ .path = slot[0..path.len], .kind = kind, .matched_spans = &.{}, }; return next_count;} fn pathSlot(storage: []u8, index: usize) []u8 { const slot_len: usize = file_index.max_path_len; const start = index * slot_len; return storage[start .. start + slot_len];} fn writeTestFile(dir: std.Io.Dir, path: []const u8) !void { if (std.fs.path.dirname(path)) |parent| try dir.createDirPath(std.testing.io, parent); var file = try dir.createFile(std.testing.io, path, .{ .truncate = true }); file.close(std.testing.io);} test "path completion classifies and splits only path-shaped queries" { try std.testing.expectEqual(QueryMode.workspace_index, queryMode("main")); try std.testing.expectEqual(QueryMode.workspace_index, queryMode("~")); try std.testing.expectEqual(QueryMode.explicit_path, queryMode("~/Dow")); try std.testing.expectEqual(QueryMode.explicit_path, queryMode("/tmp/fi")); try std.testing.expectEqual(QueryMode.explicit_path, queryMode("./src/")); try std.testing.expectEqual(QueryMode.explicit_path, queryMode("../shared/")); try std.testing.expectEqual(QueryMode.explicit_path, queryMode("src/core/")); const parsed = parseExplicitQuery("../shared/na").?; try std.testing.expectEqualStrings("../shared", parsed.parent); try std.testing.expectEqualStrings("../shared/", parsed.display_prefix); try std.testing.expectEqualStrings("na", parsed.basename_prefix);} test "path completion enumerates immediate entries with deterministic bounded order" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.createDirPath(std.testing.io, "workspace/src/empty"); try tmp.dir.createDirPath(std.testing.io, "workspace/src/nested/deeper"); try writeTestFile(tmp.dir, "workspace/src/zeta.txt"); try writeTestFile(tmp.dir, "workspace/src/Alpha.txt"); try writeTestFile(tmp.dir, "workspace/src/beta.txt"); try writeTestFile(tmp.dir, "workspace/src/.hidden.txt"); try writeTestFile(tmp.dir, "workspace/src/space \" file.txt"); const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace"); defer alloc.free(root); var results: [3]file_index.SearchResult = undefined; var spans: [3]file_index.MatchSpan = undefined; var paths: [3 * file_index.max_path_len]u8 = undefined; const count = try complete(root, "./src/", &results, &spans, &paths); try std.testing.expectEqual(@as(usize, 3), count); try std.testing.expectEqualStrings("./src/.hidden.txt", results[0].path); try std.testing.expectEqualStrings("./src/Alpha.txt", results[1].path); try std.testing.expectEqualStrings("./src/beta.txt", results[2].path); const filtered_count = try complete(root, "src/al", &results, &spans, &paths); try std.testing.expectEqual(@as(usize, 1), filtered_count); try std.testing.expectEqualStrings("src/Alpha.txt", results[0].path); try std.testing.expectEqual(file_index.CandidateKind.file, results[0].kind); try std.testing.expectEqual(@as(usize, 1), results[0].matched_spans.len); try std.testing.expectEqual(@as(u16, "src/".len), results[0].matched_spans[0].byte_start); try std.testing.expectEqual(@as(u16, "src/al".len), results[0].matched_spans[0].byte_end); try std.testing.expectEqual(@as(usize, 0), try complete(root, "src/space", &results, &spans, &paths));} test "path completion resolves parent and absolute forms without recursive traversal" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.createDirPath(std.testing.io, "workspace"); try tmp.dir.createDirPath(std.testing.io, "outside/empty"); try writeTestFile(tmp.dir, "outside/external.txt"); const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace"); defer alloc.free(root); const outside = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "outside"); defer alloc.free(outside); var results: [8]file_index.SearchResult = undefined; var spans: [8]file_index.MatchSpan = undefined; var paths: [8 * file_index.max_path_len]u8 = undefined; const parent_count = try complete(root, "../outside/", &results, &spans, &paths); try std.testing.expectEqual(@as(usize, 2), parent_count); try std.testing.expectEqualStrings("../outside/empty", results[0].path); try std.testing.expectEqual(file_index.CandidateKind.directory, results[0].kind); try std.testing.expectEqualStrings("../outside/external.txt", results[1].path); var absolute_query_storage: [file_index.max_path_len]u8 = undefined; const absolute_query = try std.fmt.bufPrint(&absolute_query_storage, "{s}/ex", .{outside}); const absolute_count = try complete(root, absolute_query, &results, &spans, &paths); try std.testing.expectEqual(@as(usize, 1), absolute_count); var expected_storage: [file_index.max_path_len]u8 = undefined; const expected = try std.fmt.bufPrint(&expected_storage, "{s}/external.txt", .{outside}); try std.testing.expectEqualStrings(expected, results[0].path);} test "path completion follows listed symlinks and filters unsafe names" { if (comptime builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest; const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.createDirPath(std.testing.io, "workspace/target-dir"); try writeTestFile(tmp.dir, "workspace/target.txt"); try writeTestFile(tmp.dir, "workspace/unsafe-\x1b.txt"); try tmp.dir.symLink(std.testing.io, "target-dir", "workspace/linked-dir", .{ .is_directory = true }); try tmp.dir.symLink(std.testing.io, "target.txt", "workspace/linked-file", .{ .is_directory = false }); const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace"); defer alloc.free(root); var results: [4]file_index.SearchResult = undefined; var spans: [4]file_index.MatchSpan = undefined; var paths: [4 * file_index.max_path_len]u8 = undefined; const count = try complete(root, "./linked", &results, &spans, &paths); try std.testing.expectEqual(@as(usize, 2), count); try std.testing.expectEqual(file_index.CandidateKind.directory, results[0].kind); try std.testing.expectEqual(file_index.CandidateKind.file, results[1].kind); try std.testing.expectEqual(@as(usize, 0), try complete(root, "./unsafe", &results, &spans, &paths));} test "path completion reports bounded storage and unavailable parents" { var results: [1]file_index.SearchResult = undefined; var spans: [1]file_index.MatchSpan = undefined; var too_small: [file_index.max_path_len - 1]u8 = undefined; try std.testing.expectError(error.NoSpaceLeft, complete("/", "./", &results, &spans, &too_small)); var paths: [file_index.max_path_len]u8 = undefined; try std.testing.expectError(error.PathUnavailable, complete("/", "/definitely/missing/fx-path/", &results, &spans, &paths));} test "path completion validates the current explicit candidate kind" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.createDirPath(std.testing.io, "workspace/folder"); try writeTestFile(tmp.dir, "workspace/file.txt"); const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace"); defer alloc.free(root); try std.testing.expect(isCurrentCandidateKind(root, "./folder", .directory)); try std.testing.expect(!isCurrentCandidateKind(root, "./folder", .file)); try std.testing.expect(isCurrentCandidateKind(root, "./file.txt", .file)); try std.testing.expect(!isCurrentCandidateKind(root, "./missing", .file));}
const std = @import("std");
const builtin = @import("builtin");
const file_picker_path = @import("../input/file_picker_path.zig");
const file_index = @import("file_index.zig");
const io_mod = @import("../shared/io.zig");
const pathing = @import("pathing.zig");
const text_utils = @import("../shared/text_utils.zig");
pub const QueryMode = enum {
workspace_index,
explicit_path,
};
pub const Error = error{
NoSpaceLeft,
PathUnavailable,
};
const ParsedQuery = struct {
parent: []const u8,
display_prefix: []const u8,
basename_prefix: []const u8,
};
pub fn queryMode(query: []const u8) QueryMode {
for (query) |byte| {
if (std.fs.path.isSep(byte)) return .explicit_path;
}
return .workspace_index;
}
pub fn complete(
workspace_root: []const u8,
query: []const u8,
out: []file_index.SearchResult,
match_spans: []file_index.MatchSpan,
path_storage: []u8,
) Error!usize {
if (out.len == 0) return 0;
const parsed = parseExplicitQuery(query) orelse return 0;
const slot_len: usize = file_index.max_path_len;
if (out.len > path_storage.len / slot_len) return error.NoSpaceLeft;
var resolve_storage: [file_index.max_path_len * 4]u8 = undefined;
var resolve_fba = std.heap.FixedBufferAllocator.init(&resolve_storage);
const resolved = pathing.resolveWorkspaceOrExternalPath(
resolve_fba.allocator(),
workspace_root,
parsed.parent,
) catch |err| switch (err) {
error.OutOfMemory => return error.NoSpaceLeft,
else => return error.PathUnavailable,
};
const io = io_mod.getIo();
var dir = std.Io.Dir.openDirAbsolute(io, resolved, .{ .iterate = true }) catch return error.PathUnavailable;
defer dir.close(io);
var count: usize = 0;
var iterator = dir.iterate();
while (iterator.next(io) catch return error.PathUnavailable) |entry| {
if (!std.ascii.startsWithIgnoreCase(entry.name, parsed.basename_prefix)) continue;
if (!text_utils.isTerminalSafe(entry.name)) continue;
const kind = candidateKind(&dir, entry.name, entry.kind) orelse continue;
var candidate_storage: [file_index.max_path_len]u8 = undefined;
const candidate_len = parsed.display_prefix.len + entry.name.len;
if (candidate_len > candidate_storage.len) continue;
@memcpy(candidate_storage[0..parsed.display_prefix.len], parsed.display_prefix);
@memcpy(candidate_storage[parsed.display_prefix.len..candidate_len], entry.name);
const candidate = candidate_storage[0..candidate_len];
if (!text_utils.isTerminalSafe(candidate)) continue;
if (!file_picker_path.isRepresentable(candidate)) continue;
count = insertCandidate(out, path_storage, count, candidate, kind);
}
var spans_used: usize = 0;
for (out[0..count]) |*result| {
if (parsed.basename_prefix.len == 0) {
result.matched_spans = match_spans[0..0];
continue;
}
if (spans_used >= match_spans.len) return error.NoSpaceLeft;
match_spans[spans_used] = .{
.byte_start = @intCast(parsed.display_prefix.len),
.byte_end = @intCast(parsed.display_prefix.len + parsed.basename_prefix.len),
};
result.matched_spans = match_spans[spans_used .. spans_used + 1];
spans_used += 1;
}
return count;
}
pub fn isCurrentCandidateKind(
workspace_root: []const u8,
path: []const u8,
expected_kind: file_index.CandidateKind,
) bool {
if (!text_utils.isTerminalSafe(path)) return false;
var resolve_storage: [file_index.max_path_len * 4]u8 = undefined;
var resolve_fba = std.heap.FixedBufferAllocator.init(&resolve_storage);
const resolved = pathing.resolveWorkspaceOrExternalPath(
resolve_fba.allocator(),
workspace_root,
path,
) catch return false;
const stat = std.Io.Dir.cwd().statFile(
io_mod.getIo(),
resolved,
.{ .follow_symlinks = true },
) catch return false;
return kindMatchesStat(expected_kind, stat.kind);
}
fn parseExplicitQuery(query: []const u8) ?ParsedQuery {
var separator_index: ?usize = null;
for (query, 0..) |byte, index| {
if (std.fs.path.isSep(byte)) separator_index = index;
}
const separator = separator_index orelse return null;
const parent = if (separator == 0) query[0..1] else query[0..separator];
return .{
.parent = parent,
.display_prefix = query[0 .. separator + 1],
.basename_prefix = query[separator + 1 ..],
};
}
fn candidateKind(
dir: *std.Io.Dir,
name: []const u8,
observed_kind: std.Io.File.Kind,
) ?file_index.CandidateKind {
return switch (observed_kind) {
.file => .file,
.directory => .directory,
.sym_link, .unknown => {
const stat = dir.statFile(io_mod.getIo(), name, .{ .follow_symlinks = true }) catch return null;
return kindFromStat(stat.kind);
},
else => null,
};
}
fn kindFromStat(kind: std.Io.File.Kind) ?file_index.CandidateKind {
return switch (kind) {
.file => .file,
.directory => .directory,
else => null,
};
}
fn kindMatchesStat(expected: file_index.CandidateKind, actual: std.Io.File.Kind) bool {
return switch (expected) {
.file => actual == .file,
.directory => actual == .directory,
};
}
fn insertCandidate(
out: []file_index.SearchResult,
path_storage: []u8,
count: usize,
path: []const u8,
kind: file_index.CandidateKind,
) usize {
var insertion_index: usize = 0;
while (insertion_index < count and std.mem.order(u8, path, out[insertion_index].path) != .lt) : (insertion_index += 1) {}
if (insertion_index >= out.len) return count;
const next_count = @min(count + 1, out.len);
var index = next_count - 1;
while (index > insertion_index) : (index -= 1) {
const previous = out[index - 1];
const slot = pathSlot(path_storage, index);
@memcpy(slot[0..previous.path.len], previous.path);
out[index] = .{
.path = slot[0..previous.path.len],
.kind = previous.kind,
.matched_spans = &.{},
};
}
const slot = pathSlot(path_storage, insertion_index);
@memcpy(slot[0..path.len], path);
out[insertion_index] = .{
.path = slot[0..path.len],
.kind = kind,
.matched_spans = &.{},
};
return next_count;
}
fn pathSlot(storage: []u8, index: usize) []u8 {
const slot_len: usize = file_index.max_path_len;
const start = index * slot_len;
return storage[start .. start + slot_len];
}
fn writeTestFile(dir: std.Io.Dir, path: []const u8) !void {
if (std.fs.path.dirname(path)) |parent| try dir.createDirPath(std.testing.io, parent);
var file = try dir.createFile(std.testing.io, path, .{ .truncate = true });
file.close(std.testing.io);
}
test "path completion classifies and splits only path-shaped queries" {
try std.testing.expectEqual(QueryMode.workspace_index, queryMode("main"));
try std.testing.expectEqual(QueryMode.workspace_index, queryMode("~"));
try std.testing.expectEqual(QueryMode.explicit_path, queryMode("~/Dow"));
try std.testing.expectEqual(QueryMode.explicit_path, queryMode("/tmp/fi"));
try std.testing.expectEqual(QueryMode.explicit_path, queryMode("./src/"));
try std.testing.expectEqual(QueryMode.explicit_path, queryMode("../shared/"));
try std.testing.expectEqual(QueryMode.explicit_path, queryMode("src/core/"));
const parsed = parseExplicitQuery("../shared/na").?;
try std.testing.expectEqualStrings("../shared", parsed.parent);
try std.testing.expectEqualStrings("../shared/", parsed.display_prefix);
try std.testing.expectEqualStrings("na", parsed.basename_prefix);
}
test "path completion enumerates immediate entries with deterministic bounded order" {
const alloc = std.testing.allocator;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDirPath(std.testing.io, "workspace/src/empty");
try tmp.dir.createDirPath(std.testing.io, "workspace/src/nested/deeper");
try writeTestFile(tmp.dir, "workspace/src/zeta.txt");
try writeTestFile(tmp.dir, "workspace/src/Alpha.txt");
try writeTestFile(tmp.dir, "workspace/src/beta.txt");
try writeTestFile(tmp.dir, "workspace/src/.hidden.txt");
try writeTestFile(tmp.dir, "workspace/src/space \" file.txt");
const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace");
defer alloc.free(root);
var results: [3]file_index.SearchResult = undefined;
var spans: [3]file_index.MatchSpan = undefined;
var paths: [3 * file_index.max_path_len]u8 = undefined;
const count = try complete(root, "./src/", &results, &spans, &paths);
try std.testing.expectEqual(@as(usize, 3), count);
try std.testing.expectEqualStrings("./src/.hidden.txt", results[0].path);
try std.testing.expectEqualStrings("./src/Alpha.txt", results[1].path);
try std.testing.expectEqualStrings("./src/beta.txt", results[2].path);
const filtered_count = try complete(root, "src/al", &results, &spans, &paths);
try std.testing.expectEqual(@as(usize, 1), filtered_count);
try std.testing.expectEqualStrings("src/Alpha.txt", results[0].path);
try std.testing.expectEqual(file_index.CandidateKind.file, results[0].kind);
try std.testing.expectEqual(@as(usize, 1), results[0].matched_spans.len);
try std.testing.expectEqual(@as(u16, "src/".len), results[0].matched_spans[0].byte_start);
try std.testing.expectEqual(@as(u16, "src/al".len), results[0].matched_spans[0].byte_end);
try std.testing.expectEqual(@as(usize, 0), try complete(root, "src/space", &results, &spans, &paths));
}
test "path completion resolves parent and absolute forms without recursive traversal" {
const alloc = std.testing.allocator;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDirPath(std.testing.io, "workspace");
try tmp.dir.createDirPath(std.testing.io, "outside/empty");
try writeTestFile(tmp.dir, "outside/external.txt");
const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace");
defer alloc.free(root);
const outside = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "outside");
defer alloc.free(outside);
var results: [8]file_index.SearchResult = undefined;
var spans: [8]file_index.MatchSpan = undefined;
var paths: [8 * file_index.max_path_len]u8 = undefined;
const parent_count = try complete(root, "../outside/", &results, &spans, &paths);
try std.testing.expectEqual(@as(usize, 2), parent_count);
try std.testing.expectEqualStrings("../outside/empty", results[0].path);
try std.testing.expectEqual(file_index.CandidateKind.directory, results[0].kind);
try std.testing.expectEqualStrings("../outside/external.txt", results[1].path);
var absolute_query_storage: [file_index.max_path_len]u8 = undefined;
const absolute_query = try std.fmt.bufPrint(&absolute_query_storage, "{s}/ex", .{outside});
const absolute_count = try complete(root, absolute_query, &results, &spans, &paths);
try std.testing.expectEqual(@as(usize, 1), absolute_count);
var expected_storage: [file_index.max_path_len]u8 = undefined;
const expected = try std.fmt.bufPrint(&expected_storage, "{s}/external.txt", .{outside});
try std.testing.expectEqualStrings(expected, results[0].path);
}
test "path completion follows listed symlinks and filters unsafe names" {
if (comptime builtin.os.tag == .windows or builtin.os.tag == .wasi) return error.SkipZigTest;
const alloc = std.testing.allocator;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDirPath(std.testing.io, "workspace/target-dir");
try writeTestFile(tmp.dir, "workspace/target.txt");
try writeTestFile(tmp.dir, "workspace/unsafe-\x1b.txt");
try tmp.dir.symLink(std.testing.io, "target-dir", "workspace/linked-dir", .{ .is_directory = true });
try tmp.dir.symLink(std.testing.io, "target.txt", "workspace/linked-file", .{ .is_directory = false });
const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace");
defer alloc.free(root);
var results: [4]file_index.SearchResult = undefined;
var spans: [4]file_index.MatchSpan = undefined;
var paths: [4 * file_index.max_path_len]u8 = undefined;
const count = try complete(root, "./linked", &results, &spans, &paths);
try std.testing.expectEqual(@as(usize, 2), count);
try std.testing.expectEqual(file_index.CandidateKind.directory, results[0].kind);
try std.testing.expectEqual(file_index.CandidateKind.file, results[1].kind);
try std.testing.expectEqual(@as(usize, 0), try complete(root, "./unsafe", &results, &spans, &paths));
}
test "path completion reports bounded storage and unavailable parents" {
var results: [1]file_index.SearchResult = undefined;
var spans: [1]file_index.MatchSpan = undefined;
var too_small: [file_index.max_path_len - 1]u8 = undefined;
try std.testing.expectError(error.NoSpaceLeft, complete("/", "./", &results, &spans, &too_small));
var paths: [file_index.max_path_len]u8 = undefined;
try std.testing.expectError(error.PathUnavailable, complete("/", "/definitely/missing/fx-path/", &results, &spans, &paths));
}
test "path completion validates the current explicit candidate kind" {
const alloc = std.testing.allocator;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
try tmp.dir.createDirPath(std.testing.io, "workspace/folder");
try writeTestFile(tmp.dir, "workspace/file.txt");
const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace");
defer alloc.free(root);
try std.testing.expect(isCurrentCandidateKind(root, "./folder", .directory));
try std.testing.expect(!isCurrentCandidateKind(root, "./folder", .file));
try std.testing.expect(isCurrentCandidateKind(root, "./file.txt", .file));
try std.testing.expect(!isCurrentCandidateKind(root, "./missing", .file));
}