nbf 1.1.0

Draft implementation of the Nested Blocks Format, which is a human-friendly text format for expressing nested or hierarchical data.
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

//! Module containing the error definitions of the parser.

use std::error::Error;
use std::fmt::{
    Display,
    Formatter,
    Result,
};

/// A parsing error which indicates its line of origin in the text as well as
/// the type of error.
#[ derive( Debug ) ]
pub struct ParsingError<ExternalErrorType>
where
    ExternalErrorType: Display + Error {

    line: usize,
    keyword: ParsingErrorType<ExternalErrorType>
}

impl<ExternalErrorType> ParsingError<ExternalErrorType>
where
    ExternalErrorType: Display + Error {

    pub fn new(
        line: usize,
        keyword: ParsingErrorType<ExternalErrorType>
    ) -> ParsingError<ExternalErrorType> {
        ParsingError {
            line,
            keyword
        }
    }
}

impl<ExternalErrorType> Error for ParsingError<ExternalErrorType>
where
    ExternalErrorType: Display + Error + 'static {

    fn source( &self ) -> Option< &( dyn Error + 'static ) > {
        if let ParsingErrorType::External( external_error ) = &self.keyword {
            Some( external_error )
        } else {
            None
        }
    }
}

/// Allows for simple printing of error information.
impl<ExternalErrorType> Display for ParsingError<ExternalErrorType>
where
    ExternalErrorType: Display + Error {

    fn fmt( &self, f: &mut Formatter<'_> ) -> Result {
        write!( f,
            "Error in line {}: {}",
            // Convert zero-based line to line counting common in text editors.
            self.line + 1,
            self.keyword,
        )
    }
}

/// The type of a parsing error.
#[ derive( Debug ) ]
pub enum ParsingErrorType<ExternalErrorType>
where
    ExternalErrorType: Display + Error {

    /// Only one kind of curly brakets is allowed per line, which has been
    /// violated when this variant occurs.
    BothBraketsInLine,
    /// A closing braket has been found where it was not expected.
    IsolatedClosingBraket,
    /// A colon is missing between type and name of an element.
    MissingColon,
    /// Type unknown to its parent.
    UnknownKeyword( String ),
    /// Missing child keyword.
    MissingChild( String ),
    /// Failed to parse a value.
    FailedParsingValue,
    /// A custom type for handling parsing errors.
    External( ExternalErrorType ),
}

/// Allows for simple printing of error information.
impl<ExternalErrorType> Display for ParsingErrorType<ExternalErrorType>
where
    ExternalErrorType: Display + Error {

    fn fmt( &self, f: &mut Formatter<'_> ) -> Result {
        
        if let ParsingErrorType::External( custom_error ) = self {
            Display::fmt( custom_error, f )?
        }

        write!( f, "{}",
            match self {
                ParsingErrorType::BothBraketsInLine =>
                    "Only an opening or a closing braket is allowed in a single line."
                        .to_owned(),
                ParsingErrorType::IsolatedClosingBraket =>
                    "Found an orphaned closing braket, for which no opening braket exists."
                        .to_owned(),
                ParsingErrorType::MissingColon =>
                    "A colon between the keyword and value is missing."
                        .to_owned(),
                ParsingErrorType::UnknownKeyword( keyword ) =>
                    format!(
                        "Unknown keyword: \"{}\"",
                        keyword,
                    ),
                ParsingErrorType::MissingChild( keyword ) =>
                    format!(
                        "The keyword \"{}\" is missing.",
                        keyword,
                    ),
                ParsingErrorType::FailedParsingValue =>
                    "Failed to parse the given value."
                        .to_owned(),
                // Handled above already, because writing to the already mutably
                // borrowed formatter `f` here is not possible.
                ParsingErrorType::External( _ ) =>
                    "".to_owned(),
            }
        )
    }
}