fix sequence at end of group, support bare sequences

flake.lock

@@ -44,11 +44,11 @@
         "rust-overlay": "rust-overlay"
       },
       "locked": {
-        "lastModified": 1740345481,
+        "lastModified": 1740783063,
-        "narHash": "sha256-1lAgc6UhpYTHwKm88BUNSnC9nlT4a00rc6UmaE2n0LY=",
+        "narHash": "sha256-nJ/tvNBWFNJtwtNG/KsqtVq4p3aitkEb1pRW0qHvmsk=",
         "owner": "icewind1991",
         "repo": "mill-scale",
-        "rev": "582f15f238322a7f9c129aa5adef12dde3f0a5ce",
+        "rev": "591ea924cfd3cd7932b385341fb0aad0a935bb46",
         "type": "github"
       },
       "original": {

src/entry/mod.rs

@@ -122,6 +122,20 @@ impl Entry {
             _ => None,
         }
     }
+
+    pub fn parse<'a, T: Deserialize<'a>>(&'a self) -> Result<T, ParseEntryError> {
+        let str = self
+            .as_str()
+            .ok_or_else(|| ParseEntryError::new(type_name::<T>(), self.clone()))?;
+        let mut deserializer = crate::serde::Deserializer::from_str(str);
+        let result = T::deserialize(&mut deserializer)
+            .map_err(|_| ParseEntryError::new(type_name::<T>(), self.clone()))?;
+        if deserializer.next().is_some() {
+            Err(ParseEntryError::new(type_name::<T>(), self.clone()))
+        } else {
+            Ok(result)
+        }
+    }
 }
 
 /// Parsable types.
@@ -771,6 +785,21 @@ fn test_serde_entry() {
     );
 }
 
+#[test]
+fn test_parse_entry() {
+    assert_eq!(1, Entry::Value("1".into()).parse::<usize>().unwrap());
+    assert_eq!(
+        vec!(1, 2, 3),
+        Entry::Value("1 2 3".into()).parse::<Vec<u8>>().unwrap()
+    );
+    assert_eq!(
+        (1, 2, 3),
+        Entry::Value("1 2 3".into())
+            .parse::<(u8, u8, u8)>()
+            .unwrap()
+    );
+}
+
 pub(crate) fn string_is_array(string: &str) -> bool {
     (string.starts_with('[') && string.ends_with(']'))
         || (string.starts_with('{') && string.ends_with('}'))

src/serde.rs

@@ -484,7 +484,7 @@ impl<'source, 'a> TableWalker<'source, 'a> {
         self.de.source()
     }
 
-    fn key_token(&mut self) -> Result<Option<SpannedToken>> {
+    fn key_token(&mut self, retain_group_end: bool) -> Result<Option<SpannedToken>> {
         if self.done {
             return Ok(None);
         }
@@ -512,6 +512,9 @@ impl<'source, 'a> TableWalker<'source, 'a> {
 
         if key.token == Token::GroupEnd {
             self.done = true;
+            if retain_group_end {
+                self.de.push_peeked(key);
+            }
             return Ok(None);
         }
         Ok(Some(key))
@@ -525,7 +528,7 @@ impl<'de> MapAccess<'de> for TableWalker<'de, '_> {
     where
         K: DeserializeSeed<'de>,
     {
-        let key = match self.key_token() {
+        let key = match self.key_token(false) {
             Ok(Some(key)) => key,
             Ok(None) => {
                 return Ok(None);
@@ -585,20 +588,37 @@ impl<'de> SeqAccess<'de> for SeqWalker<'de, '_> {
         if self.done {
             return Ok(None);
         }
-        let value = seed.deserialize(&mut *self.table.de).map(Some)?;
 
-        let key_token = match self.table.key_token() {
+        let value = match seed.deserialize(&mut *self.table.de) {
-            Ok(Some(key)) => key,
+            Ok(value) => Some(value),
-            Ok(None) => {
+            Err(VdfError::NoValidToken(_)) => None,
-                return Ok(None);
-            }
             Err(e) => return Err(e),
         };
 
-        let key = key_token.string(self.source());
+        let value_span = self.table.de.last_span.clone();
-        if key != self.key {
+        let newline = match self.table.de.peek_span() {
-            self.table.de.push_peeked(key_token);
+            Some(next_span) => {
-            self.done = true;
+                let whitespace = &self.source()[value_span.end..next_span.start];
+                whitespace.contains('\n')
+            }
+            _ => false,
+        };
+
+        if newline {
+            let key_token = match self.table.key_token(true) {
+                Ok(Some(key)) => key,
+                Ok(None) => {
+                    self.done = true;
+                    return Ok(value);
+                }
+                Err(e) => return Err(e),
+            };
+
+            let key = key_token.string(self.source());
+            if key != self.key {
+                self.table.de.push_peeked(key_token);
+                self.done = true;
+            }
         }
 
         Ok(value)
@@ -866,4 +886,25 @@ mod tests {
         let j = r#"1.1"#;
         assert_eq!(E::Float(1.1), unwrap_err(from_str(j)));
     }
+
+    #[test]
+    fn test_list_in_struct() {
+        #[derive(Deserialize, PartialEq, Debug)]
+        struct Test {
+            seq: Vec<u8>,
+        }
+
+        let j = r#"{
+            seq 1
+            seq 2
+            seq 3
+        }"#;
+        let expected = Test { seq: vec![1, 2, 3] };
+        assert_eq!(expected, unwrap_err(from_str(j)));
+
+        let j = r#"{
+            seq 1 2 3
+        }"#;
+        assert_eq!(expected, unwrap_err(from_str(j)));
+    }
 }

tests/data/messy.vdf

@@ -8,6 +8,6 @@
     array "3"
     windows_path "C:\test\no newline"
 
-    \\"$translucent" 1 // this is read vdf written by real valve developers
+    \\"$translucent" 1 // this is real vdf written by real valve developers
-    "$envmaptint" .5 .5 .5 // found in the wild, pretty sure they mean "[.5 .5 .5]", but it ends up working by accident with a stray `.5 = .5` kv
+    "$envmaptint" .5 .5 .5
 }

tests/data/serde_array_type.vdf

@@ -5,4 +5,5 @@
     single 1.2
     triple "{1.2 1.3 1.4}"
     single_int 2
+    another_tuple 8 foo 0
 }

tests/serde.rs

@@ -18,6 +18,7 @@ enum Expected {
         single: SingleOrTriple<f32>,
         triple: SingleOrTriple<f32>,
         single_int: SingleOrTriple<f32>,
+        another_tuple: (u8, String, bool),
     },
     LightmappedGeneric {
         #[serde(rename = "$baseTexture")]
@@ -45,9 +46,7 @@ enum Expected {
         #[serde(rename = r#"\\"$translucent""#)]
         translucent: bool,
         #[serde(rename = "$envmaptint")]
-        env_map_tint: f32,
+        env_map_tint: [f32; 3],
-        #[serde(rename = ".5")]
-        spare: f32,
     },
     UserConfigData {
         #[serde(rename = "Steam")]

tests/snapshots/serde__table__tests__data__serde_array_type.vdf.snap

@@ -4,6 +4,7 @@ expression: result
 ---
 {
   "Types": {
+    "another_tuple": "8",
     "fixed_array": [
       "1",
       "2",
@@ -13,6 +14,7 @@ expression: result
       "1",
       "2.2",
     ],
+    "foo": "0",
     "single": "1.2",
     "single_int": "2",
     "triple": [

tests/snapshots/serde__tests__data__internal_tag.vdf.snap

@@ -0,0 +1,16 @@
+---
+source: tests/serde.rs
+expression: out
+---
+vmt_reader::unexpected_token
+
+  × invalid type: boolean `true`, expected u32
+    ╭─[6:9]
+  5 │       }
+  6 │ ╭─▶   data2 {
+  7 │ │       kind Bar
+  8 │ │       val1 1
+  9 │ ├─▶   }
+    · ╰──── invalid type: boolean `true`, expected u32
+ 10 │     }
+    ╰────

tests/snapshots/serde__tests__data__messy.vdf.snap

@@ -11,6 +11,5 @@ r#Resource/specificPanel.res(
   ],
   windows_path: "C:\\test\\no newline",
   r#\\"$translucent": true,
-  r#$envmaptint: 0.5,
+  r#$envmaptint: (0.5, 0.5, 0.5),
-  r#.5: 0.5,
 )

tests/snapshots/serde__tests__data__serde_array_type.vdf.snap

@@ -12,4 +12,5 @@ Types(
   single: 1.2,
   triple: (1.2, 1.3, 1.4),
   single_int: 2.0,
+  another_tuple: (8, "foo", false),
 )