fhp-core 0.1.1

Core types for the HTML parser: interned tags, entity table, error types
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

/// Errors that can occur during HTML parsing.
#[derive(Debug, thiserror::Error)]
pub enum ParseError {
    /// Encountered an unexpected byte during tokenization.
    #[error("unexpected byte 0x{byte:02X} at offset {offset}")]
    UnexpectedByte {
        /// The byte value encountered.
        byte: u8,
        /// The byte offset in the input.
        offset: usize,
    },

    /// The input ended in the middle of a token.
    #[error("unexpected end of input at offset {offset}, state: {state}")]
    UnexpectedEof {
        /// The byte offset where input ended.
        offset: usize,
        /// Description of the tokenizer state when EOF was hit.
        state: &'static str,
    },

    /// A nesting depth limit was exceeded.
    #[error("nesting depth limit exceeded ({depth} > {limit})")]
    NestingTooDeep {
        /// Current depth.
        depth: u32,
        /// Configured limit.
        limit: u32,
    },
}

/// Errors that can occur during CSS selector parsing.
#[derive(Debug, thiserror::Error)]
pub enum SelectorError {
    /// Invalid selector syntax.
    #[error("invalid selector: {reason}")]
    Invalid {
        /// Description of what went wrong.
        reason: String,
    },
}

/// Errors that can occur during XPath expression parsing or evaluation.
#[derive(Debug, thiserror::Error)]
pub enum XPathError {
    /// Invalid XPath syntax.
    #[error("invalid xpath: {reason}")]
    Invalid {
        /// Description of what went wrong.
        reason: String,
    },
}

/// Errors that can occur during encoding detection or conversion.
#[derive(Debug, thiserror::Error)]
pub enum EncodingError {
    /// The decoder encountered bytes that could not be mapped to Unicode.
    #[error("decode error: malformed {encoding} input at byte offset {offset}")]
    MalformedInput {
        /// Name of the encoding being decoded.
        encoding: &'static str,
        /// Approximate byte offset of the first invalid sequence.
        offset: usize,
    },
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_error_display() {
        let err = ParseError::UnexpectedByte {
            byte: 0xFF,
            offset: 42,
        };
        assert_eq!(err.to_string(), "unexpected byte 0xFF at offset 42");
    }

    #[test]
    fn selector_error_display() {
        let err = SelectorError::Invalid {
            reason: "unclosed bracket".to_string(),
        };
        assert_eq!(err.to_string(), "invalid selector: unclosed bracket");
    }

    #[test]
    fn xpath_error_display() {
        let err = XPathError::Invalid {
            reason: "unexpected token".to_string(),
        };
        assert_eq!(err.to_string(), "invalid xpath: unexpected token");
    }

    #[test]
    fn encoding_error_display() {
        let err = EncodingError::MalformedInput {
            encoding: "windows-1252",
            offset: 42,
        };
        assert_eq!(
            err.to_string(),
            "decode error: malformed windows-1252 input at byte offset 42"
        );
    }

    #[test]
    fn nesting_error_display() {
        let err = ParseError::NestingTooDeep {
            depth: 513,
            limit: 512,
        };
        assert_eq!(err.to_string(), "nesting depth limit exceeded (513 > 512)");
    }
}