cjkfmt 0.0.3

Formatter for CJK text files
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

//! The [`Diagnostic`] type for storing diagnostic information.
use core::fmt::Display;

use serde::{Deserialize, Serialize};
use yansi::Paint;

use crate::position::Position;

/// Diagnostic information for a single issue.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Diagnostic {
    /// The name of the file where the issue was detected.
    pub filename: Option<String>,

    /// The start position of the half-open range (inclusive) where the issue applies.
    pub start: Position,

    /// The end position of the half-open range (exclusive) where the issue applies.
    pub end: Position,

    /// A unique code identifying the issue.
    pub code: String,

    /// A human-readable message describing the issue.
    pub message: String,
}

impl Diagnostic {
    pub fn new<S: Into<String>>(
        filename: Option<S>,
        start: Position,
        end: Position,
        code: String,
        message: String,
    ) -> Self {
        Self {
            filename: filename.map(Into::into),
            start,
            end,
            code,
            message,
        }
    }
}

impl Display for Diagnostic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let filename = self.filename.as_deref().unwrap_or("<stdin>");
        let line = self.start.line;
        let column = self.start.column;
        let buf = format!(
            "{}\0{}\0{}\0{}\0{}",
            filename,
            line + 1,
            column + 1,
            self.code,
            self.message
        );
        let tokens: Vec<&str> = buf.split('\0').collect();
        let colon = ":".cyan();
        let filename = tokens[0].white().bold();
        let line = tokens[1];
        let column = tokens[2];
        let code = tokens[3].yellow();
        let message = tokens[4];
        write!(
            f,
            "{}{colon}{}{colon}{}{colon} {} {}",
            filename, line, column, code, message
        )
    }
}