weavatrix-rust 2.16.1

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

use crate::engine::RepositoryState;
use blazingly_json::{Value, json};
use weavatrix_graph::Node;

#[must_use]
pub(super) fn in_path(node: &Node, filter: &str) -> bool {
    node.span
        .as_ref()
        .is_some_and(|span| span.file.contains(filter))
        || node.label.contains(filter)
        || node.id.as_str().contains(filter)
}

#[must_use]
pub(super) fn owned_domains<'a>(state: &'a RepositoryState, owner: &str) -> Vec<&'a Node> {
    state
        .graph()
        .edges()
        .iter()
        .filter(|edge| edge.source.as_str() == owner && edge.kind.as_str() == "configures")
        .filter_map(|edge| state.graph().node(edge.target.as_str()))
        .collect()
}

#[must_use]
pub(super) fn domain_names(state: &RepositoryState, owner: &str) -> Vec<String> {
    owned_domains(state, owner)
        .into_iter()
        .map(|node| node.label.clone())
        .collect()
}

#[must_use]
pub(super) fn file_of(node: &Node) -> String {
    node.span
        .as_ref()
        .map(|span| span.file.clone())
        .unwrap_or_default()
}

#[must_use]
pub(super) fn consumers_of(state: &RepositoryState, target: &str) -> Vec<Value> {
    state
        .graph()
        .edges()
        .iter()
        .filter(|edge| edge.target.as_str() == target && edge.kind.as_str() == "web3.binds")
        .filter_map(|edge| {
            let source = state.graph().node(edge.source.as_str())?;
            Some(json!({
                "id": source.id,
                "label": source.label,
                "kind": source.kind,
                "file": file_of(source),
                "binding": binding_status(state, source),
                "span": source.span
            }))
        })
        .collect()
}

#[must_use]
pub(super) fn binding_status(state: &RepositoryState, node: &Node) -> String {
    domain_names(state, node.id.as_str())
        .into_iter()
        .find_map(|name| name.strip_prefix("web3.binding:").map(str::to_owned))
        .unwrap_or_else(|| "unresolved".to_owned())
}

#[must_use]
pub(super) fn coverage(state: &RepositoryState) -> Value {
    let decode = state
        .snapshot()
        .diagnostics
        .iter()
        .any(|item| item.code.starts_with("web3."));
    json!({
        "sourceBinding": if decode { "partial" } else { "supplied" },
        "consumerBindings": "partial",
        "deployment": "not_provided",
        "runtime": { "provided": false }
    })
}