Encoder and Decoder errors for serde de/serialization

Author: kyeah

serde-tests/test.rs.in

@@ -60,7 +60,10 @@ macro_rules! t {
 macro_rules! encode( ($t:expr) => ({
     let mut e = Encoder::new();
     t!($t.serialize(&mut e));
-    e.unwrap()
+    match e.bson() {
+        Ok(b) => b,
+        Err(e) => panic!("Failed to serialize: {}", e),
+    }
 }) );
 
 macro_rules! decode( ($t:expr) => ({

src/bson.rs

@@ -365,49 +365,45 @@ impl Bson {
                     }
                 }
             }
-            // TODO: Actual error
-            _ => unreachable!()
+            _ => panic!("Attempted conversion of invalid data type: {}", self),
         }
     }
 
     pub fn from_extended_document(values: Document) -> Bson {
-        if values.contains_key("$regex") {
-            if let Some(&Bson::String(ref pat)) = values.get("$regex") {
-                if let Some(&Bson::String(ref opt)) = values.get("$options") {
-                    return Bson::RegExp(pat.to_owned(), opt.to_owned());
-                }
-            }
+        if values.len() == 2 {
+            if let (Ok(pat), Ok(opt)) = (values.get_str("$regex"), 
+                                         values.get_str("$options")) {
+                return Bson::RegExp(pat.to_owned(), opt.to_owned());
 
-        } else if let Some(&Bson::String(ref code)) = values.get("$code") {
-            if let Some(&Bson::Document(ref scope)) = values.get("$scope") {
+            } else if let (Ok(code), Ok(scope)) = (values.get_str("$code"),
+                                                   values.get_document("$scope")) {
                 return Bson::JavaScriptCodeWithScope(code.to_owned(), scope.to_owned());
-            } else {
-                return Bson::JavaScriptCode(code.to_owned());
-            }
 
-        } else if let Some(&Bson::I32(t)) = values.get("t") {
-            if let Some(&Bson::I32(i)) = values.get("i") {
+            } else if let (Ok(t), Ok(i)) = (values.get_i32("t"),
+                                            values.get_i32("i")) {
                 let timestamp = ((t as i64) << 32) + (i as i64);
-                return Bson::TimeStamp(timestamp)
-            }
+                return Bson::TimeStamp(timestamp);
 
-        } else if let Some(&Bson::I64(t)) = values.get("t") {
-            if let Some(&Bson::I64(i)) = values.get("i") {
+            } else if let (Ok(t), Ok(i)) = (values.get_i64("t"),
+                                            values.get_i64("i")) {
                 let timestamp = (t << 32) + i;
-                return Bson::TimeStamp(timestamp)
-            }
+                return Bson::TimeStamp(timestamp);
 
-        } else if let Some(&Bson::String(ref hex)) = values.get("$binary") {
-            if let Some(&Bson::I64(t)) = values.get("type") {
+            } else if let (Ok(hex), Ok(t)) = (values.get_str("$binary"),
+                                              values.get_i64("type")) {
                 let ttype = t as u8;
                 return Bson::Binary(From::from(ttype), hex.from_hex().unwrap());
             }
 
-        } else if let Some(&Bson::String(ref hex)) = values.get("$oid") {
-            return Bson::ObjectId(oid::ObjectId::with_string(hex).unwrap());
+        } else if values.len() == 1 {
+            if let Ok(code) = values.get_str("$code") {
+                return Bson::JavaScriptCode(code.to_owned());
+
+            } else if let Ok(hex) = values.get_str("$oid") {
+                return Bson::ObjectId(oid::ObjectId::with_string(hex).unwrap());
 
-        } else if let Some(&Bson::Document(ref doc)) = values.get("$date") {
-            if let Some(&Bson::I64(long)) = doc.get("$numberLong") {
+            } else if let Ok(long) = values.get_document("$date")
+                                           .and_then(|inner| inner.get_i64("$numberLong")) {
                 return Bson::UtcDatetime(UTC.timestamp(long / 1000, (long % 1000) as u32 * 1000000));
             }
         }

src/decoder/serde.rs

@@ -10,6 +10,43 @@ use super::error::{DecoderError, DecoderResult};
 
 pub struct BsonVisitor;
 
+
+impl Deserialize for ObjectId {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_map(BsonVisitor)
+            .and_then(|bson| if let Bson::ObjectId(oid) = bson {
+                Ok(oid)
+            } else {
+                Err(de::Error::syntax(&format!("expected objectId extended document, found {}", bson)))
+            })
+    }
+}
+
+impl Deserialize for OrderedDocument {
+    /// Deserialize this value given this `Deserializer`.
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_map(BsonVisitor)
+            .and_then(|bson| if let Bson::Document(doc) = bson {
+                Ok(doc)
+            } else {
+                Err(de::Error::syntax(&format!("expected document, found extended JSON data type: {}", bson)))
+            })
+    }
+}
+
+impl Deserialize for Bson {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<Bson, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(BsonVisitor)
+    }
+}
+
 impl Visitor for BsonVisitor {
     type Value = Bson;
 
@@ -96,49 +133,11 @@ impl Visitor for BsonVisitor {
     }
 }
 
-impl Deserialize for ObjectId {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit_map(BsonVisitor)
-            .and_then(|bson| if let Bson::ObjectId(oid) = bson {
-                Ok(oid)
-            } else {
-                unimplemented!()
-            })
-    }
-}
-
-impl Deserialize for OrderedDocument {
-    /// Deserialize this value given this `Deserializer`.
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit_map(BsonVisitor)
-            .and_then(|bson| if let Bson::Document(doc) = bson {
-                Ok(doc)
-            } else {
-                unimplemented!()
-            })
-    }
-}
-
-impl Deserialize for Bson {
-    #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<Bson, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(BsonVisitor)
-    }
-}
-
-/// Creates a `serde::Deserializer` from a `json::Value` object.
 pub struct Decoder {
     value: Option<Bson>,
 }
 
 impl Decoder {
-    /// Creates a new deserializer instance for deserializing the specified JSON value.
     pub fn new(value: Bson) -> Decoder {
         Decoder {
             value: Some(value),
@@ -264,25 +263,29 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
     fn visit_variant<V>(&mut self) -> DecoderResult<V>
         where V: Deserialize,
     {
-        Deserialize::deserialize(&mut Decoder::new(self.variant.take().unwrap()))
+        Deserialize::deserialize(&mut Decoder::new(try!(self.variant.take()
+                                                        .ok_or(DecoderError::EndOfStream))))
     }
 
     fn visit_unit(&mut self) -> DecoderResult<()> {
-        Deserialize::deserialize(&mut Decoder::new(self.val.take().unwrap()))
+        Deserialize::deserialize(&mut Decoder::new(try!(self.val.take()
+                                                        .ok_or(DecoderError::EndOfStream))))
     }
 
     fn visit_newtype<T>(&mut self) -> DecoderResult<T>
         where T: Deserialize,
     {
-        Deserialize::deserialize(&mut Decoder::new(self.val.take().unwrap()))
+        Deserialize::deserialize(&mut Decoder::new(try!(self.val.take()
+                                                        .ok_or(DecoderError::EndOfStream))))
     }
 
     fn visit_tuple<V>(&mut self,
                       _len: usize,
                       visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
-        if let Bson::Array(fields) = self.val.take().unwrap() {
+        if let Bson::Array(fields) = try!(self.val.take()
+                                          .ok_or(DecoderError::EndOfStream)) {
             Deserializer::visit(
                 &mut SeqDecoder {
                     de: self.de,
@@ -301,7 +304,8 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
                        visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
-        if let Bson::Document(fields) = self.val.take().unwrap() {
+        if let Bson::Document(fields) = try!(self.val.take()
+                                             .ok_or(DecoderError::EndOfStream)) {
             Deserializer::visit(
                 &mut MapDecoder {
                     de: self.de,
@@ -398,7 +402,9 @@ impl<'a> MapVisitor for MapDecoder<'a> {
     fn visit_value<T>(&mut self) -> DecoderResult<T>
         where T: Deserialize
     {
-        let value = self.value.take().unwrap();
+        let value = try!(self.value.take()
+                         .ok_or(DecoderError::EndOfStream));
+
         self.de.value = Some(value);
         Ok(try!(Deserialize::deserialize(self.de)))
     }

src/encoder/error.rs

@@ -1,10 +1,14 @@
 use std::{io, error, fmt};
 use byteorder;
+use super::serde::State;
 
 /// Possible errors that can arise during encoding.
 #[derive(Debug)]
 pub enum EncoderError {
     IoError(io::Error),
+    InvalidMapKeyType(State),
+    InvalidState(State),
+    EmptyState,
 }
 
 impl From<io::Error> for EncoderError {
@@ -22,7 +26,10 @@ impl From<byteorder::Error> for EncoderError {
 impl fmt::Display for EncoderError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &EncoderError::IoError(ref inner) => inner.fmt(fmt)
+            &EncoderError::IoError(ref inner) => inner.fmt(fmt),
+            &EncoderError::InvalidMapKeyType(ref inner) => write!(fmt, "Invalid map key type: {:?}", inner),
+            &EncoderError::InvalidState(ref inner) => write!(fmt, "Invalid state emitted: {:?}", inner),
+            &EncoderError::EmptyState => write!(fmt, "No state emitted"),
         }
     }
 }
@@ -31,11 +38,15 @@ impl error::Error for EncoderError {
     fn description(&self) -> &str {
         match self {
             &EncoderError::IoError(ref inner) => inner.description(),
+            &EncoderError::InvalidMapKeyType(_) => "Invalid map key type",
+            &EncoderError::InvalidState(_) => "Invalid state emitted",
+            &EncoderError::EmptyState => "No state emitted",
         }
     }
     fn cause(&self) -> Option<&error::Error> {
         match self {
-            &EncoderError::IoError(ref inner) => Some(inner)
+            &EncoderError::IoError(ref inner) => Some(inner),
+            _ => None,
         }
     }
 }

src/encoder/mod.rs

@@ -136,10 +136,10 @@ fn encode_bson<W: Write + ?Sized>(writer: &mut W, key: &str, val: &Bson) -> Enco
 }
 
 /// Encode a `T` Serializable into a BSON `Value`.
-pub fn to_bson<T>(value: &T) -> Bson
+pub fn to_bson<T>(value: &T) -> EncoderResult<Bson>
     where T: Serialize
 {
     let mut ser = Encoder::new();
-    value.serialize(&mut ser).unwrap();
-    ser.unwrap()
+    try!(value.serialize(&mut ser));
+    ser.bson()
 }