Improve Bool parsing and add sequence serialization

src/de/mod.rs

@@ -227,7 +227,25 @@ impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
     deserialize_type!(deserialize_u64 => visit_u64);
     deserialize_type!(deserialize_f32 => visit_f32);
     deserialize_type!(deserialize_f64 => visit_f64);
-    deserialize_type!(deserialize_bool => visit_bool);
+
+    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+        if let XmlEvent::StartElement { .. } = *self.peek()? {
+            self.set_map_value()
+        }
+        self.read_inner_value::<V, V::Value, _>(|this| {
+            if let XmlEvent::EndElement { .. } = *this.peek()? {
+                return visitor.visit_bool(false);
+            }
+            expect!(this.next()?, XmlEvent::Characters(s) => {
+                match s.as_str() {
+                    "true" | "1" => visitor.visit_bool(true),
+                    "false" | "0" => visitor.visit_bool(false),
+                    _ => visitor.visit_bool(false),
+                }
+
+            })
+        })
+    }
 
     fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         self.deserialize_string(visitor)

src/ser/mod.rs

@@ -103,7 +103,6 @@ where
     }
 }
 
-
 #[allow(unused_variables)]
 impl<'w, W> ser::Serializer for &'w mut Serializer<W>
 where
@@ -112,7 +111,7 @@ where
     type Ok = ();
     type Error = Error;
 
-    type SerializeSeq = Impossible<Self::Ok, Self::Error>;
+    type SerializeSeq = Self;
     type SerializeTuple = Impossible<Self::Ok, Self::Error>;
     type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
     type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
@@ -234,10 +233,7 @@ where
     }
 
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        // TODO: Figure out how to constrain the things written to only be composites
-        Err(
-            ErrorKind::UnsupportedOperation("serialize_seq".to_string()).into(),
-        )
+        Ok(self)
     }
 
     fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
@@ -288,6 +284,24 @@ where
     }
 }
 
+impl<'a, W> ser::SerializeSeq for &'a mut Serializer<W>
+where
+    W: Write,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, value: &T) -> ::std::result::Result<(), Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(&mut **self)
+    }
+
+    fn end(self) -> ::std::result::Result<(), Error> {
+        Ok(())
+    }
+}
 
 #[cfg(test)]
 mod tests {

tests/round_trip.rs

@@ -41,6 +41,24 @@ fn basic_struct() {
     assert_eq!(src, reserialized_item);
 }
 
+#[test]
+fn repeated_basic_struct() {
+    let src = r#"<Item><name>Banana</name><source>Store</source></Item><Item><name>Split</name><source>Store</source></Item>"#;
+    let should_be = vec![Item {
+        name: "Banana".to_string(),
+        source: "Store".to_string(),
+    }, Item {
+        name: "Split".to_string(),
+        source: "Store".to_string(),
+    }];
+
+    let items: Vec<Item> = from_str(src).unwrap();
+    assert_eq!(items, should_be);
+
+    let reserialized_item = to_string(&items).unwrap();
+    assert_eq!(src, reserialized_item);
+}
+
 
 #[test]
 #[ignore]