lini 1.0.0-alpha.0

Pretty diagrams, charts, and technical drawings from plain text, with fine-grained control. Compiles to clean, themeable SVG.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::span::{Span, line_col};
use std::fmt;

#[derive(Debug)]
pub struct Error {
    pub message: String,
    pub span: Span,
    /// A secondary span rendered inline as `(previously at L:C)` — used for
    /// duplicate-definition diagnostics [SPEC 20]. Only shown with source.
    pub related: Option<Span>,
}

impl Error {
    pub fn at(span: Span, message: impl Into<String>) -> Self {
        Self {
            message: message.into(),
            span,
            related: None,
        }
    }

    /// Attach the span of a prior definition, shown as `(previously at L:C)`.
    pub fn with_related(mut self, span: Span) -> Self {
        self.related = Some(span);
        self
    }

    pub fn display_with_source<'a>(
        &'a self,
        source: &'a str,
        filename: &'a str,
    ) -> ErrorDisplay<'a> {
        ErrorDisplay {
            err: self,
            source,
            filename,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "error: {}", self.message)
    }
}

impl std::error::Error for Error {}

pub struct ErrorDisplay<'a> {
    err: &'a Error,
    source: &'a str,
    filename: &'a str,
}

impl<'a> fmt::Display for ErrorDisplay<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (line, col) = line_col(self.source, self.err.span.start);
        write!(
            f,
            "{}:{}:{}: error: {}",
            self.filename, line, col, self.err.message
        )?;
        if let Some(related) = self.err.related {
            let (rl, rc) = line_col(self.source, related.start);
            write!(f, " (previously at {}:{})", rl, rc)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct Diagnostic {
    pub level: Level,
    pub message: String,
    pub span: Span,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Level {
    /// A hard diagnostic [SPEC 16/20] — the CLI fails on it like a compile error.
    Error,
    Warning,
}

impl Diagnostic {
    pub fn warn(span: Span, message: impl Into<String>) -> Self {
        Self {
            level: Level::Warning,
            message: message.into(),
            span,
        }
    }

    pub fn error(span: Span, message: impl Into<String>) -> Self {
        Self {
            level: Level::Error,
            message: message.into(),
            span,
        }
    }

    pub fn display_with_source<'a>(
        &'a self,
        source: &'a str,
        filename: &'a str,
    ) -> DiagnosticDisplay<'a> {
        DiagnosticDisplay {
            diag: self,
            source,
            filename,
        }
    }
}

pub struct DiagnosticDisplay<'a> {
    diag: &'a Diagnostic,
    source: &'a str,
    filename: &'a str,
}

impl<'a> fmt::Display for DiagnosticDisplay<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (line, col) = line_col(self.source, self.diag.span.start);
        let kind = match self.diag.level {
            Level::Error => "error",
            Level::Warning => "warning",
        };
        write!(
            f,
            "{}:{}:{}: {}: {}",
            self.filename, line, col, kind, self.diag.message
        )
    }
}