nested-text 0.1.0

A fully spec-compliant NestedText v3.8 parser and serializer
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

use std::fmt;

#[derive(Debug, Clone, PartialEq)]
pub enum ErrorKind {
    // Lexer errors
    InvalidIndentation,
    TabInIndentation,
    // Parser errors
    UnrecognizedLine,
    UnexpectedLineType,
    DuplicateKey,
    InvalidIndentLevel,
    // Inline errors
    UnterminatedInlineList,
    UnterminatedInlineDict,
    InvalidInlineCharacter,
    TrailingContent,
    // Dump errors
    UnsupportedType,
    // IO
    Io,
}

/// Error type with location information matching the NestedText test suite format.
#[derive(Debug, Clone)]
pub struct Error {
    pub kind: ErrorKind,
    pub message: String,
    /// 0-based line number where the error occurred.
    pub lineno: Option<usize>,
    /// 0-based column number where the error occurred.
    pub colno: Option<usize>,
    /// The source line that caused the error.
    pub line: Option<String>,
}

impl Error {
    pub fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
        Error {
            kind,
            message: message.into(),
            lineno: None,
            colno: None,
            line: None,
        }
    }

    pub fn with_location(mut self, lineno: usize, colno: usize, line: impl Into<String>) -> Self {
        self.lineno = Some(lineno);
        self.colno = Some(colno);
        self.line = Some(line.into());
        self
    }

    pub fn with_lineno(mut self, lineno: usize) -> Self {
        self.lineno = Some(lineno);
        self
    }

    pub fn with_line(mut self, line: impl Into<String>) -> Self {
        self.line = Some(line.into());
        self
    }

    pub fn with_colno(mut self, colno: usize) -> Self {
        self.colno = Some(colno);
        self
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(lineno) = self.lineno {
            write!(f, "line {}: {}", lineno, self.message)
        } else {
            write!(f, "{}", self.message)
        }
    }
}

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

impl From<std::io::Error> for Error {
    fn from(e: std::io::Error) -> Self {
        Error::new(ErrorKind::Io, e.to_string())
    }
}