enki-anu 0.2.2

BorrowEngine, task recording, and pipeline synthesis for the Enki runtime
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
97
98
99
100
101
102
103
104
105

use super::gutter::Gutter;
use super::theme::Theme;
use crate::diagnostics::catalog::DiagnosticTemplate;
use crate::diagnostics::source::{Role, SourceCache, Span};
use std::path::Path;

fn format_display_path(path: &Path) -> String {
    if let Ok(cwd) = std::env::current_dir() {
        if let Ok(rel) = path.strip_prefix(&cwd) {
            return rel.display().to_string();
        }
        if let Ok(canon_cwd) = cwd.canonicalize() {
            if let Ok(canon_path) = path.canonicalize() {
                if let Ok(rel) = canon_path.strip_prefix(&canon_cwd) {
                    return rel.display().to_string();
                }
            }
        }
    }
    if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
        let manifest_path = Path::new(&manifest_dir);
        if let Ok(rel) = path.strip_prefix(manifest_path) {
            return rel.display().to_string();
        }
    }
    path.display().to_string()
}

pub fn render_snippets(
    spans: &[Span],
    template: &DiagnosticTemplate,
    cache: &SourceCache,
    gutter: &Gutter,
    theme: &Theme,
) -> String {
    if spans.is_empty() {
        return String::new();
    }

    let mut out = String::with_capacity(512);

    let primary = spans.iter().find(|s| s.is_primary()).unwrap_or(&spans[0]);
    let file_str = format_display_path(&primary.file_path);
    let pos_str = format!("{}:{}:{}", file_str, primary.line, primary.column);

    out.push_str(&gutter.arrow_header(theme, &pos_str));
    out.push('\n');
    out.push_str(&gutter.empty_bar(theme));
    out.push('\n');

    let mut sorted_spans = spans.to_vec();
    sorted_spans.sort_by_key(|s| s.line);

    let mut last_line = 0;

    for span in &sorted_spans {
        if last_line != 0 && span.line > last_line + 1 {
            out.push_str(&gutter.dots_bar(theme));
            out.push('\n');
        }

        if let Some(line_info) = cache.get_formatted_line(span) {
            out.push_str(&gutter.line_bar(span.line, theme));
            out.push(' ');
            out.push_str(&line_info.text);
            out.push('\n');

            let indent = " ".repeat(line_info.visual_column.saturating_sub(1));
            out.push_str(&gutter.empty_bar(theme));
            out.push(' ');
            out.push_str(&indent);

            match span.role {
                Role::Primary => {
                    let carets =
                        theme.carets_for_severity(template.severity, line_info.visual_length);
                    let label = theme.label_for_severity(template.severity, template.primary_label);
                    out.push_str(&carets);
                    if !template.primary_label.is_empty() {
                        out.push(' ');
                        out.push_str(&label);
                    }
                }
                Role::Secondary => {
                    let dashes = theme.secondary_carets(line_info.visual_length);
                    out.push_str(&dashes);
                    if let Some(sec_label) = template.secondary_label {
                        if !sec_label.is_empty() {
                            out.push(' ');
                            out.push_str(&theme.secondary_label(sec_label));
                        }
                    }
                }
            }
            out.push('\n');
        }

        last_line = span.line;
    }

    out.push_str(&gutter.empty_bar(theme));
    out.push('\n');

    out
}