Replace Error::UnexpectedToken by Error::IllFormed(DoubleHyphenInComment)

Author: Mingun

Changelog.md

@@ -23,6 +23,7 @@
   - `Error::UnexpectedBang` replaced by `SyntaxError`
   - `Error::UnexpectedEof` replaced by `SyntaxError` in some cases
   - `Error::UnexpectedEof` replaced by `IllFormedError` in some cases
+  - `Error::UnexpectedToken` replaced by `IllFormedError::DoubleHyphenInComment`
 
 [#675]: https://github.com/tafia/quick-xml/pull/675
 

examples/read_nodes.rs

@@ -2,6 +2,7 @@
 // Note: for this specific data set using serde feature would simplify
 //       this simple data is purely to make it easier to understand the code
 
+use quick_xml::events::attributes::AttrError;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::name::QName;
 use quick_xml::reader::Reader;
@@ -29,6 +30,26 @@ const XML: &str = r#"
   </Localization>
 "#;
 
+#[derive(Debug)]
+enum AppError {
+    /// XML parsing error
+    Xml(quick_xml::Error),
+    /// The `Translation/Text` node is missed
+    NoText(String),
+}
+
+impl From<quick_xml::Error> for AppError {
+    fn from(error: quick_xml::Error) -> Self {
+        Self::Xml(error)
+    }
+}
+
+impl From<AttrError> for AppError {
+    fn from(error: AttrError) -> Self {
+        Self::Xml(quick_xml::Error::InvalidAttr(error))
+    }
+}
+
 #[derive(Debug)]
 struct Translation {
     tag: String,
@@ -40,7 +61,7 @@ impl Translation {
     fn new_from_element(
         reader: &mut Reader<&[u8]>,
         element: BytesStart,
-    ) -> Result<Translation, quick_xml::Error> {
+    ) -> Result<Translation, AppError> {
         let mut tag = Cow::Borrowed("");
         let mut lang = Cow::Borrowed("");
 
@@ -68,16 +89,16 @@ impl Translation {
             } else {
                 dbg!("Expected Event::Start for Text, got: {:?}", &event);
                 let name_string = reader.decoder().decode(name.as_ref())?;
-                Err(quick_xml::Error::UnexpectedToken(name_string.into()))
+                Err(AppError::NoText(name_string.into()))
             }
         } else {
             let event_string = format!("{:?}", event);
-            Err(quick_xml::Error::UnexpectedToken(event_string))
+            Err(AppError::NoText(event_string))
         }
     }
 }
 
-fn main() -> Result<(), quick_xml::Error> {
+fn main() -> Result<(), AppError> {
     // In a real-world use case, Settings would likely be a struct
     // HashMap here is just to make the sample code short
     let mut settings: HashMap<String, String>;

src/errors.rs

@@ -84,6 +84,17 @@ pub enum IllFormedError {
         /// Name of actually closed tag
         found: String,
     },
+    /// A comment contains forbidden double-hyphen (`--`) sequence inside.
+    ///
+    /// According to the [specification], for compatibility, comments MUST NOT contain
+    /// double-hyphen (`--`) sequence, in particular, they cannot end by `--->`.
+    ///
+    /// The quick-xml by default does not check that, because this restriction is
+    /// mostly artificial, but you can enable it in the [configuration].
+    ///
+    /// [specification]: https://www.w3.org/TR/xml11/#sec-comments
+    /// [configuration]: crate::reader::Reader::check_comments
+    DoubleHyphenInComment,
 }
 
 impl fmt::Display for IllFormedError {
@@ -102,6 +113,9 @@ impl fmt::Display for IllFormedError {
                 "expected `</{}>`, but `</{}>` was found",
                 expected, found,
             ),
+            Self::DoubleHyphenInComment => {
+                write!(f, "forbidden string `--` was found in a comment")
+            }
         }
     }
 }
@@ -126,8 +140,6 @@ pub enum Error {
     ///
     /// [`encoding`]: index.html#encoding
     NonDecodable(Option<Utf8Error>),
-    /// Unexpected token
-    UnexpectedToken(String),
     /// Text not found, expected `Event::Text`
     TextNotFound,
     /// `Event::BytesDecl` must start with *version* attribute. Contains the attribute
@@ -236,7 +248,6 @@ impl fmt::Display for Error {
             Error::IllFormed(e) => write!(f, "ill-formed document: {}", e),
             Error::NonDecodable(None) => write!(f, "Malformed input, decoding impossible"),
             Error::NonDecodable(Some(e)) => write!(f, "Malformed UTF-8 input: {}", e),
-            Error::UnexpectedToken(e) => write!(f, "Unexpected token '{}'", e),
             Error::TextNotFound => write!(f, "Cannot read text, expecting Event::Text"),
             Error::XmlDeclWithoutVersion(e) => write!(
                 f,

src/reader/state.rs

@@ -97,7 +97,7 @@ impl ReaderState {
                         .position(|p| buf[3 + p + 1] == b'-')
                     {
                         self.offset += len - p;
-                        return Err(Error::UnexpectedToken("--".to_string()));
+                        return Err(Error::IllFormed(IllFormedError::DoubleHyphenInComment));
                     }
                 }
                 Ok(Event::Comment(BytesText::wrap(

tests/xmlrs_reader_tests.rs

@@ -201,15 +201,15 @@ fn dashes_in_comments() {
     test(
         r#"<!-- comment -- --><hello/>"#,
         r#"
-        |Error: Unexpected token '--'
+        |Error: ill-formed document: forbidden string `--` was found in a comment
         "#,
         true,
     );
 
     test(
         r#"<!-- comment ---><hello/>"#,
         r#"
-        |Error: Unexpected token '--'
+        |Error: ill-formed document: forbidden string `--` was found in a comment
         "#,
         true,
     );