refactor deserializer

src/model/parser/header/de.rs

@@ -9,11 +9,15 @@ pub type Result<T> = std::result::Result<T, DeserializeError>;
 
 pub struct Deserializer<'de> {
     input: &'de str,
+    context: DeserializeContext,
 }
 
 impl<'de> Deserializer<'de> {
     pub fn from_str(input: &'de str) -> Self {
-        Deserializer { input }
+        Deserializer {
+            input,
+            context: DeserializeContext::default(),
+        }
     }
 }
 
@@ -30,6 +34,29 @@ where
     }
 }
 
+#[derive(Debug, Clone, Default)]
+struct DeserializeContext {
+    contexts: Vec<char>,
+}
+
+impl DeserializeContext {
+    fn current(&self) -> Option<char> {
+        self.contexts.last().copied()
+    }
+    fn test(&self, c: char) -> bool {
+        self.contexts.contains(&c)
+    }
+    fn test_noncurrent(&self, c: char) -> bool {
+        self.contexts.len() > 0 && self.contexts[..self.contexts.len() - 1].contains(&c)
+    }
+    fn enter(&mut self, expect: char) {
+        self.contexts.push(expect)
+    }
+    fn exit(&mut self) -> Option<char> {
+        self.contexts.pop()
+    }
+}
+
 impl<'de> Deserializer<'de> {
     fn peek_char(&self) -> Result<char> {
         self.input.chars().next().ok_or(DeserializeError::Eof)
@@ -85,22 +112,54 @@ impl<'de> Deserializer<'de> {
                 None => Err(DeserializeError::Eof),
             }
         } else {
-            let len = self
-                .input
-                .find([':', ',', '\n'])
-                .unwrap_or(self.input.len());
-            let s = &self.input[..len];
-            self.input = &self.input[len..];
-            Ok(s)
+            self.str_until_expect()
         }
     }
 
-    fn str_until_lineend(&mut self) -> Result<&'de str> {
-        let len = self.input.find('\n').unwrap_or(self.input.len());
+    fn str_until_expect(&mut self) -> Result<&'de str> {
+        let len = self
+            .input
+            .find(|c| self.context.test(c))
+            .unwrap_or(self.input.len());
+
         let s = &self.input[..len];
         self.input = &self.input[len..];
         Ok(s)
     }
+
+    /// Consume string until chars other than current delimiter appears.
+    /// - `Some(true)`: Current delimiter found (sequence continues)
+    /// - `Some(false)`: Current delimiter was not found, but other delimiters were found or the string reached EOF (sequence ends)
+    /// - `None`: No delimiter found (syntax error)
+    fn consume_delimiters(&mut self) -> Option<bool> {
+        let Some(current) = self.context.current() else {
+            // Delimiter is empty
+            return None;
+        };
+
+        let Some(pos) = self.input.find(|c| c != current) else {
+            // Input was all delimiter (EOF)
+            // When EOF, clear buffer
+            self.input = "";
+            return Some(false);
+        };
+        let (prefix, rest) = self.input.split_at(pos);
+        if prefix.contains(|c| self.context.test_noncurrent(c)) {
+            // Other delimiters came earlier than current one
+            return Some(false);
+        }
+        if prefix.is_empty() {
+            match rest.chars().next() {
+                // The first char was delimiter (end of sequence)
+                Some(c) if self.context.test_noncurrent(c) => return Some(false),
+                // The first char was not delimiter
+                _ => return None,
+            }
+        }
+
+        self.input = rest;
+        Some(true)
+    }
 }
 
 impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
@@ -110,7 +169,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        visitor.visit_borrowed_str(self.str_until_lineend()?)
+        visitor.visit_borrowed_str(self.str_until_expect()?)
     }
 
     forward_to_deserialize_any! {
@@ -268,22 +327,21 @@ impl<'de, 'a> SeqAccess<'de> for List<'a, 'de> {
     where
         T: DeserializeSeed<'de>,
     {
-        let mut delim_ok = false;
-        loop {
-            let char = self.de.peek_char();
-            match char {
-                Ok(c) if c == self.delim => delim_ok = true,
-                Ok('\n') | Err(DeserializeError::Eof) => return Ok(None),
-                _ => break,
+        self.de.context.enter(self.delim);
+        match self.de.consume_delimiters() {
+            Some(false) => {
+                self.de.context.exit();
+                return Ok(None);
             }
-            self.de.next_char()?;
-        }
-        if !self.first && !delim_ok {
-            return Err(DeserializeError::ExpectedArrayComma);
+            // No need to clear context if deserializing stops here
+            None if !self.first => return Err(DeserializeError::ExpectedArrayComma),
+            _ => (),
         }
         self.first = false;
 
-        seed.deserialize(&mut *self.de).map(Some)
+        let res = seed.deserialize(&mut *self.de);
+        self.de.context.exit();
+        res.map(Some)
     }
 }
 
@@ -305,21 +363,19 @@ impl<'de, 'a> MapAccess<'de> for NewlineSeparated<'a, 'de> {
     where
         K: DeserializeSeed<'de>,
     {
-        let mut newline = false;
-        loop {
-            let char = self.de.peek_char();
-            match char {
-                Ok('\n') => newline = true,
-                Err(DeserializeError::Eof) => return Ok(None),
-                _ => break,
+        self.de.context.enter('\n');
+        match self.de.consume_delimiters() {
+            Some(false) => {
+                self.de.context.exit();
+                return Ok(None);
             }
-            self.de.next_char()?;
-        }
-        if !self.first && !newline {
-            return Err(DeserializeError::ExpectedMapNewline);
+            // No need to clear context if deserializing stops here
+            None if !self.first => return Err(DeserializeError::ExpectedMapNewline),
+            _ => (),
         }
         self.first = false;
 
+        self.de.context.enter(':');
         seed.deserialize(&mut *self.de).map(Some)
     }
 
@@ -328,8 +384,48 @@ impl<'de, 'a> MapAccess<'de> for NewlineSeparated<'a, 'de> {
         V: DeserializeSeed<'de>,
     {
         if self.de.next_char()? != ':' {
+            // No need to clear context if deserializing stops here
             return Err(DeserializeError::ExpectedMapColon);
         }
-        seed.deserialize(&mut *self.de)
+
+        self.de.context.exit();
+        let res = seed.deserialize(&mut *self.de);
+        self.de.context.exit();
+        res
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Deserializer;
+
+    #[test]
+    fn consume_delimiters() {
+        {
+            let mut de = Deserializer::from_str("\nFULL");
+            de.context.enter('\n');
+            assert_eq!(de.consume_delimiters(), Some(true));
+            assert_eq!(de.input, "FULL");
+        }
+        {
+            let mut de = Deserializer::from_str(",\nFULL");
+            de.context.enter('\n');
+            de.context.enter(',');
+            assert_eq!(de.consume_delimiters(), Some(true));
+            assert_eq!(de.input, "\nFULL");
+        }
+        {
+            let mut de = Deserializer::from_str("\nFULL");
+            de.context.enter('\n');
+            de.context.enter(',');
+            assert_eq!(de.consume_delimiters(), Some(false));
+            assert_eq!(de.input, "\nFULL");
+        }
+        {
+            let mut de = Deserializer::from_str("\nFULL");
+            de.context.enter(',');
+            assert_eq!(de.consume_delimiters(), None);
+            assert_eq!(de.input, "\nFULL");
+        }
     }
 }