Bump version to v0.12.0, updated dependencies

Author: zonyitoo

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bson"
-version = "0.11.1"
+version = "0.12.0"
 authors = [
     "Y. T. Chung <zonyitoo@gmail.com>",
     "Kevin Yeh <kevinyeah@utexas.edu>"
@@ -15,17 +15,17 @@ documentation = "https://docs.rs/crate/bson"
 name = "bson"
 
 [dependencies]
-byteorder = "1.0"
+byteorder = "1"
 chrono = "0.4"
 libc = "0.2"
-rand = "0.3"
-rust-crypto = "0.2"
+rand = "0.5"
 serde = "1.0"
-serde_json = { version = "1.0.0", features = ["preserve_order"] }
+serde_json = { version = "1.0", features = ["preserve_order"] }
 time = "0.1"
 linked-hash-map = "0.5"
-hostname = "^0.1"
-hex = "^0.2"
+hostname = "0.1"
+hex = "0.3"
+md5 = "0.3"
 
 [dev-dependencies]
 serde_derive = "1.0"

src/bson.rs

@@ -24,9 +24,9 @@
 use std::fmt::{self, Debug, Display};
 use std::ops::{Deref, DerefMut};
 
-use chrono::{DateTime, Timelike, Utc};
 use chrono::offset::TimeZone;
-use hex::{FromHex, ToHex};
+use chrono::{DateTime, Timelike, Utc};
+use hex;
 use serde_json::Value;
 
 use oid;
@@ -107,7 +107,7 @@ impl Debug for Bson {
 
                 write!(f, "TimeStamp({}, {})", time, inc)
             }
-            &Bson::Binary(t, ref vec) => write!(f, "BinData({}, 0x{})", u8::from(t), vec.to_hex()),
+            &Bson::Binary(t, ref vec) => write!(f, "BinData({}, 0x{})", u8::from(t), hex::encode(vec)),
             &Bson::ObjectId(ref id) => write!(f, "ObjectId({:?})", id),
             &Bson::UtcDatetime(date_time) => write!(f, "UtcDatetime({:?})", date_time),
             &Bson::Symbol(ref sym) => write!(f, "Symbol({:?})", sym),
@@ -148,7 +148,7 @@ impl Display for Bson {
 
                 write!(fmt, "Timestamp({}, {})", time, inc)
             }
-            &Bson::Binary(t, ref vec) => write!(fmt, "BinData({}, 0x{})", u8::from(t), vec.to_hex()),
+            &Bson::Binary(t, ref vec) => write!(fmt, "BinData({}, 0x{})", u8::from(t), hex::encode(vec)),
             &Bson::ObjectId(ref id) => write!(fmt, "ObjectId(\"{}\")", id),
             &Bson::UtcDatetime(date_time) => write!(fmt, "Date(\"{}\")", date_time),
             &Bson::Symbol(ref sym) => write!(fmt, "Symbol(\"{}\")", sym),
@@ -270,12 +270,11 @@ impl From<DateTime<Utc>> for Bson {
 impl From<Value> for Bson {
     fn from(a: Value) -> Bson {
         match a {
-            Value::Number(x) => {
-                x.as_i64().map(Bson::from)
-                 .or_else(|| x.as_u64().map(Bson::from))
-                 .or_else(|| x.as_f64().map(Bson::from))
-                 .unwrap_or_else(|| panic!("Invalid number value: {}", x))
-            }
+            Value::Number(x) => x.as_i64()
+                                 .map(Bson::from)
+                                 .or_else(|| x.as_u64().map(Bson::from))
+                                 .or_else(|| x.as_f64().map(Bson::from))
+                                 .unwrap_or_else(|| panic!("Invalid number value: {}", x)),
             Value::String(x) => x.into(),
             Value::Bool(x) => x.into(),
             Value::Array(x) => Bson::Array(x.into_iter().map(Bson::from).collect()),
@@ -296,19 +295,15 @@ impl Into<Value> for Bson {
             Bson::Document(v) => json!(v),
             Bson::Boolean(v) => json!(v),
             Bson::Null => Value::Null,
-            Bson::RegExp(pat, opt) => {
-                json!({
+            Bson::RegExp(pat, opt) => json!({
                     "$regex": pat,
                     "$options": opt
-                })
-            }
+                }),
             Bson::JavaScriptCode(code) => json!({ "$code": code }),
-            Bson::JavaScriptCodeWithScope(code, scope) => {
-                json!({
+            Bson::JavaScriptCodeWithScope(code, scope) => json!({
                     "$code": code,
                     "scope": scope
-                })
-            }
+                }),
             Bson::I32(v) => v.into(),
             Bson::I64(v) => v.into(),
             Bson::TimeStamp(v) => {
@@ -323,17 +318,15 @@ impl Into<Value> for Bson {
                 let tval: u8 = From::from(t);
                 json!({
                     "type": tval,
-                    "$binary": v.to_hex()
+                    "$binary": hex::encode(v),
                 })
             }
             Bson::ObjectId(v) => json!({"$oid": v.to_string()}),
-            Bson::UtcDatetime(v) => {
-                json!({
+            Bson::UtcDatetime(v) => json!({
                     "$date": {
                         "$numberLong": (v.timestamp() * 1000) + ((v.nanosecond() / 1000000) as i64)
                     }
-                })
-            }
+                }),
             // FIXME: Don't know what is the best way to encode Symbol type
             Bson::Symbol(v) => json!({ "$symbol": v }),
         }
@@ -418,7 +411,7 @@ impl Bson {
             Bson::Binary(t, ref v) => {
                 let tval: u8 = From::from(t);
                 doc! {
-                    "$binary": v.to_hex(),
+                    "$binary": hex::encode(v),
                     "type": tval as i64,
                 }
             }
@@ -460,8 +453,7 @@ impl Bson {
                 return Bson::TimeStamp(timestamp);
             } 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),
-                                    FromHex::from_hex(hex.as_bytes()).unwrap());
+                return Bson::Binary(From::from(ttype), hex::decode(hex.as_bytes()).expect("$binary value is not a valid Hex encoded bytes"));
             }
         } else if values.len() == 1 {
             if let Ok(code) = values.get_str("$code") {

src/lib.rs

@@ -44,7 +44,6 @@
 
 extern crate byteorder;
 extern crate chrono;
-extern crate crypto;
 extern crate hex;
 extern crate hostname;
 extern crate libc;
@@ -53,19 +52,20 @@ extern crate rand;
 extern crate serde;
 #[macro_use]
 extern crate serde_json;
+extern crate md5;
 extern crate time;
 
 pub use self::bson::{Array, Bson, Document, TimeStamp, UtcDateTime};
-pub use self::decoder::{decode_document, from_bson, Decoder, DecoderError, DecoderResult, decode_document_utf8_lossy};
+pub use self::decoder::{decode_document, decode_document_utf8_lossy, from_bson, Decoder, DecoderError, DecoderResult};
 pub use self::encoder::{encode_document, to_bson, Encoder, EncoderError, EncoderResult};
 pub use self::ordered::{ValueAccessError, ValueAccessResult};
 
 #[macro_use]
 pub mod macros;
-pub mod oid;
-pub mod spec;
 mod bson;
-mod encoder;
+pub mod compat;
 mod decoder;
+mod encoder;
+pub mod oid;
 pub mod ordered;
-pub mod compat;
+pub mod spec;

src/oid.rs

@@ -2,16 +2,15 @@
 
 use libc;
 
-use std::{error, fmt, io, result};
 use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+use std::{error, fmt, io, result};
 
 use byteorder::{BigEndian, ByteOrder, LittleEndian};
-use crypto::digest::Digest;
-use crypto::md5::Md5;
+use md5;
 
-use hex::{FromHex, FromHexError, ToHex};
+use hex::{self, FromHexError};
 
-use rand::{OsRng, Rng};
+use rand::{thread_rng, Rng};
 
 use hostname::get_hostname;
 use time;
@@ -126,7 +125,7 @@ impl ObjectId {
 
     /// Creates an ObjectID using a 12-byte (24-char) hexadecimal string.
     pub fn with_string(s: &str) -> Result<ObjectId> {
-        let bytes: Vec<u8> = FromHex::from_hex(s.as_bytes())?;
+        let bytes: Vec<u8> = hex::decode(s.as_bytes())?;
         if bytes.len() != 12 {
             Err(Error::ArgumentError("Provided string must be a 12-byte hexadecimal string.".to_owned()))
         } else {
@@ -182,7 +181,7 @@ impl ObjectId {
 
     /// Convert the objectId to hex representation.
     pub fn to_hex(&self) -> String {
-        self.id.to_hex()
+        hex::encode(self.id)
     }
 
     // Generates a new timestamp representing the current seconds since epoch.
@@ -214,9 +213,8 @@ impl ObjectId {
         }
 
         // Hash hostname string
-        let mut md5 = Md5::new();
-        md5.input_str(hostname.unwrap().as_str());
-        let hash = md5.result_str();
+        let digest = md5::compute(hostname.unwrap().as_str());
+        let hash = format!("{:x}", digest);
 
         // Re-convert string to bytes and grab first three
         let mut bytes = hash.bytes();
@@ -246,8 +244,7 @@ impl ObjectId {
     fn gen_count() -> Result<[u8; 3]> {
         // Init oid counter
         if OID_COUNTER.load(Ordering::SeqCst) == 0 {
-            let mut rng = OsRng::new()?;
-            let start = rng.gen_range(0, MAX_U24 + 1);
+            let start = thread_rng().gen_range(0, MAX_U24 + 1);
             OID_COUNTER.store(start, Ordering::SeqCst);
         }
 

tests/modules/macros.rs

@@ -1,8 +1,8 @@
-use bson::Bson;
 use bson::oid::ObjectId;
 use bson::spec::BinarySubtype;
+use bson::Bson;
 use chrono::offset::Utc;
-use hex::ToHex;
+use hex;
 
 #[test]
 fn standard_format() {
@@ -44,8 +44,8 @@ fn standard_format() {
                  regexp: /s[ao]d/i, with_wrapped_parens: -20, code: function(x) {{ return x._id; }}, i32: 12, \
                  i64: -55, timestamp: Timestamp(0, 229999444), binary: BinData(5, \
                  0x{}), _id: ObjectId(\"{}\"), date: Date(\"{}\") }}",
-                "thingies".to_hex(),
-                id_string.to_hex(),
+                hex::encode("thingies"),
+                hex::encode(id_string),
                 date);
 
     assert_eq!(expected, format!("{}", doc));
@@ -92,8 +92,8 @@ fn rocket_format() {
                  regexp: /s[ao]d/i, with_wrapped_parens: -20, code: function(x) {{ return x._id; }}, i32: 12, \
                  i64: -55, timestamp: Timestamp(0, 229999444), binary: BinData(5, \
                  0x{}), _id: ObjectId(\"{}\"), date: Date(\"{}\") }}",
-                "thingies".to_hex(),
-                id_string.to_hex(),
+                hex::encode("thingies"),
+                hex::encode(id_string),
                 date);
 
     assert_eq!(expected, format!("{}", doc));

tests/modules/oid.rs

@@ -1,11 +1,20 @@
 use bson::oid::ObjectId;
-use hex::ToHex;
+use hex;
 
 #[test]
 fn deserialize() {
-    let bytes: [u8; 12] = [0xDEu8, 0xADu8, 0xBEu8, 0xEFu8 /* timestamp is 3735928559 */, 0xEFu8, 0xCDu8,
-                           0xABu8 /* machine_id is 11259375 */, 0xFAu8, 0x29u8 /* process_id is 10746 */,
-                           0x11u8, 0x22u8, 0x33u8 /* increment is 1122867 */];
+    let bytes: [u8; 12] = [0xDEu8,
+                           0xADu8,
+                           0xBEu8,
+                           0xEFu8, // timestamp is 3735928559
+                           0xEFu8,
+                           0xCDu8,
+                           0xABu8, // machine_id is 11259375
+                           0xFAu8,
+                           0x29u8, // process_id is 10746
+                           0x11u8,
+                           0x22u8,
+                           0x33u8 /* increment is 1122867 */];
 
     let oid = ObjectId::with_bytes(bytes);
     assert_eq!(3735928559 as u32, oid.timestamp());
@@ -37,7 +46,7 @@ fn string_oid() {
     let s = "123456789012123456789012";
     let oid_res = ObjectId::with_string(s);
     assert!(oid_res.is_ok());
-    let actual_s = oid_res.unwrap().bytes().to_hex();
+    let actual_s = hex::encode(oid_res.unwrap().bytes());
     assert_eq!(s.to_owned(), actual_s);
 }