tiny.smg.scan.reconcile.projection

1const std = @import("std");2const sys = @import("sys");3const smg = @import("../../root.zig");4const reconcile = @import("root.zig");56const graph_mod = smg.graph;7const model = smg.model;8const scan_root = smg.scan;9const core = scan_root.core;1011pub const Plan = struct {12    files: []const []const u8,13    displaced_edges: []const model.Edge,14};1516pub fn clonePlan(allocator: std.mem.Allocator, plan: Plan) !Plan {17    const files = try allocator.alloc([]const u8, plan.files.len);18    var file_count: usize = 0;19    errdefer {20        for (files[0..file_count]) |file| allocator.free(file);21        allocator.free(files);22    }23    for (plan.files, 0..) |file, index| {24        files[index] = try allocator.dupe(u8, file);25        file_count += 1;26    }27    const edges = try allocator.alloc(model.Edge, plan.displaced_edges.len);28    var edge_count: usize = 0;29    errdefer {30        for (edges[0..edge_count]) |*edge| model.deinitEdge(edge, allocator);31        allocator.free(edges);32    }33    for (plan.displaced_edges, 0..) |edge, index| {34        edges[index] = try model.cloneEdge(allocator, edge);35        edge_count += 1;36    }37    return .{ .files = files, .displaced_edges = edges };38}3940pub fn prepare(41    allocator: std.mem.Allocator,42    graph: *graph_mod.Graph,43    root: []const u8,44    paths: []const []const u8,45    replace: bool,46    options: core.Options,47    stats: *core.Stats,48) !Plan {49    const selected = try reconcile.scope.collect(allocator, graph.*, root, paths, options);50    return .{51        .files = selected.files,52        .displaced_edges = try retire(allocator, graph, root, selected, replace, stats),53    };54}5556pub fn finish(allocator: std.mem.Allocator, graph: *graph_mod.Graph, plan: Plan, stats: *core.Stats) !void {57    for (plan.displaced_edges) |edge| {58        const source_exists = graph_mod.getNode(graph, edge.source) != null;59        const target_exists = graph_mod.getNode(graph, edge.target) != null;60        if (!source_exists and target_exists and hierarchyEdge(edge)) try ensurePackageHierarchy(allocator, graph, edge.target, stats);61    }62    for (plan.displaced_edges) |edge| {63        if (graph_mod.getNode(graph, edge.source) != null and graph_mod.getNode(graph, edge.target) != null) {64            _ = try graph_mod.addEdgeTracked(graph, edge);65            continue;66        }67        if (!manualEdge(edge)) continue;68        stats.edges_removed += 1;69        try stats.orphaned_manual_edges.append(allocator, .{70            .source = edge.source,71            .rel = edge.rel,72            .target = edge.target,73            .reason = if (graph_mod.getNode(graph, edge.source) == null) "source node removed" else "target node removed",74        });75    }76}7778fn retire(79    allocator: std.mem.Allocator,80    graph: *graph_mod.Graph,81    root: []const u8,82    selected: reconcile.scope.Scope,83    replace: bool,84    stats: *core.Stats,85) ![]const model.Edge {86    var live = std.StringHashMap(void).init(allocator);87    defer live.deinit();88    for (selected.files) |file| try live.put(file, {});89    var exact = std.StringHashMap(void).init(allocator);90    defer exact.deinit();91    for (selected.exact) |file| try exact.put(file, {});92    var existence = std.StringHashMap(bool).init(allocator);93    defer existence.deinit();94    var removed = std.StringHashMap(void).init(allocator);95    defer removed.deinit();96    var packages = std.StringHashMap(void).init(allocator);97    defer packages.deinit();9899    for (graph.nodes.items) |node| {100        if (!graph_mod.isScan(node.metadata)) continue;101        const file = node.file orelse continue;102        if (!try shouldRetireFile(allocator, root, selected, replace, file, live, exact, &existence)) continue;103        try removed.put(node.name, {});104        try addSyntheticPackageAncestors(allocator, graph.*, node.name, &packages);105    }106    try addEmptySyntheticPackages(graph.*, &removed, packages);107    if (removed.count() == 0) return &.{};108109    var displaced_edges: std.ArrayList(model.Edge) = .empty;110    for (graph.edges.items) |edge| {111        if (!removed.contains(edge.source) and !removed.contains(edge.target)) continue;112        if (manualEdge(edge) or !removed.contains(edge.source) or (!removed.contains(edge.target) and hierarchyEdge(edge))) try displaced_edges.append(allocator, edge);113    }114115    var names: std.ArrayList([]const u8) = .empty;116    for (graph.nodes.items) |node| if (removed.contains(node.name)) try names.append(allocator, node.name);117    try graph_mod.removeNodes(graph, names.items);118    stats.nodes_removed += names.items.len;119    return try displaced_edges.toOwnedSlice(allocator);120}121122fn shouldRetireFile(123    allocator: std.mem.Allocator,124    root: []const u8,125    selected: reconcile.scope.Scope,126    replace: bool,127    file: []const u8,128    live: std.StringHashMap(void),129    exact: std.StringHashMap(void),130    existence: *std.StringHashMap(bool),131) !bool {132    const selected_tree = scan_root.scan_files.underPrefixes(selected.trees, file);133    if (replace and (live.contains(file) or selected_tree)) return true;134    if (exact.contains(file)) return true;135    if (!selected_tree) return false;136    const entry = try existence.getOrPut(file);137    if (!entry.found_existing) {138        entry.value_ptr.* = exists: {139            const stat = sys.fs.statFile(try std.fs.path.join(allocator, &.{ root, file })) catch |err| switch (err) {140                error.FileNotFound, error.NotDir => break :exists false,141                else => return err,142            };143            break :exists stat.kind == .file;144        };145    }146    return !entry.value_ptr.*;147}148149fn manualEdge(edge: model.Edge) bool {150    return std.mem.eql(u8, model.pairValue(edge.metadata, "source") orelse "", "manual");151}152153fn hierarchyEdge(edge: model.Edge) bool {154    return std.mem.eql(u8, edge.rel, model.RelType.contains) and graph_mod.isScan(edge.metadata);155}156157pub fn ensurePackageHierarchy(allocator: std.mem.Allocator, graph: *graph_mod.Graph, module: []const u8, stats: *core.Stats) !void {158    var parts: std.ArrayList([]const u8) = .empty;159    var split = std.mem.splitScalar(u8, module, '.');160    while (split.next()) |part| try parts.append(allocator, part);161    if (parts.items.len < 2) return;162    var parent: ?[]const u8 = null;163    var index: usize = 0;164    while (index + 1 < parts.items.len) : (index += 1) {165        const current = try core.joinDotted(allocator, parts.items[0 .. index + 1]);166        if (graph_mod.getNode(graph, current) == null) {167            const meta = try model.sourcePair(allocator, "scan");168            try graph_mod.addNode(graph, .{ .name = current, .type = model.NodeType.package, .metadata = meta });169        }170        if (parent) |parent_name| {171            const meta = try model.sourcePair(allocator, "scan");172            try core.addScanEdge(graph, stats, .{ .source = parent_name, .rel = model.RelType.contains, .target = current, .metadata = meta });173        }174        parent = current;175    }176    if (parent) |parent_name| {177        const meta = try model.sourcePair(allocator, "scan");178        try core.addScanEdge(graph, stats, .{ .source = parent_name, .rel = model.RelType.contains, .target = module, .metadata = meta });179    }180}181182fn addSyntheticPackageAncestors(allocator: std.mem.Allocator, graph: graph_mod.Graph, name: []const u8, packages: *std.StringHashMap(void)) !void {183    for (graph_mod.incomingEdges(&graph, name)) |edge_index| {184        const edge = graph.edges.items[edge_index];185        if (!std.mem.eql(u8, edge.rel, model.RelType.contains)) continue;186        const parent = graph_mod.getNode(&graph, edge.source) orelse continue;187        if (!std.mem.eql(u8, parent.type, model.NodeType.package) or parent.file != null or !graph_mod.isScan(parent.metadata)) continue;188        const entry = try packages.getOrPut(parent.name);189        if (entry.found_existing) continue;190        try addSyntheticPackageAncestors(allocator, graph, parent.name, packages);191    }192}193194fn addEmptySyntheticPackages(graph: graph_mod.Graph, removed: *std.StringHashMap(void), packages: std.StringHashMap(void)) !void {195    var remaining = std.StringHashMap(usize).init(graph.allocator);196    defer remaining.deinit();197    var queue: std.ArrayList([]const u8) = .empty;198    defer queue.deinit(graph.allocator);199    var iterator = packages.iterator();200    while (iterator.next()) |entry| {201        const name = entry.key_ptr.*;202        var count: usize = 0;203        for (graph_mod.outgoingEdges(&graph, name)) |edge_index| {204            const edge = graph.edges.items[edge_index];205            if (std.mem.eql(u8, edge.rel, model.RelType.contains) and !removed.contains(edge.target)) count += 1;206        }207        try remaining.put(name, count);208        if (count == 0) try queue.append(graph.allocator, name);209    }210    var index: usize = 0;211    while (index < queue.items.len) : (index += 1) {212        const name = queue.items[index];213        if (removed.contains(name)) continue;214        try removed.put(name, {});215        for (graph_mod.incomingEdges(&graph, name)) |edge_index| {216            const edge = graph.edges.items[edge_index];217            if (!std.mem.eql(u8, edge.rel, model.RelType.contains)) continue;218            const count = remaining.getPtr(edge.source) orelse continue;219            if (count.* == 0) continue;220            count.* -= 1;221            if (count.* == 0) try queue.append(graph.allocator, edge.source);222        }223    }224}225226fn checkClonePlanAllocationFailures(allocator: std.mem.Allocator) !void {227    const metadata = [_]model.Pair{.{ .key = "source", .value = "manual" }};228    const edges = [_]model.Edge{.{229        .source = "manual",230        .rel = model.RelType.depends_on,231        .target = "app.main",232        .metadata = &metadata,233    }};234    const cloned = try clonePlan(allocator, .{235        .files = &.{ "app.py", "lib.py" },236        .displaced_edges = &edges,237    });238    defer {239        for (cloned.files) |file| allocator.free(file);240        allocator.free(cloned.files);241        for (@constCast(cloned.displaced_edges)) |*edge| model.deinitEdge(edge, allocator);242        allocator.free(cloned.displaced_edges);243    }244    try std.testing.expectEqualStrings("app.py", cloned.files[0]);245    try std.testing.expectEqualStrings("manual", cloned.displaced_edges[0].source);246}247248test "reconciliation plan clone cleans every allocation failure" {249    try std.testing.checkAllAllocationFailures(250        std.testing.allocator,251        checkClonePlanAllocationFailures,252        .{},253    );254}

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