chore: Improved error messages

Ref: #27

Author: Stranger6667

src/error.rs

@@ -1,14 +1,15 @@
 //! Errors that may happen during inlining.
-use cssparser::ParseError;
-use std::io;
+use cssparser::{BasicParseErrorKind, ParseError, ParseErrorKind};
+use std::fmt::{Display, Formatter};
+use std::{fmt, io};
 
 /// Inlining error
 #[derive(Debug)]
 pub enum InlineError {
     /// Input-output error. May happen during writing the resulting HTML.
     IO(io::Error),
     /// Syntax errors or unsupported selectors.
-    ParseError,
+    ParseError(String),
 }
 
 impl From<io::Error> for InlineError {
@@ -17,8 +18,29 @@ impl From<io::Error> for InlineError {
     }
 }
 
+impl Display for InlineError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            InlineError::IO(error) => write!(f, "{}", error),
+            InlineError::ParseError(error) => write!(f, "{}", error),
+        }
+    }
+}
+
 impl From<(ParseError<'_, ()>, &str)> for InlineError {
-    fn from(_: (ParseError<'_, ()>, &str)) -> Self {
-        InlineError::ParseError
+    fn from(error: (ParseError<'_, ()>, &str)) -> Self {
+        let message = match error.0.kind {
+            ParseErrorKind::Basic(kind) => match kind {
+                BasicParseErrorKind::UnexpectedToken(token) => {
+                    format!("Unexpected token: {:?}", token)
+                }
+                BasicParseErrorKind::EndOfInput => "End of input".to_string(),
+                BasicParseErrorKind::AtRuleInvalid(value) => format!("Invalid @ rule: {}", value),
+                BasicParseErrorKind::AtRuleBodyInvalid => "Invalid @ rule body".to_string(),
+                BasicParseErrorKind::QualifiedRuleInvalid => "Invalid qualified rule".to_string(),
+            },
+            ParseErrorKind::Custom(_) => "Unknown error".to_string(),
+        };
+        InlineError::ParseError(message)
     }
 }

src/lib.rs

@@ -127,7 +127,7 @@ pub fn inline(html: &str) -> Result<String, InlineError> {
     let document = parse_html().one(html);
     for style_tag in document
         .select("style")
-        .map_err(|_| error::InlineError::ParseError)?
+        .map_err(|_| error::InlineError::ParseError("Unknown error".to_string()))?
     {
         if let Some(first_child) = style_tag.as_node().first_child() {
             if let Some(css_cell) = first_child.as_text() {
@@ -136,8 +136,9 @@ pub fn inline(html: &str) -> Result<String, InlineError> {
                 let mut parser = parse::CSSParser::new(&mut parse_input);
                 for parsed in parser.parse() {
                     if let Ok((selector, declarations)) = parsed {
-                        let rule = Rule::new(&selector, declarations)
-                            .map_err(|_| error::InlineError::ParseError)?;
+                        let rule = Rule::new(&selector, declarations).map_err(|_| {
+                            error::InlineError::ParseError("Unknown error".to_string())
+                        })?;
                         let matching_elements = document
                             .inclusive_descendants()
                             .filter_map(|node| node.into_element_ref())

tests/test_inlining.rs

@@ -89,3 +89,14 @@ fn media_query_ignore() {
         expected = "<h1>Hello world!</h1>"
     )
 }
+
+#[test]
+fn invalid_rule() {
+    let html = html!(
+        "h1 {background-color: blue;}",
+        r#"<h1 style="@wrong { color: ---}">Hello world!</h1>"#
+    );
+    let result = inline(&html);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err().to_string(), "Invalid @ rule: wrong")
+}