the-code-graph-domain 0.1.2

Core domain types and traits for The Code Graph
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use crate::model::*;
use crate::traversal::InMemoryGraph;

/// Compute blast radius from a set of impact targets.
/// For Symbol targets: BFS forward from the symbol.
/// For File targets: BFS forward from the file node (which typically has Contains edges to symbols).
pub fn compute_blast_radius(
    graph: &InMemoryGraph,
    targets: &[ImpactTarget],
    max_depth: usize,
    min_confidence: Confidence,
) -> ImpactReport {
    let mut all_affected = Vec::new();

    for target in targets {
        let start = match target {
            ImpactTarget::Symbol(s) => s.as_str(),
            ImpactTarget::File(p) => p.to_str().unwrap_or_default(),
        };
        let results = graph.bfs_filtered(start, Direction::Forward, max_depth, min_confidence);
        for r in results {
            all_affected.push(AffectedNode {
                qualified_name: r.node,
                depth: r.depth,
                confidence: r.edge_kind.confidence(),
                path: r.path,
            });
        }
    }

    ImpactReport {
        targets: targets.to_vec(),
        affected: all_affected,
        depth: max_depth,
        min_confidence,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::traversal::InMemoryGraph;

    #[test]
    fn blast_radius_from_single_symbol() {
        let edges = vec![
            Edge {
                kind: EdgeKind::Calls,
                source: "a::foo".into(),
                target: "b::bar".into(),
                metadata: None,
            },
            Edge {
                kind: EdgeKind::Calls,
                source: "b::bar".into(),
                target: "c::baz".into(),
                metadata: None,
            },
        ];
        let graph = InMemoryGraph::from_edges(edges);
        let targets = vec![ImpactTarget::Symbol("a::foo".into())];
        let report = compute_blast_radius(&graph, &targets, 3, Confidence::Structural);
        assert!(!report.affected.is_empty());
        assert!(report.affected.iter().any(|n| n.qualified_name == "b::bar"));
        assert!(report.affected.iter().any(|n| n.qualified_name == "c::baz"));
    }

    #[test]
    fn blast_radius_from_file_target() {
        let edges = vec![
            Edge {
                kind: EdgeKind::Contains,
                source: "a.rs".into(),
                target: "a.rs::foo".into(),
                metadata: None,
            },
            Edge {
                kind: EdgeKind::Calls,
                source: "a.rs::foo".into(),
                target: "b.rs::bar".into(),
                metadata: None,
            },
        ];
        let graph = InMemoryGraph::from_edges(edges);
        let targets = vec![ImpactTarget::File("a.rs".into())];
        let report = compute_blast_radius(&graph, &targets, 3, Confidence::Structural);
        assert!(!report.targets.is_empty());
    }
}