tiny.smg.name

1const std = @import("std");23const testing_fallback_match_count = @import("root.zig").default_limits.suggestions.fallback_match_count;45pub fn matchesSuffix(name: []const u8, suffix: []const u8) bool {6    if (!std.mem.endsWith(u8, name, suffix)) return false;7    if (name.len == suffix.len) return true;8    return name[name.len - suffix.len - 1] == '.';9}1011pub fn leaf(raw: []const u8) []const u8 {12    if (std.mem.lastIndexOfScalar(u8, raw, '/')) |slash| {13        const base = raw[slash + 1 ..];14        const dot = std.mem.lastIndexOfScalar(u8, base, '.') orelse return base;15        if (dot == 0) return base;16        return base[0..dot];17    }18    const dot = std.mem.lastIndexOfScalar(u8, raw, '.') orelse return raw;19    return raw[dot + 1 ..];20}2122pub fn dottedFromPath(allocator: std.mem.Allocator, raw: []const u8) !?[]const u8 {23    if (std.mem.indexOfScalar(u8, raw, '/') == null) return null;24    var trimmed = raw;25    while (std.mem.startsWith(u8, trimmed, "./")) trimmed = trimmed[2..];26    while (trimmed.len != 0 and trimmed[0] == '/') trimmed = trimmed[1..];27    while (trimmed.len != 0 and trimmed[trimmed.len - 1] == '/') trimmed = trimmed[0 .. trimmed.len - 1];28    if (trimmed.len == 0) return null;29    const base_start = if (std.mem.lastIndexOfScalar(u8, trimmed, '/')) |slash| slash + 1 else 0;30    if (std.mem.lastIndexOfScalar(u8, trimmed[base_start..], '.')) |dot| {31        if (dot != 0) trimmed = trimmed[0 .. base_start + dot];32    }33    const stem = trimmed[base_start..];34    if (std.mem.eql(u8, stem, "index") or std.mem.eql(u8, stem, "__init__")) {35        trimmed = if (base_start == 0) "root" else trimmed[0 .. base_start - 1];36    }37    const out = try allocator.dupe(u8, trimmed);38    for (out) |*char| {39        if (char.* == '/') char.* = '.';40    }41    return out;42}4344pub fn matchesSubsequence(name: []const u8, query: []const u8) bool {45    const query_dot = std.mem.lastIndexOfScalar(u8, query, '.') orelse return false;46    const name_dot = std.mem.lastIndexOfScalar(u8, name, '.') orelse return false;47    if (!std.mem.eql(u8, name[name_dot + 1 ..], query[query_dot + 1 ..])) return false;48    var query_segments = std.mem.splitScalar(u8, query[0..query_dot], '.');49    var name_segments = std.mem.splitScalar(u8, name[0..name_dot], '.');50    var pending = query_segments.next();51    while (pending) |segment| {52        const candidate = name_segments.next() orelse return false;53        if (std.mem.eql(u8, candidate, segment)) pending = query_segments.next();54    }55    return true;56}5758pub fn fallbackMatches(allocator: std.mem.Allocator, names: []const []const u8, raw: []const u8, limit: usize) ![]const []const u8 {59    if (try dottedFromPath(allocator, raw)) |translated| {60        defer allocator.free(translated);61        for (names) |name| {62            if (std.mem.eql(u8, name, translated)) {63                const out = try allocator.alloc([]const u8, 1);64                out[0] = name;65                return out;66            }67        }68        const suffixed = try collect(allocator, names, translated, matchesSuffix, limit);69        if (suffixed.len != 0) return suffixed;70        return try collect(allocator, names, translated, matchesSubsequence, limit);71    }72    return try collect(allocator, names, raw, matchesSubsequence, limit);73}7475fn collect(allocator: std.mem.Allocator, names: []const []const u8, query: []const u8, matches: fn ([]const u8, []const u8) bool, limit: usize) ![]const []const u8 {76    var out: std.ArrayList([]const u8) = .empty;77    errdefer out.deinit(allocator);78    for (names) |name| {79        if (!matches(name, query)) continue;80        if (out.items.len == limit) {81            out.deinit(allocator);82            return &.{};83        }84        try out.append(allocator, name);85    }86    std.mem.sort([]const u8, out.items, {}, stringLess);87    return try out.toOwnedSlice(allocator);88}8990fn stringLess(_: void, a: []const u8, b: []const u8) bool {91    return std.mem.lessThan(u8, a, b);92}9394test "suffix matches whole dotted segments only" {95    try std.testing.expect(matchesSuffix("app.main", "main"));96    try std.testing.expect(matchesSuffix("app.main", "app.main"));97    try std.testing.expect(!matchesSuffix("app.domain", "main"));98    try std.testing.expect(!matchesSuffix("main", "app.main"));99}100101test "leaf strips qualification for dotted names and extensions for paths" {102    try std.testing.expectEqualStrings("merge", leaf("lib.tracker.src.store.merge"));103    try std.testing.expectEqualStrings("merge", leaf("lib/tracker/src/store/merge.zig"));104    try std.testing.expectEqualStrings("tinyalloc", leaf("lib/tinyalloc"));105    try std.testing.expectEqualStrings(".hidden", leaf("dir/.hidden"));106    try std.testing.expectEqualStrings("plain", leaf("plain"));107}108109test "dotted translation maps repo paths onto node names" {110    const allocator = std.testing.allocator;111    const translated = (try dottedFromPath(allocator, "lib/tracker/src/store/merge.zig")).?;112    defer allocator.free(translated);113    try std.testing.expectEqualStrings("lib.tracker.src.store.merge", translated);114    const trimmed = (try dottedFromPath(allocator, "./lib/term/src/")).?;115    defer allocator.free(trimmed);116    try std.testing.expectEqualStrings("lib.term.src", trimmed);117    const bare = (try dottedFromPath(allocator, "lib/tinyalloc")).?;118    defer allocator.free(bare);119    try std.testing.expectEqualStrings("lib.tinyalloc", bare);120    const index = (try dottedFromPath(allocator, "tools/glom/src/index.zig")).?;121    defer allocator.free(index);122    try std.testing.expectEqualStrings("tools.glom.src", index);123    const init = (try dottedFromPath(allocator, "analysis/src/analysis/__init__.py")).?;124    defer allocator.free(init);125    try std.testing.expectEqualStrings("analysis.src.analysis", init);126    try std.testing.expectEqual(@as(?[]const u8, null), try dottedFromPath(allocator, "app.main"));127}128129test "subsequence anchors the leaf and orders the qualifiers" {130    try std.testing.expect(matchesSubsequence("lib.choir.src.core.context.dialects", "choir.context.dialects"));131    try std.testing.expect(matchesSubsequence("lib.tracker.src.store.merge", "store.merge"));132    try std.testing.expect(matchesSubsequence("app.main", "app.main"));133    try std.testing.expect(!matchesSubsequence("lib.choir.src.core.dialects", "choir.context.dialects"));134    try std.testing.expect(!matchesSubsequence("lib.choir.src.context.core.dialects", "choir.core.context.dialects"));135    try std.testing.expect(!matchesSubsequence("lib.choir.src.core.context.dialects", "dialects"));136    try std.testing.expect(!matchesSubsequence("dialects", "choir.context.dialects"));137}138139test "fallback resolves path forms before subsequence forms" {140    const allocator = std.testing.allocator;141    const names = [_][]const u8{142        "lib.choir.src.core.dialects",143        "lib.choir.src.core.context.dialects",144        "lib.tracker.src.store.merge",145        "lib.tracker.src.store",146    };147148    const path_hit = try fallbackMatches(allocator, &names, "lib/tracker/src/store/merge.zig", testing_fallback_match_count);149    defer allocator.free(path_hit);150    try std.testing.expectEqual(@as(usize, 1), path_hit.len);151    try std.testing.expectEqualStrings("lib.tracker.src.store.merge", path_hit[0]);152153    const relative = try fallbackMatches(allocator, &names, "src/store/merge.zig", testing_fallback_match_count);154    defer allocator.free(relative);155    try std.testing.expectEqual(@as(usize, 1), relative.len);156    try std.testing.expectEqualStrings("lib.tracker.src.store.merge", relative[0]);157158    const subsequence = try fallbackMatches(allocator, &names, "choir.context.dialects", testing_fallback_match_count);159    defer allocator.free(subsequence);160    try std.testing.expectEqual(@as(usize, 1), subsequence.len);161    try std.testing.expectEqualStrings("lib.choir.src.core.context.dialects", subsequence[0]);162163    const ambiguous = try fallbackMatches(allocator, &names, "core.dialects", testing_fallback_match_count);164    defer allocator.free(ambiguous);165    try std.testing.expectEqual(@as(usize, 2), ambiguous.len);166167    const missing = try fallbackMatches(allocator, &names, "absent.node", testing_fallback_match_count);168    defer allocator.free(missing);169    try std.testing.expectEqual(@as(usize, 0), missing.len);170}171172test "fallback declares no resolution beyond the candidate bound" {173    const allocator = std.testing.allocator;174    var names: std.ArrayList([]const u8) = .empty;175    defer {176        for (names.items) |name| allocator.free(name);177        names.deinit(allocator);178    }179    for (0..testing_fallback_match_count + 1) |index| {180        try names.append(allocator, try std.fmt.allocPrint(allocator, "pkg{d}.src.core.leaf", .{index}));181    }182    const flooded = try fallbackMatches(allocator, names.items, "core.leaf", testing_fallback_match_count);183    defer allocator.free(flooded);184    try std.testing.expectEqual(@as(usize, 0), flooded.len);185}

1pub const name = @import("name.zig");