weavatrix-rust 2.14.3

Protocol-independent Rust repository intelligence: typed evidence graphs for impact, architecture, APIs, Git, search, and memory
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
90
91
92
93
94
95
96

use super::resolve::binding_row;
use super::view::{domain_name, owned_domains};
use crate::engine::RepositoryState;
use blazingly_json::{Value, json};
use weavatrix_graph::Node;

pub(in crate::operations) fn affected(
    state: &RepositoryState,
    files: &[String],
    impacts: &[Value],
) -> Vec<Value> {
    let mut rows = Vec::new();
    for node in state
        .graph()
        .nodes()
        .iter()
        .filter(|node| node.kind.as_str() == "mermaid.diagram")
    {
        if file_changed(node, files) {
            rows.push(json!({
                "diagram": node.label,
                "element": Value::Null,
                "reason": "diagram source is in the changed files",
                "not_proven": ["runtime equivalence of the drawn graph"]
            }));
        }
    }
    for node in state
        .graph()
        .nodes()
        .iter()
        .filter(|node| node.kind.as_str() == "mermaid.binding")
    {
        let binding = binding_row(state, node);
        if binding["status"] != "exact" {
            continue;
        }
        let hit = binding["targets"]
            .as_array()
            .into_iter()
            .flatten()
            .any(|target| file_label_changed(target, files) || impact_hit(target, impacts));
        if hit {
            rows.push(json!({
                "diagram": binding["diagram"],
                "element": binding["element"],
                "reason": "explicit sidecar binding to a changed symbol",
                "check": neighbors(state, binding["element"].as_str()),
                "not_proven": ["the drawn arrow is implemented"]
            }));
        }
    }
    rows
}

fn file_changed(node: &Node, files: &[String]) -> bool {
    node.span.as_ref().is_some_and(|span| {
        files
            .iter()
            .any(|file| span.file == *file || span.file.ends_with(file))
    })
}

fn file_label_changed(target: &Value, files: &[String]) -> bool {
    target["span"]["file"].as_str().is_some_and(|path| {
        files
            .iter()
            .any(|file| path == file || path.ends_with(file))
    })
}

fn impact_hit(target: &Value, impacts: &[Value]) -> bool {
    let id = target["id"].as_str();
    let label = target["label"].as_str();
    impacts
        .iter()
        .any(|item| item["id"].as_str() == id || item["label"].as_str() == label)
}

fn neighbors(state: &RepositoryState, element: Option<&str>) -> Vec<String> {
    let Some(element) = element else {
        return Vec::new();
    };
    let Some(node) = state
        .graph()
        .nodes()
        .iter()
        .find(|node| node.kind.as_str() == "mermaid.element" && node.label == element)
    else {
        return Vec::new();
    };
    owned_domains(state, node.id.as_str())
        .iter()
        .filter_map(|item| domain_name(std::slice::from_ref(item), "label:"))
        .collect()
}