nornir 0.4.22

Companion to cargo: dependency tracking, release gating, deploy, benchmarks, and documentation assembly. Project-agnostic.
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

//! Code introspection — derive structural docs from the *built* code.
//!
//! All extraction targets the compiled / parsed artifact, never
//! hand-maintained sources. The published documentation is then a
//! pure function of the code:
//!
//! ```text
//!     source code  ──cargo──►  rustdoc JSON ┐
//!     workspace    ──cargo──►  metadata     ├─► nornir::introspect ─► graphs
//!     src/**/*.rs  ──syn ───►  AST          ┘                       │
//!                                                                   ▼
//!                                                             nornir::docs
//!                                                                   │
//!                                                                   ▼
//!                                                    README / CLAUDE / docs/*
//! ```

pub mod api;
pub mod artifact;
pub mod callgraph;
pub mod callgraph_dwarf;
pub mod callgraph_llvm;
pub mod depgraph;
pub mod persist;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Edge {
    pub from: String,
    pub to: String,
    pub kind: EdgeKind,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum EdgeKind {
    Calls,
    DependsOn,
    Reexports,
    Implements,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Graph {
    pub nodes: Vec<String>,
    pub edges: Vec<Edge>,
}

impl Graph {
    pub fn to_mermaid(&self) -> String {
        let mut s = String::from("```mermaid\ngraph LR\n");
        for n in &self.nodes {
            s.push_str(&format!("  {}\n", sanitize(n)));
        }
        for e in &self.edges {
            let arrow = match e.kind {
                EdgeKind::Calls => "-->",
                EdgeKind::DependsOn => "-.->",
                EdgeKind::Reexports => "==>",
                EdgeKind::Implements => "--o",
            };
            s.push_str(&format!("  {} {} {}\n", sanitize(&e.from), arrow, sanitize(&e.to)));
        }
        s.push_str("```\n");
        s
    }
}

fn sanitize(s: &str) -> String {
    s.replace([':', '-', '.', '/'], "_")
}