htmls 0.1.8

This is a library for parsing HTML and extracting HTML elements or text.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::error::Error;
use std::fmt;

/// Parser error types
#[derive(Debug, Clone, PartialEq)]
pub enum ParseErrorKind {
    /// Unexpected token encountered
    UnexpectedToken,

    /// Invalid selector value
    InvalidSelectorValue,

    /// Nesting level too deep
    NestingTooDeep,

    /// Other syntax errors
    SyntaxError,
    
    /// Multiple text query directives
    MultipleTextSelectors,
    
    /// Element query directive after text query directive
    ElementAfterTextSelector,
}

impl fmt::Display for ParseErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseErrorKind::UnexpectedToken => write!(f, "Unexpected token"),
            ParseErrorKind::InvalidSelectorValue => write!(f, "Invalid selector value"),
            ParseErrorKind::NestingTooDeep => write!(f, "Nesting level too deep"),
            ParseErrorKind::SyntaxError => write!(f, "Syntax error"),
            ParseErrorKind::MultipleTextSelectors => write!(f, "Multiple text query directives"),
            ParseErrorKind::ElementAfterTextSelector => write!(f, "Element query after text query"),
        }
    }
}

/// Parse error
#[derive(Debug, Clone)]
pub struct ParseError {
    /// Error type
    pub kind: ParseErrorKind,

    /// Error message
    pub message: String,

    /// Line number where the error occurred
    pub line: usize,

    /// Column number where the error occurred
    pub column: usize,

    /// Error recovery hint
    pub recovery_hint: Option<String>,
}

impl ParseError {
    /// Create a new parse error
    #[allow(dead_code)]
    pub fn new(
        kind: ParseErrorKind,
        message: String,
        line: usize,
        column: usize,
        recovery_hint: Option<String>,
    ) -> Self {
        ParseError {
            kind,
            message,
            line,
            column,
            recovery_hint,
        }
    }

    /// Create an unexpected token error
    pub fn unexpected_token(expected: &str, found: &str, line: usize, column: usize) -> Self {
        ParseError {
            kind: ParseErrorKind::UnexpectedToken,
            message: format!("Expected {} but found {}", expected, found),
            line,
            column,
            recovery_hint: Some(format!("Please check if {} is missing here", expected)),
        }
    }

    pub fn syntax_error(msg: &str, line: usize, column: usize) -> Self {
        ParseError {
            kind: ParseErrorKind::SyntaxError,
            message: msg.to_string(),
            line,
            column,
            recovery_hint: None,
        }
    }


    /// Create an invalid selector value error
    pub fn invalid_selector_value(value: &str, line: usize, column: usize) -> Self {
        ParseError {
            kind: ParseErrorKind::InvalidSelectorValue,
            message: format!("Invalid selector value: {}", value),
            line,
            column,
            recovery_hint: Some("Please check if the selector value format is correct".to_string()),
        }
    }

    /// Create a nesting too deep error
    pub fn nesting_too_deep(max_depth: usize, line: usize, column: usize) -> Self {
        ParseError {
            kind: ParseErrorKind::NestingTooDeep,
            message: format!("Expression nesting exceeds maximum depth ({})", max_depth),
            line,
            column,
            recovery_hint: Some("Please simplify the expression, reduce nesting levels".to_string()),
        }
    }
    
    /// Create a multiple text selectors error
    pub fn multiple_text_selectors(line: usize, column: usize) -> Self {
        ParseError {
            kind: ParseErrorKind::MultipleTextSelectors,
            message: "Query operation can only contain one text query directive".to_string(),
            line,
            column,
            recovery_hint: Some("Please remove extra text query directives or separate them with set operations (+, *, -)".to_string()),
        }
    }
    
    /// Create an element after text selector error
    pub fn element_after_text_selector(line: usize, column: usize) -> Self {
        ParseError {
            kind: ParseErrorKind::ElementAfterTextSelector,
            message: "Element query directives cannot appear after text query directives".to_string(),
            line,
            column,
            recovery_hint: Some("Please place element query directives before text query directives".to_string()),
        }
    }
}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Parse error (line {}, column {}): {} - {}",
            self.line, self.column, self.kind, self.message
        )?;

        if let Some(hint) = &self.recovery_hint {
            write!(f, "\nHint: {}", hint)?;
        }

        Ok(())
    }
}

impl Error for ParseError {}