tiny.smg.view

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

1const std = @import("std");2const alloc_phase = @import("alloc_phase");3const graph_mod = @import("graph.zig");4const limits_mod = @import("limits/root.zig");5const model = @import("model.zig");6const name_mod = @import("name.zig");78const testing_limits = @import("root.zig").default_limits.suggestions;910pub fn containsEdge(graph: graph_mod.Graph, source: []const u8, rel: []const u8, target: []const u8) !bool {11    var stack: [4096]u8 = undefined;12    const key_len = graph_mod.edgeKeyLen(source, rel, target);13    const key = if (key_len <= stack.len)14        graph_mod.edgeKeyInto(stack[0..key_len], source, rel, target)15    else16        try graph_mod.edgeKey(graph.allocator, source, rel, target);17    defer if (key_len > stack.len) graph.allocator.free(key);18    return graph.edge_index.contains(key);19}2021pub fn resolve(graph: graph_mod.Graph, allocator: std.mem.Allocator, raw: []const u8) ![]const []const u8 {22    var out: std.ArrayList([]const u8) = .empty;23    errdefer out.deinit(allocator);24    if (graph.node_index.contains(raw)) {25        try out.append(allocator, raw);26        return try out.toOwnedSlice(allocator);27    }28    if (graph_mod.suffixIndexReady(graph)) {29        try graph_mod.appendSuffixMatches(graph, allocator, raw, &out);30    } else {31        for (graph.nodes.items) |node| {32            if (name_mod.matchesSuffix(node.name, raw)) try out.append(allocator, node.name);33        }34    }35    std.mem.sort([]const u8, out.items, {}, cmpString);36    return try out.toOwnedSlice(allocator);37}3839pub fn lookup(graph: graph_mod.Graph, allocator: std.mem.Allocator, raw: []const u8, limits: limits_mod.Suggestions) ![]const []const u8 {40    const direct = try resolve(graph, allocator, raw);41    if (direct.len != 0) return direct;42    allocator.free(direct);43    const names = try allocator.alloc([]const u8, graph.nodes.items.len);44    defer allocator.free(names);45    for (graph.nodes.items, 0..) |node, index| names[index] = node.name;46    return try name_mod.fallbackMatches(allocator, names, raw, limits.fallback_match_count);47}4849pub fn resolveOne(graph: graph_mod.Graph, allocator: std.mem.Allocator, raw: []const u8) ![]const u8 {50    const matches = try resolve(graph, allocator, raw);51    defer allocator.free(matches);52    if (matches.len == 0) return graph_mod.Error.NodeNotFound;53    if (matches.len > 1) return graph_mod.Error.AmbiguousName;54    return matches[0];55}5657pub const SuggestionRank = struct {58    score: u8,59    spread: usize,60};6162pub const SuggestionQuery = struct {63    allocator: std.mem.Allocator,64    normalized: []u8,65    normalized_len: usize,66    leaf: []u8,67    rows: []usize,6869    pub fn init(allocator: std.mem.Allocator, raw: []const u8, limits: limits_mod.Suggestions) !?SuggestionQuery {70        const normalized = try allocator.alloc(u8, limits.normalized_name_bytes);71        errdefer allocator.free(normalized);72        const leaf = try allocator.alloc(u8, limits.normalized_name_bytes);73        errdefer allocator.free(leaf);74        const row_entries = try alloc_phase.capacity.add(usize, limits.normalized_name_bytes, 1);75        const row_count = try alloc_phase.capacity.mul(usize, row_entries, 2);76        const rows = try allocator.alloc(usize, row_count);77        errdefer allocator.free(rows);78        const value = normalizeInto(normalized, name_mod.leaf(raw)) orelse {79            allocator.free(rows);80            allocator.free(leaf);81            allocator.free(normalized);82            return null;83        };84        if (value.len == 0) {85            allocator.free(rows);86            allocator.free(leaf);87            allocator.free(normalized);88            return null;89        }90        return .{91            .allocator = allocator,92            .normalized = normalized,93            .normalized_len = value.len,94            .leaf = leaf,95            .rows = rows,96        };97    }9899    pub fn deinit(self: *SuggestionQuery) void {100        self.allocator.free(self.rows);101        self.allocator.free(self.leaf);102        self.allocator.free(self.normalized);103        self.* = undefined;104    }105106    pub fn rank(self: *SuggestionQuery, name: []const u8) ?SuggestionRank {107        const query = self.normalized[0..self.normalized_len];108        const leaf = normalizeInto(self.leaf, name_mod.leaf(name)) orelse return null;109        if (leaf.len == 0) return null;110        const score: u8 = if (std.mem.eql(u8, leaf, query))111            0112        else if (query.len >= 3 and std.mem.indexOf(u8, leaf, query) != null)113            1114        else if (boundedDistance(leaf, query, 2, self.rows)) |distance|115            1 + distance116        else if (leaf.len >= 3 and std.mem.indexOf(u8, query, leaf) != null)117            4118        else119            return null;120        return .{121            .score = score,122            .spread = @max(leaf.len, query.len) - @min(leaf.len, query.len),123        };124    }125};126127const Scored = struct {128    name: []const u8,129    rank: SuggestionRank,130};131132pub fn suggestionLessThan(133    a_name: []const u8,134    a_rank: SuggestionRank,135    b_name: []const u8,136    b_rank: SuggestionRank,137) bool {138    if (a_rank.score != b_rank.score) return a_rank.score < b_rank.score;139    if (a_rank.spread != b_rank.spread) return a_rank.spread < b_rank.spread;140    if (a_name.len != b_name.len) return a_name.len < b_name.len;141    return std.mem.lessThan(u8, a_name, b_name);142}143144pub fn suggest(allocator: std.mem.Allocator, names: []const []const u8, raw: []const u8, limit: usize, limits: limits_mod.Suggestions) ![]const []const u8 {145    var query = (try SuggestionQuery.init(allocator, raw, limits)) orelse return &.{};146    defer query.deinit();147    var scored: std.ArrayList(Scored) = .empty;148    defer scored.deinit(allocator);149    for (names) |name| {150        if (std.mem.eql(u8, name, raw)) continue;151        const rank = query.rank(name) orelse continue;152        try scored.append(allocator, .{ .name = name, .rank = rank });153    }154    std.mem.sort(Scored, scored.items, {}, scoredLess);155    const count = @min(limit, scored.items.len);156    const out = try allocator.alloc([]const u8, count);157    for (scored.items[0..count], 0..) |entry, index| out[index] = entry.name;158    return out;159}160161pub fn suggestNodes(graph: graph_mod.Graph, allocator: std.mem.Allocator, raw: []const u8, limit: usize, limits: limits_mod.Suggestions) ![]const []const u8 {162    const names = try allocator.alloc([]const u8, graph.nodes.items.len);163    defer allocator.free(names);164    for (graph.nodes.items, 0..) |node, index| names[index] = node.name;165    return try suggest(allocator, names, raw, limit, limits);166}167168fn normalizeInto(buffer: []u8, raw: []const u8) ?[]const u8 {169    var length: usize = 0;170    for (raw) |char| {171        if (char == '_' or char == '-') continue;172        if (length == buffer.len) return null;173        buffer[length] = std.ascii.toLower(char);174        length += 1;175    }176    return buffer[0..length];177}178179fn boundedDistance(a: []const u8, b: []const u8, max: u8, rows: []usize) ?u8 {180    const longer = if (a.len >= b.len) a else b;181    const shorter = if (a.len >= b.len) b else a;182    if (longer.len - shorter.len > max) return null;183    const row_len = shorter.len + 1;184    if (row_len > rows.len / 2) return null;185    var previous = rows[0..row_len];186    var current = rows[row_len .. row_len * 2];187    for (0..shorter.len + 1) |index| previous[index] = @intCast(index);188    for (longer, 0..) |char, row| {189        current[0] = row + 1;190        var row_min = current[0];191        for (shorter, 0..) |other, column| {192            const substitution = previous[column] + @intFromBool(char != other);193            const insertion = current[column] + 1;194            const deletion = previous[column + 1] + 1;195            current[column + 1] = @min(substitution, @min(insertion, deletion));196            row_min = @min(row_min, current[column + 1]);197        }198        if (row_min > max) return null;199        @memcpy(previous[0 .. shorter.len + 1], current[0 .. shorter.len + 1]);200    }201    const distance = previous[shorter.len];202    return if (distance <= max) @intCast(distance) else null;203}204205fn scoredLess(_: void, a: Scored, b: Scored) bool {206    return suggestionLessThan(a.name, a.rank, b.name, b.rank);207}208209pub fn incoming(graph: graph_mod.Graph, allocator: std.mem.Allocator, name: []const u8, rel: ?[]const u8) ![]const model.Edge {210    var out: std.ArrayList(model.Edge) = .empty;211    errdefer out.deinit(allocator);212    for (graph_mod.incomingEdges(&graph, name)) |edge_index| {213        const edge = graph.edges.items[edge_index];214        if (rel == null or std.mem.eql(u8, edge.rel, rel.?)) try out.append(allocator, edge);215    }216    std.mem.sort(model.Edge, out.items, {}, cmpIncoming);217    return try out.toOwnedSlice(allocator);218}219220pub fn outgoing(graph: graph_mod.Graph, allocator: std.mem.Allocator, name: []const u8, rel: ?[]const u8) ![]const model.Edge {221    var out: std.ArrayList(model.Edge) = .empty;222    errdefer out.deinit(allocator);223    for (graph_mod.outgoingEdges(&graph, name)) |edge_index| {224        const edge = graph.edges.items[edge_index];225        if (rel == null or std.mem.eql(u8, edge.rel, rel.?)) try out.append(allocator, edge);226    }227    std.mem.sort(model.Edge, out.items, {}, cmpOutgoing);228    return try out.toOwnedSlice(allocator);229}230231pub fn allNodes(graph: graph_mod.Graph, allocator: std.mem.Allocator, type_name: ?[]const u8) ![]const model.Node {232    var out: std.ArrayList(model.Node) = .empty;233    errdefer out.deinit(allocator);234    for (graph.nodes.items) |node| {235        if (type_name == null or std.mem.eql(u8, node.type, type_name.?)) try out.append(allocator, node);236    }237    sortNodes(out.items);238    return try out.toOwnedSlice(allocator);239}240241pub fn sortNodes(nodes: []model.Node) void {242    std.mem.sort(model.Node, nodes, {}, cmpNode);243}244245pub fn allEdges(graph: graph_mod.Graph, allocator: std.mem.Allocator) ![]const model.Edge {246    var out: std.ArrayList(model.Edge) = .empty;247    errdefer out.deinit(allocator);248    for (graph.edges.items) |edge| try out.append(allocator, edge);249    sortEdges(out.items);250    return try out.toOwnedSlice(allocator);251}252253pub fn sortEdges(edges: []model.Edge) void {254    std.mem.sort(model.Edge, edges, {}, cmpEdge);255}256257pub fn validate(graph: graph_mod.Graph, allocator: std.mem.Allocator) ![]const []const u8 {258    var out: std.ArrayList([]const u8) = .empty;259    errdefer {260        freeStrings(allocator, out.items);261        out.deinit(allocator);262    }263    for (graph.edges.items) |edge| {264        if (!graph.node_index.contains(edge.source)) {265            const issue = try std.fmt.allocPrint(allocator, "dangling edge source: {s}", .{edge.source});266            errdefer allocator.free(issue);267            try out.append(allocator, issue);268        }269        if (!graph.node_index.contains(edge.target)) {270            const issue = try std.fmt.allocPrint(allocator, "dangling edge target: {s}", .{edge.target});271            errdefer allocator.free(issue);272            try out.append(allocator, issue);273        }274    }275    return try out.toOwnedSlice(allocator);276}277278pub fn scopePrefix(graph: graph_mod.Graph, allocator: std.mem.Allocator, module_filter: []const u8) !graph_mod.Graph {279    var scoped = graph_mod.init(allocator);280    errdefer graph_mod.deinit(&scoped);281    const prefix_owned = !std.mem.endsWith(u8, module_filter, ".");282    const prefix = if (prefix_owned) try std.fmt.allocPrint(allocator, "{s}.", .{module_filter}) else module_filter;283    defer if (prefix_owned) allocator.free(prefix);284    const nodes = try allNodes(graph, allocator, null);285    defer allocator.free(nodes);286    for (nodes) |node| {287        if (std.mem.eql(u8, node.name, module_filter) or std.mem.startsWith(u8, node.name, prefix)) try graph_mod.addNode(&scoped, node);288    }289    const edges = try allEdges(graph, allocator);290    defer allocator.free(edges);291    for (edges) |edge| {292        if (scoped.node_index.contains(edge.source) and scoped.node_index.contains(edge.target)) try graph_mod.addEdge(&scoped, edge);293    }294    return scoped;295}296297fn freeStrings(allocator: std.mem.Allocator, values: []const []const u8) void {298    for (values) |value| allocator.free(value);299}300301fn cmpString(_: void, a: []const u8, b: []const u8) bool {302    return std.mem.lessThan(u8, a, b);303}304305fn cmpNode(_: void, a: model.Node, b: model.Node) bool {306    return std.mem.lessThan(u8, a.name, b.name);307}308309fn cmpEdge(_: void, a: model.Edge, b: model.Edge) bool {310    const source = std.mem.order(u8, a.source, b.source);311    if (source != .eq) return source == .lt;312    const rel = std.mem.order(u8, a.rel, b.rel);313    if (rel != .eq) return rel == .lt;314    return std.mem.lessThan(u8, a.target, b.target);315}316317fn cmpIncoming(_: void, a: model.Edge, b: model.Edge) bool {318    const rel = std.mem.order(u8, a.rel, b.rel);319    if (rel != .eq) return rel == .lt;320    return std.mem.lessThan(u8, a.source, b.source);321}322323fn cmpOutgoing(_: void, a: model.Edge, b: model.Edge) bool {324    const rel = std.mem.order(u8, a.rel, b.rel);325    if (rel != .eq) return rel == .lt;326    return std.mem.lessThan(u8, a.target, b.target);327}328329test "resolve suffix and validate edge" {330    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);331    defer arena.deinit();332    const allocator = arena.allocator();333    var graph = graph_mod.init(allocator);334    const meta = try model.sourcePair(allocator, "manual");335    try graph_mod.addNode(&graph, .{ .name = "pkg.mod", .type = model.NodeType.module, .metadata = meta });336    try graph_mod.addNode(&graph, .{ .name = "pkg.mod.f", .type = model.NodeType.function, .metadata = meta });337    try graph_mod.addEdge(&graph, .{ .source = "pkg.mod", .rel = model.RelType.contains, .target = "pkg.mod.f", .metadata = meta });338    try std.testing.expectEqualStrings("pkg.mod.f", try resolveOne(graph, allocator, "f"));339    const issues = try validate(graph, allocator);340    try std.testing.expectEqual(@as(usize, 0), issues.len);341}342343test "lookup widens resolve with path and subsequence stages" {344    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);345    defer arena.deinit();346    const allocator = arena.allocator();347    var graph = graph_mod.init(allocator);348    for ([_][]const u8{ "lib.pkg.src.core.merge", "lib.pkg.src.core", "lib.other.src.core.split", "tools.glom.src" }) |node_name| {349        try graph_mod.addNode(&graph, .{ .name = node_name, .type = model.NodeType.module });350    }351352    const exact = try lookup(graph, allocator, "lib.pkg.src.core.merge", testing_limits);353    try std.testing.expectEqual(@as(usize, 1), exact.len);354    const path = try lookup(graph, allocator, "lib/pkg/src/core/merge.zig", testing_limits);355    try std.testing.expectEqual(@as(usize, 1), path.len);356    try std.testing.expectEqualStrings("lib.pkg.src.core.merge", path[0]);357    const relative = try lookup(graph, allocator, "src/core/merge.zig", testing_limits);358    try std.testing.expectEqual(@as(usize, 1), relative.len);359    try std.testing.expectEqualStrings("lib.pkg.src.core.merge", relative[0]);360    const package_path = try lookup(graph, allocator, "tools/glom/src/index.zig", testing_limits);361    try std.testing.expectEqual(@as(usize, 1), package_path.len);362    try std.testing.expectEqualStrings("tools.glom.src", package_path[0]);363    const subsequence = try lookup(graph, allocator, "pkg.core.merge", testing_limits);364    try std.testing.expectEqual(@as(usize, 1), subsequence.len);365    try std.testing.expectEqualStrings("lib.pkg.src.core.merge", subsequence[0]);366    const strict = try resolve(graph, allocator, "pkg.core.merge");367    try std.testing.expectEqual(@as(usize, 0), strict.len);368    const absent = try lookup(graph, allocator, "no/such/file.zig", testing_limits);369    try std.testing.expectEqual(@as(usize, 0), absent.len);370}371372test "resolve matches agree between linear and indexed suffix lookup" {373    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);374    defer arena.deinit();375    const allocator = arena.allocator();376    var graph = graph_mod.init(allocator);377    for ([_][]const u8{ "app.main", "lib.main", "app.helper", "domain", "remain" }) |name| {378        try graph_mod.addNode(&graph, .{ .name = name, .type = model.NodeType.function });379    }380    const linear = try resolve(graph, allocator, "main");381    try std.testing.expectEqual(@as(usize, 2), linear.len);382    try std.testing.expectEqualStrings("app.main", linear[0]);383    try std.testing.expectEqualStrings("lib.main", linear[1]);384    const linear_missing = try resolve(graph, allocator, "absent");385    try std.testing.expectEqual(@as(usize, 0), linear_missing.len);386387    try graph_mod.buildSuffixIndex(&graph);388    const indexed = try resolve(graph, allocator, "main");389    try std.testing.expectEqual(@as(usize, 2), indexed.len);390    try std.testing.expectEqualStrings("app.main", indexed[0]);391    try std.testing.expectEqualStrings("lib.main", indexed[1]);392    const exact = try resolve(graph, allocator, "app.main");393    try std.testing.expectEqual(@as(usize, 1), exact.len);394}395396test "suggest ranks case and separator variants above typos" {397    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);398    defer arena.deinit();399    const allocator = arena.allocator();400    const names = [_][]const u8{401        "store.IssueStateStore.mark_status",402        "store.IssueStateStore.mark_stale",403        "app.markstatus.render",404        "lib.unrelated",405    };406    const exact = try suggest(allocator, &names, "markstatus", 5, testing_limits);407    try std.testing.expectEqual(@as(usize, 1), exact.len);408    try std.testing.expectEqualStrings("store.IssueStateStore.mark_status", exact[0]);409    const typo = try suggest(allocator, &names, "mark_statsu", 5, testing_limits);410    try std.testing.expect(typo.len >= 1);411    try std.testing.expectEqualStrings("store.IssueStateStore.mark_status", typo[0]);412    const none = try suggest(allocator, &names, "zzzqqq", 5, testing_limits);413    try std.testing.expectEqual(@as(usize, 0), none.len);414}415416test "suggest matches partial leaves and respects the limit" {417    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);418    defer arena.deinit();419    const allocator = arena.allocator();420    const names = [_][]const u8{421        "compiler.lowering.emit",422        "compiler.lowering.emitAll",423        "compiler.lowering.emitOne",424        "compiler.lowering.emitMany",425        "compiler.lowering.emitSome",426        "compiler.lowering.emitEach",427    };428    const partial = try suggest(allocator, &names, "emit", 5, testing_limits);429    try std.testing.expectEqual(@as(usize, 5), partial.len);430    try std.testing.expectEqualStrings("compiler.lowering.emit", partial[0]);431}432433test "suggest nodes reads names from the graph" {434    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);435    defer arena.deinit();436    const allocator = arena.allocator();437    var graph = graph_mod.init(allocator);438    try graph_mod.addNode(&graph, .{ .name = "app.main", .type = model.NodeType.function });439    try graph_mod.addNode(&graph, .{ .name = "app.helper", .type = model.NodeType.function });440    const suggestions = try suggestNodes(graph, allocator, "app.mian", 5, testing_limits);441    try std.testing.expectEqual(@as(usize, 1), suggestions.len);442    try std.testing.expectEqualStrings("app.main", suggestions[0]);443}444445test "contains edge frees long lookup keys" {446    const source = &(@as([4100]u8, @splat('s')));447    const target = &(@as([4100]u8, @splat('t')));448    var graph = graph_mod.init(std.testing.allocator);449    defer graph_mod.deinit(&graph);450    try graph_mod.addNode(&graph, .{ .name = source, .type = model.NodeType.module });451    try graph_mod.addNode(&graph, .{ .name = target, .type = model.NodeType.function });452    try graph_mod.addEdge(&graph, .{ .source = source, .rel = model.RelType.calls, .target = target });453    try std.testing.expect(try containsEdge(graph, source, model.RelType.calls, target));454}455456test "view helpers clean up allocation failures" {457    try std.testing.checkAllAllocationFailures(458        std.testing.allocator,459        checkViewAllocationFailures,460        .{},461    );462}463464fn checkViewAllocationFailures(allocator: std.mem.Allocator) !void {465    var graph = graph_mod.init(allocator);466    defer graph_mod.deinit(&graph);467    try graph_mod.addNode(&graph, .{ .name = "app", .type = model.NodeType.module });468    try graph_mod.addNode(&graph, .{ .name = "app.main", .type = model.NodeType.function });469    try graph_mod.addNode(&graph, .{ .name = "lib.util", .type = model.NodeType.function });470    try graph_mod.addEdge(&graph, .{ .source = "app", .rel = model.RelType.contains, .target = "app.main" });471    try graph_mod.addEdge(&graph, .{ .source = "app.main", .rel = model.RelType.calls, .target = "lib.util" });472    const matches = try resolve(graph, allocator, "main");473    defer allocator.free(matches);474    try std.testing.expectEqual(@as(usize, 1), matches.len);475    try std.testing.expectEqualStrings("app.main", try resolveOne(graph, allocator, "main"));476    const incoming_edges = try incoming(graph, allocator, "app.main", null);477    defer allocator.free(incoming_edges);478    const outgoing_edges = try outgoing(graph, allocator, "app.main", null);479    defer allocator.free(outgoing_edges);480    const nodes = try allNodes(graph, allocator, null);481    defer allocator.free(nodes);482    const edges = try allEdges(graph, allocator);483    defer allocator.free(edges);484    const issues = try validate(graph, allocator);485    defer {486        freeStrings(allocator, issues);487        allocator.free(issues);488    }489    var scoped = try scopePrefix(graph, allocator, "app");490    defer graph_mod.deinit(&scoped);491    try std.testing.expectEqual(@as(usize, 2), scoped.nodes.items.len);492}493494test "validate returns owned issue strings" {495    var graph = graph_mod.init(std.testing.allocator);496    defer graph_mod.deinit(&graph);497    try graph.edges.append(std.testing.allocator, .{498        .source = "missing",499        .rel = model.RelType.calls,500        .target = "also_missing",501    });502    const issues = try validate(graph, std.testing.allocator);503    defer {504        freeStrings(std.testing.allocator, issues);505        std.testing.allocator.free(issues);506    }507    try std.testing.expectEqual(@as(usize, 2), issues.len);508}509510test "incoming edges sort by relationship then source" {511    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);512    defer arena.deinit();513    const allocator = arena.allocator();514    var graph = graph_mod.init(allocator);515    try graph_mod.addNode(&graph, .{ .name = "target", .type = model.NodeType.function });516    try graph_mod.addNode(&graph, .{ .name = "owner", .type = model.NodeType.module });517    try graph_mod.addNode(&graph, .{ .name = "caller", .type = model.NodeType.function });518    try graph_mod.addEdge(&graph, .{ .source = "owner", .rel = model.RelType.contains, .target = "target" });519    try graph_mod.addEdge(&graph, .{ .source = "caller", .rel = model.RelType.calls, .target = "target" });520    const incoming_edges = try incoming(graph, allocator, "target", null);521    try std.testing.expectEqualStrings(model.RelType.calls, incoming_edges[0].rel);522    try std.testing.expectEqualStrings("caller", incoming_edges[0].source);523    try std.testing.expectEqualStrings(model.RelType.contains, incoming_edges[1].rel);524    try std.testing.expectEqualStrings("owner", incoming_edges[1].source);525}526527test "scope prefix keeps matching nodes and internal edges" {528    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);529    defer arena.deinit();530    const allocator = arena.allocator();531    var graph = graph_mod.init(allocator);532    try graph_mod.addNode(&graph, .{ .name = "app", .type = model.NodeType.module });533    try graph_mod.addNode(&graph, .{ .name = "app.main", .type = model.NodeType.function });534    try graph_mod.addNode(&graph, .{ .name = "lib", .type = model.NodeType.module });535    try graph_mod.addNode(&graph, .{ .name = "lib.util", .type = model.NodeType.function });536    try graph_mod.addEdge(&graph, .{ .source = "app", .rel = model.RelType.contains, .target = "app.main" });537    try graph_mod.addEdge(&graph, .{ .source = "app.main", .rel = model.RelType.calls, .target = "lib.util" });538    const scoped = try scopePrefix(graph, allocator, "app");539    try std.testing.expectEqual(@as(usize, 2), scoped.nodes.items.len);540    try std.testing.expectEqual(@as(usize, 1), scoped.edges.items.len);541    try std.testing.expect(graph_mod.getNode(&scoped, "app") != null);542    try std.testing.expect(graph_mod.getNode(&scoped, "app.main") != null);543}