Upgrade chrono deps to v0.3 [#68], add UtcDateTime wrapper as serde serialization helper [#65]

Author: zonyitoo

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bson"
-version = "0.7.0"
+version = "0.7.1"
 authors = [
     "Y. T. Chung <[email protected]>",
     "Kevin Yeh <[email protected]>"
@@ -16,7 +16,7 @@ name = "bson"
 
 [dependencies]
 byteorder = "1.0"
-chrono = "0.2"
+chrono = "0.3"
 libc = "0.2"
 rand = "0.3"
 rust-crypto = "0.2"
@@ -26,3 +26,6 @@ time = "0.1"
 linked-hash-map = "0.3"
 hostname = "^0.1"
 hex = "^0.2"
+
+[dev-dependencies]
+serde_derive = "1.0"

src/bson.rs

@@ -22,6 +22,7 @@
 //! BSON definition
 
 use std::fmt::{self, Display, Debug};
+use std::ops::{Deref, DerefMut};
 
 use chrono::{DateTime, Timelike, UTC};
 use chrono::offset::TimeZone;
@@ -429,7 +430,7 @@ impl Bson {
             Bson::UtcDatetime(ref v) => {
                 doc! {
                     "$date" => {
-                        "$numberLong" => ((v.timestamp() * 1000) + (v.nanosecond() / 1000000) as i64)
+                        "$numberLong" => ((v.timestamp() * 1000) + v.nanosecond() as i64 / 1000000)
                     }
                 }
             }
@@ -479,7 +480,7 @@ impl Bson {
                           .get_document("$date")
                           .and_then(|inner| inner.get_i64("$numberLong")) {
                 return Bson::UtcDatetime(UTC.timestamp(long / 1000,
-                                                       (long % 1000) as u32 * 1000000));
+                                                       ((long % 1000) * 1000000) as u32));
             } else if let Ok(sym) = values.get_str("$symbol") {
                 return Bson::Symbol(sym.to_owned());
             }
@@ -587,3 +588,47 @@ impl Bson {
         }
     }
 }
+
+/// `DateTime` representation in struct for serde serialization
+///
+/// Just a helper for convenience
+///
+/// ```rust,ignore
+/// #[macro_use]
+/// extern crate serde_derive;
+/// extern crate bson;
+/// use bson::UtcDateTime;
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Foo {
+///     date_time: UtcDateTime,
+/// }
+/// ```
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub struct UtcDateTime(pub DateTime<UTC>);
+
+impl Deref for UtcDateTime {
+    type Target = DateTime<UTC>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for UtcDateTime {
+    fn deref_mut(&mut self) -> &mut DateTime<UTC> {
+        &mut self.0
+    }
+}
+
+impl Into<DateTime<UTC>> for UtcDateTime {
+    fn into(self) -> DateTime<UTC> {
+        self.0
+    }
+}
+
+impl From<DateTime<UTC>> for UtcDateTime {
+    fn from(x: DateTime<UTC>) -> Self {
+        UtcDateTime(x)
+    }
+}

src/decoder/serde.rs

@@ -5,7 +5,7 @@ use serde::de::{self, Deserialize, Deserializer, Visitor, MapAccess, SeqAccess,
                 DeserializeSeed, EnumAccess};
 use serde::de::Unexpected;
 
-use bson::Bson;
+use bson::{Bson, UtcDateTime};
 use oid::ObjectId;
 use ordered::{OrderedDocument, OrderedDocumentIntoIterator, OrderedDocumentVisitor};
 use super::error::{DecoderError, DecoderResult};
@@ -366,8 +366,7 @@ impl<'de> VariantAccess<'de> for VariantDecoder {
         match self.val.take() {
             None => Ok(()),
             Some(val) => {
-                try!(Deserialize::deserialize(Decoder::new(val)));
-                Ok(())
+                Bson::deserialize(Decoder::new(val)).map(|_| ())
             }
         }
     }
@@ -570,3 +569,16 @@ impl<'de> Deserializer<'de> for MapDecoder {
         deserialize_byte_buf();
     }
 }
+
+impl<'de> Deserialize<'de> for UtcDateTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        use serde::de::Error;
+
+        match Bson::deserialize(deserializer)? {
+            Bson::UtcDatetime(dt) => Ok(UtcDateTime(dt)),
+            _ => Err(D::Error::custom("expecting UtcDateTime")),
+        }
+    }
+}

src/encoder/serde.rs

@@ -1,7 +1,7 @@
 use serde::ser::{Serialize, Serializer, SerializeSeq, SerializeTuple, SerializeTupleStruct,
                  SerializeTupleVariant, SerializeMap, SerializeStruct, SerializeStructVariant};
 
-use bson::{Array, Bson, Document};
+use bson::{Array, Bson, Document, UtcDateTime};
 use oid::ObjectId;
 
 use super::{to_bson, EncoderError, EncoderResult};
@@ -434,3 +434,14 @@ impl SerializeStructVariant for StructVariantSerializer {
         Ok(Bson::Document(struct_variant))
     }
 }
+
+impl Serialize for UtcDateTime {
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        // Cloning a `DateTime` is extremely cheap
+        let doc = Bson::UtcDatetime(self.0);
+        doc.serialize(serializer)
+    }
+}

src/lib.rs

@@ -55,7 +55,7 @@ extern crate linked_hash_map;
 extern crate hostname;
 extern crate hex;
 
-pub use self::bson::{Bson, Document, Array};
+pub use self::bson::{Bson, Document, Array, UtcDateTime};
 pub use self::encoder::{encode_document, to_bson, Encoder, EncoderResult, EncoderError};
 pub use self::decoder::{decode_document, from_bson, Decoder, DecoderResult, DecoderError};
 pub use self::ordered::{ValueAccessError, ValueAccessResult};

tests/serde.rs

@@ -1,9 +1,12 @@
 #[macro_use]
 extern crate bson;
-use bson::{Encoder, Decoder};
-
 extern crate serde;
+#[macro_use]
+extern crate serde_derive;
+extern crate chrono;
+
 use serde::{Serialize, Deserialize};
+use bson::{Encoder, Decoder, Bson};
 
 use std::collections::BTreeMap;
 
@@ -54,3 +57,26 @@ fn test_de_map() {
     expected.insert("y".to_string(), 1);
     assert_eq!(expected, map);
 }
+
+#[test]
+fn test_ser_datetime() {
+    use chrono::{UTC, Timelike};
+    use bson::UtcDateTime;
+
+    #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)]
+    struct Foo {
+        date: UtcDateTime,
+    }
+
+    let now = UTC::now();
+    // FIXME: Due to BSON's datetime precision
+    let now = now.with_nanosecond(now.nanosecond() / 1000000 * 1000000).unwrap();
+
+    let foo = Foo { date: From::from(now) };
+
+    let x = bson::to_bson(&foo).unwrap();
+    assert_eq!(x.as_document().unwrap(), &doc! { "date" => (Bson::UtcDatetime(now)) });
+
+    let xfoo: Foo = bson::from_bson(x).unwrap();
+    assert_eq!(xfoo, foo);
+}