CHANGELOG.adoc

@@ -6,12 +6,6 @@
 
 == [Unreleased]
 
-== [v0.2.2] - 2023-02-18
-
-=== Fixed
-
-- fix deserialization failing on arrays and objects in some cases
-
 == [v0.2.1] - 2022-12-28
 
 === Fixed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_sjson"
-version = "0.2.2"
+version = "0.2.1"
 edition = "2021"
 keywords = ["serde", "serialization", "sjson"]
 description = "An SJSON serialization file format"

src/de.rs

@@ -53,16 +53,6 @@ impl<'de> Deserializer<'de> {
             Some(self.input.fragment().to_string()),
         )
     }
-
-    fn error_with_token(&self, code: ErrorCode, token: Token) -> Error {
-        Error::with_token(
-            code,
-            self.input.location_line(),
-            self.input.get_utf8_column(),
-            Some(self.input.fragment().to_string()),
-            token,
-        )
-    }
 }
 
 pub fn from_str<'a, T>(input: &'a str) -> Result<T>
@@ -89,15 +79,13 @@ impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de> {
             return Err(self.error(ErrorCode::ExpectedTopLevelObject));
         }
 
-        match self.peek_token()? {
+        match self.next_token()? {
-            Token::Boolean(_) => self.deserialize_bool(visitor),
+            Token::Boolean(val) => visitor.visit_bool::<Self::Error>(val),
-            Token::Float(_) => self.deserialize_f64(visitor),
+            Token::Float(val) => visitor.visit_f64(val),
-            Token::Integer(_) => self.deserialize_i64(visitor),
+            Token::Integer(val) => visitor.visit_i64(val),
-            Token::Null => self.deserialize_unit(visitor),
+            Token::Null => visitor.visit_unit(),
-            Token::String(_) => self.deserialize_str(visitor),
+            Token::String(val) => visitor.visit_str(&val),
-            Token::ArrayStart => self.deserialize_seq(visitor),
+            _ => Err(self.error(ErrorCode::ExpectedValue)),
-            Token::ObjectStart => self.deserialize_map(visitor),
-            token => Err(self.error_with_token(ErrorCode::ExpectedValue, token)),
         }
     }
 
@@ -743,53 +731,4 @@ render_config = "core/rendering/renderer"
         let actual = from_str::<()>(json);
         assert_eq!(actual, Err(err));
     }
-
-    #[test]
-    fn deserialize_array() {
-        #[derive(Debug, Default, serde::Deserialize, PartialEq)]
-        struct Data {
-            array: Vec<String>,
-        }
-
-        let expected = Data {
-            array: vec![String::from("foo")],
-        };
-
-        let sjson = r#"
-array = [
-    "foo"
-]
-"#;
-        assert_ok!(Data, expected, sjson);
-    }
-
-    // Regression test for #1 (https://git.sclu1034.dev/lucas/serde_sjson/issues/1)
-    #[test]
-    fn deserialize_dtmt_config() {
-        #[derive(Debug, Default, serde::Deserialize, PartialEq)]
-        struct DtmtConfig {
-            name: String,
-            #[serde(default)]
-            description: String,
-            version: Option<String>,
-        }
-
-        let sjson = r#"
-name = "test-mod"
-description = "A dummy project to test things with"
-version = "0.1.0"
-
-packages = [
-    "packages/test-mod"
-]
-"#;
-
-        let expected = DtmtConfig {
-            name: String::from("test-mod"),
-            description: String::from("A dummy project to test things with"),
-            version: Some(String::from("0.1.0")),
-        };
-
-        assert_ok!(DtmtConfig, expected, sjson);
-    }
 }

src/error.rs

@@ -1,7 +1,5 @@
 use std::fmt;
 
-use crate::parser::Token;
-
 pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(PartialEq)]
@@ -15,7 +13,6 @@ struct ErrorImpl {
     line: u32,
     column: usize,
     fragment: Option<String>,
-    token: Option<Token>,
 }
 
 #[derive(PartialEq)]
@@ -92,12 +89,11 @@ impl fmt::Debug for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "Error({:?}, line: {}, column: {}, fragment: {:?}, token: {:?})",
+            "Error({:?}, line: {}, column: {}, fragment: {:?})",
             self.inner.code.to_string(),
             self.inner.line,
             self.inner.column,
             self.inner.fragment,
-            self.inner.token,
         )
     }
 }
@@ -112,7 +108,6 @@ impl serde::de::Error for Error {
             line: 0,
             column: 0,
             fragment: None,
-            token: None,
         });
         Self { inner }
     }
@@ -128,7 +123,6 @@ impl serde::ser::Error for Error {
             line: 0,
             column: 0,
             fragment: None,
-            token: None,
         });
         Self { inner }
     }
@@ -144,24 +138,6 @@ impl Error {
                 line,
                 column,
                 fragment,
-                token: None,
-            }),
-        }
-    }
-    pub(crate) fn with_token(
-        code: ErrorCode,
-        line: u32,
-        column: usize,
-        fragment: Option<String>,
-        token: Token,
-    ) -> Self {
-        Self {
-            inner: Box::new(ErrorImpl {
-                code,
-                line,
-                column,
-                fragment,
-                token: Some(token),
             }),
         }
     }

src/parser.rs

@@ -203,32 +203,6 @@ mod test {
         }};
     }
 
-    fn check_parse_result<S: AsRef<str>, T: AsRef<[Token]>>(input: S, tokens: T) {
-        let tokens = tokens.as_ref();
-        let mut remaining = Span::from(input.as_ref());
-        let mut i = 0;
-
-        loop {
-            if remaining.fragment().is_empty() {
-                break;
-            }
-
-            let (span, token) =
-                super::parse_next_token(remaining).expect("failed to parse next token");
-
-            assert_eq!(Some(&token), tokens.get(i));
-
-            remaining = span;
-            i = i + 1;
-        }
-
-        assert_eq!(
-            tokens.len(),
-            i,
-            "tokens to check against were not exhausted"
-        );
-    }
-
     #[test]
     fn parse_optional() {
         assert_ok!("\n", whitespace, "", '\n');
@@ -291,7 +265,6 @@ mod test {
         assert_ok!(r#""foo123""#, delimited_string, "", "foo123");
         assert_ok!(r#""123foo""#, delimited_string, "", "123foo");
         assert_ok!(r#""foo\"bar""#, delimited_string, "", "foo\\\"bar");
-        assert_ok!(r#""foo/bar""#, delimited_string, "", "foo/bar");
 
         assert_err!("foo\"", delimited_string, ErrorKind::Char);
 
@@ -329,39 +302,4 @@ mod test {
         assert_ok!("/* foo */", block_comment, "", " foo ");
         assert_ok!("/*\n\tfoo\nbar\n*/", block_comment, "", "\n\tfoo\nbar\n");
     }
-
-    // Regression test for #1 (https://git.sclu1034.dev/lucas/serde_sjson/issues/1)
-    #[test]
-    fn parse_dtmt_config() {
-        let sjson = r#"
-name = "test-mod"
-description = "A dummy project to test things with"
-version = "0.1.0"
-
-packages = [
-    "packages/test-mod"
-]
-"#;
-
-        check_parse_result(
-            sjson,
-            [
-                Token::String(String::from("name")),
-                Token::Equals,
-                Token::String(String::from("test-mod")),
-                Token::String(String::from("description")),
-                Token::Equals,
-                Token::String(String::from("A dummy project to test things with")),
-                Token::String(String::from("version")),
-                Token::Equals,
-                Token::String(String::from("0.1.0")),
-                Token::String(String::from("packages")),
-                Token::Equals,
-                Token::ArrayStart,
-                Token::String(String::from("packages/test-mod")),
-                Token::ArrayEnd,
-                Token::Eof,
-            ],
-        );
-    }
 }