toml-parse 0.2.11

Set of modules for parsing, sorting and formating toml.
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

use std::io;
use std::num::{ParseFloatError, ParseIntError};

use chrono::format::ParseError as ChronoParseError;

pub type TomlResult<T> = Result<T, ParseTomlError>;

#[derive(PartialEq)]
pub enum TomlErrorKind {
    UnexpectedToken { tkn: String, ln: usize, col: usize },
    DateError,
    NumberError,
    InternalParseError(String),
}

#[derive(PartialEq)]
pub struct ParseTomlError {
    pub(super) kind: TomlErrorKind,
    pub(super) info: String,
}

impl ParseTomlError {
    pub fn new(s: String, t_err: TomlErrorKind) -> ParseTomlError {
        ParseTomlError {
            kind: t_err,
            info: s,
        }
    }
}

impl From<io::Error> for ParseTomlError {
    fn from(e: io::Error) -> ParseTomlError {
        let msg = e.to_string();
        ParseTomlError::new(
            msg,
            TomlErrorKind::InternalParseError("? opperator returned error".to_owned()),
        )
    }
}

impl From<ParseTomlError> for io::Error {
    fn from(e: ParseTomlError) -> io::Error {
        io::Error::new(io::ErrorKind::Other, e.info)
    }
}

impl From<chrono::format::ParseError> for ParseTomlError {
    fn from(e: ChronoParseError) -> ParseTomlError {
        let msg = e.to_string();
        ParseTomlError::new(msg, TomlErrorKind::DateError)
    }
}

impl From<ParseFloatError> for ParseTomlError {
    fn from(e: ParseFloatError) -> ParseTomlError {
        let msg = e.to_string();
        ParseTomlError::new(msg, TomlErrorKind::NumberError)
    }
}

impl From<ParseIntError> for ParseTomlError {
    fn from(e: ParseIntError) -> ParseTomlError {
        let msg = e.to_string();
        ParseTomlError::new(msg, TomlErrorKind::NumberError)
    }
}

impl std::error::Error for ParseTomlError {
    fn description(&self) -> &str {
        self.info.as_str()
    }
}

impl std::fmt::Debug for ParseTomlError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self)
    }
}

impl std::fmt::Display for ParseTomlError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        let span = match &self.kind {
            TomlErrorKind::InternalParseError(span) => span.into(),
            TomlErrorKind::UnexpectedToken { tkn, ln, col } => {
                format!("{} at ln {}, col {}", tkn, ln, col)
            }
            TomlErrorKind::DateError => "an invalid date-time".into(),
            TomlErrorKind::NumberError => "an invalid number".into(),
        };
        write!(f, "{}, found {}", self.info, span)
    }
}