bashrs 6.66.0

Rust-to-Shell transpiler for deterministic bootstrap scripts
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

impl Default for CfgBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// Write a padded line inside box borders: `║<content padded to inner>║\n`
fn write_box_line(out: &mut String, content: &str, inner: usize) {
    out.push('║');
    out.push_str(content);
    for _ in 0..inner.saturating_sub(content.len()) {
        out.push(' ');
    }
    out.push_str("║\n");
}

/// Write a horizontal rule: `<left><fill * inner><right>\n`
fn write_hrule(out: &mut String, left: char, fill: char, right: &str, inner: usize) {
    out.push(left);
    for _ in 0..inner {
        out.push(fill);
    }
    out.push_str(right);
    out.push('\n');
}

/// ASCII CFG visualization (ML-017)
pub fn render_cfg_ascii(
    cfg: &ControlFlowGraph,
    metrics: &ComplexityMetrics,
    width: usize,
) -> String {
    let mut out = String::new();
    let inner = width - 2;

    write_hrule(&mut out, '╔', '═', "╗", inner);

    // Title centered
    let title = "CONTROL FLOW GRAPH";
    let padding = (inner.saturating_sub(title.len())) / 2;
    let mut title_line = String::new();
    for _ in 0..padding {
        title_line.push(' ');
    }
    title_line.push_str(title);
    for _ in 0..(inner - padding - title.len()) {
        title_line.push(' ');
    }
    write_box_line(&mut out, &title_line, inner);

    write_hrule(&mut out, '╠', '═', "╣", inner);

    // Entry node
    let entry_lines = [
        "                          ┌─────────┐",
        "                          │  ENTRY  │",
        "                          └────┬────┘",
        "                               │",
    ];
    for line in &entry_lines {
        write_box_line(&mut out, line, inner);
    }

    // Show conditional if present
    if metrics.decision_points > 0 {
        let cond_lines = [
            "                          ┌────▼────┐",
            "                          │ if cond │",
            "                          └────┬────┘",
            "                     ┌────────┼────────┐",
            "                     │ TRUE   │  FALSE │",
            "                     └────────┼────────┘",
            "                               │",
        ];
        for line in &cond_lines {
            write_box_line(&mut out, line, inner);
        }
    }

    // Exit node
    let exit_lines = [
        "                          ┌───▼────┐",
        "                          │  EXIT  │",
        "                          └────────┘",
    ];
    for line in &exit_lines {
        write_box_line(&mut out, line, inner);
    }

    // Metrics section
    write_hrule(&mut out, '╠', '═', "╣", inner);

    let metrics_line = format!(
        "  Nodes: {} │ Edges: {} │ Cyclomatic: {} │ Essential: {} │ Max Depth: {}",
        cfg.node_count(),
        cfg.edge_count(),
        metrics.cyclomatic,
        metrics.essential,
        metrics.max_depth
    );
    let truncated = if metrics_line.len() > inner {
        &metrics_line[..inner]
    } else {
        &metrics_line
    };
    write_box_line(&mut out, truncated, inner);

    write_hrule(&mut out, '╚', '═', "╝", inner);

    out
}

#[cfg(test)]
#[path = "cfg_tests_ml_015.rs"]
mod tests_extracted;