WIP fix nested vec serialization: #186

Author: julienr

src/ser/mod.rs

@@ -400,6 +400,11 @@ impl<'ser, W: Write> serde::ser::Serializer for &'ser mut Serializer<W> {
 mod tests {
     use super::*;
     use serde::Serialize;
+    use simple_logger::SimpleLogger;
+
+    fn init_logger() {
+        SimpleLogger::new().with_utc_timestamps().init().unwrap();
+    }
 
     #[test]
     fn test_serialize_struct() {
@@ -447,4 +452,64 @@ mod tests {
         let got = String::from_utf8(buffer).unwrap();
         assert_eq!(got, should_be);
     }
+
+    #[test]
+    fn test_serialize_nested_structs() {
+        #[derive(Debug, Serialize, PartialEq)]
+        struct Outer {
+            a: Inner,
+        }
+
+        #[derive(Debug, Serialize, PartialEq)]
+        struct Inner {
+            name: String,
+        }
+
+        let coll = Outer {
+            a: Inner {
+                name: "42".to_owned(),
+            },
+        };
+
+        let str = to_string(&coll).unwrap();
+        println!("str={:?}", str);
+    }
+    #[test]
+    fn test_serialize_nested_collection() {
+        init_logger();
+
+        #[derive(Debug, Serialize, PartialEq)]
+        struct OuterCollection {
+            a: Vec<A>,
+        }
+
+        #[derive(Debug, Serialize, PartialEq)]
+        struct A {
+            name: String,
+        }
+
+        let coll = OuterCollection {
+            a: vec![A {
+                name: "42".to_owned(),
+            }],
+        };
+
+        let str = to_string(&coll).unwrap();
+        println!("str={:?}", str);
+    }
+
+    #[test]
+    fn test_serialize_vector() {
+        #[derive(Debug, Serialize, PartialEq)]
+        struct OuterCollection {
+            a: Vec<String>,
+        }
+
+        let coll = OuterCollection {
+            a: vec!["42".to_owned()],
+        };
+
+        let str = to_string(&coll).unwrap();
+        println!("str={:?}", str);
+    }
 }

src/ser/seq.rs

@@ -1,5 +1,6 @@
 use super::Serializer;
 use crate::error::{Error, Result};
+use log::debug;
 use serde::ser::Serialize;
 use std::io::Write;
 
@@ -22,16 +23,20 @@ impl<'ser, W: 'ser + Write> serde::ser::SerializeSeq for SeqSeralizer<'ser, W> {
         T: ?Sized + Serialize,
     {
         let must_close_tag = self.ser.build_start_tag()?;
+        debug!("start, must_close_tag={:?}", must_close_tag);
         value.serialize(&mut *self.ser)?;
         if must_close_tag {
+            debug!("end");
             self.ser.end_tag()?;
             self.ser.reopen_tag()?;
         }
         Ok(())
     }
 
     fn end(self) -> Result<()> {
-        self.ser.abandon_tag()?;
+        debug!("end");
+        // TODO: Commenting this out fixes it, but unsure why
+        // self.ser.abandon_tag()?;
         Ok(())
     }
 }