spandex 0.0.2

A modern LaTeX alternative
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
135
136
137
138
139
140
141
142

//! This module contains everything related to parsing errors.

use std::error::Error;
use std::fmt;
use std::path::PathBuf;

use colored::*;

use crate::parser::utils::{next_new_line, previous_new_line, replicate};
use crate::parser::Position;

/// The different types errors that can occur while parsing.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ErrorType {
    /// A star for bold content is unmatched.
    UnmatchedStar,

    /// A slash for italic content is unmatched.
    UnmatchedSlash,

    /// A dollar for a inlinemath is unmatched.
    UnmatchedDollar,

    /// A title is on multiple lines.
    MultipleLinesTitle,
}

impl ErrorType {
    /// Returns the title of the error.
    pub fn title(self) -> &'static str {
        match self {
            ErrorType::UnmatchedStar => "unmatched *",
            ErrorType::UnmatchedSlash => "unmactched /",
            ErrorType::UnmatchedDollar => "unmactched $",
            ErrorType::MultipleLinesTitle => "titles must be followed by an empty line",
        }
    }

    /// Returns the detail of the error.
    pub fn detail(self) -> &'static str {
        match self {
            ErrorType::UnmatchedStar => "bold content starts here but never ends",
            ErrorType::UnmatchedSlash => "italic content starts here but never ends",
            ErrorType::UnmatchedDollar => "inline inlinemath starts here but never ends",
            ErrorType::MultipleLinesTitle => "expected empty line here",
        }
    }

    /// Returns an optional note.
    pub fn note(self) -> Option<&'static str> {
        match self {
            ErrorType::UnmatchedStar => None,
            ErrorType::UnmatchedSlash => None,
            ErrorType::UnmatchedDollar => None,
            ErrorType::MultipleLinesTitle => None,
        }
    }
}

/// An error that occured during the parsing.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EmptyError {
    /// The position of the error.
    pub position: Position,

    /// The type of the error.
    pub ty: ErrorType,
}

/// A struct that contains many errors that references a file.
#[derive(Debug)]
pub struct Errors {
    /// The path to the corresponding file.
    pub path: PathBuf,

    /// The content that produced the errors.
    pub content: String,

    /// The errors that were produced.
    pub errors: Vec<EmptyError>,
}

impl fmt::Display for Errors {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        for error in &self.errors {
            let start = previous_new_line(&self.content, error.position.offset);
            let end = next_new_line(&self.content, error.position.offset);

            let line = error.position.line;
            let column = error.position.column;

            let line_number = format!("{} ", line);
            let space = replicate(' ', line_number.len() - 1);
            let margin = replicate(' ', column);
            let hats = replicate('^', 1);

            writeln!(fmt, "{}{}", "error: ".bold().red(), error.ty.title().bold())?;

            writeln!(
                fmt,
                "{}{} {}:{}:{}",
                space,
                "-->".bold().blue(),
                self.path.display(),
                line,
                column
            )?;

            writeln!(fmt, "{} {}", space, "|".blue().bold())?;
            writeln!(
                fmt,
                "{} {}",
                &format!("{}|", line_number).blue().bold(),
                &self.content[start..end]
            )?;
            writeln!(
                fmt,
                "{} {}{}{} {}",
                space,
                "|".blue().bold(),
                margin,
                hats.bold().red(),
                error.ty.detail().bold().red()
            )?;
            writeln!(fmt, "{} {}", space, "|".blue().bold())?;
            if let Some(note) = error.ty.note() {
                writeln!(
                    fmt,
                    "{} {} {}{}",
                    space,
                    "=".blue().bold(),
                    "note: ".bold(),
                    note
                )?;
            }
        }

        Ok(())
    }
}

impl Error for Errors {}