replace rustc-serialize with data-encoding

Author: kyeah

Cargo.toml

@@ -16,10 +16,10 @@ name = "bson"
 [dependencies]
 byteorder = "1.0"
 chrono = "0.2"
+data-encoding = "1.1.2"
 libc = "0.2"
 rand = "0.3"
 rust-crypto = "0.2"
-rustc-serialize = "0.3"
 serde = "0.9"
 serde_json = { version = "0.9.5", features = ["preserve_order"] }
 time = "0.1"

src/bson.rs

@@ -25,10 +25,10 @@ use std::fmt::{self, Display, Debug};
 
 use chrono::{DateTime, Timelike, UTC};
 use chrono::offset::TimeZone;
+use data_encoding::hex;
 
 use oid;
 use ordered::OrderedDocument;
-use rustc_serialize::hex::{FromHex, ToHex};
 use serde_json:: Value;
 use spec::{ElementType, BinarySubtype};
 
@@ -80,7 +80,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),
@@ -123,7 +123,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())
+                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),
@@ -301,7 +301,7 @@ impl Bson {
                 let tval: u8 = From::from(t);
                 json!({
                     "type": tval,
-                    "$binary": v.to_hex()
+                    "$binary": hex::encode(v)
                 })
             },
             &Bson::ObjectId(ref v) => json!({"$oid": v.to_string()}),
@@ -365,7 +365,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)
                 }
             }
@@ -409,7 +409,7 @@ impl Bson {
 
             } 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());
+                return Bson::Binary(From::from(ttype), hex::decode(hex.to_uppercase().as_bytes()).unwrap());
             }
 
         } else if values.len() == 1 {

src/lib.rs

@@ -45,9 +45,9 @@
 extern crate byteorder;
 extern crate chrono;
 extern crate crypto;
+extern crate data_encoding;
 extern crate libc;
 extern crate rand;
-extern crate rustc_serialize;
 extern crate serde;
 #[macro_use]
 extern crate serde_json;

src/oid.rs

@@ -6,9 +6,9 @@ use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 use byteorder::{ByteOrder, BigEndian, LittleEndian};
 use crypto::digest::Digest;
 use crypto::md5::Md5;
+use data_encoding::{self, hex};
 
 use rand::{Rng, OsRng};
-use rustc_serialize::hex::{self, FromHex, ToHex};
 
 use time;
 use hostname::get_hostname;
@@ -33,13 +33,13 @@ static mut MACHINE_BYTES: Option<[u8; 3]> = None;
 #[derive(Debug)]
 pub enum Error {
     ArgumentError(String),
-    FromHexError(hex::FromHexError),
+    FromHexError(data_encoding::decode::Error),
     IoError(io::Error),
     HostnameError,
 }
 
-impl From<hex::FromHexError> for Error {
-    fn from(err: hex::FromHexError) -> Error {
+impl From<data_encoding::decode::Error> for Error {
+    fn from(err: data_encoding::decode::Error) -> Error {
         Error::FromHexError(err)
     }
 }
@@ -124,7 +124,7 @@ impl ObjectId {
 
     /// Creates an ObjectID using a 12-byte (24-char) hexadecimal string.
     pub fn with_string(s: &str) -> Result<ObjectId> {
-        let bytes = try!(s.from_hex());
+        let bytes = try!(hex::decode(s.to_uppercase().as_bytes()));
         if bytes.len() != 12 {
             Err(Error::ArgumentError("Provided string must be a 12-byte hexadecimal string."
                 .to_owned()))
@@ -179,6 +179,11 @@ impl ObjectId {
         BigEndian::read_u32(&buf)
     }
 
+    /// Convert the objectId to hex representation.
+    pub fn to_hex(&self) -> String {
+        hex::encode(&self.id)
+    }
+
     // Generates a new timestamp representing the current seconds since epoch.
     // Represented in Big Endian.
     fn gen_timestamp() -> [u8; 4] {
@@ -263,12 +268,6 @@ impl ObjectId {
     }
 }
 
-impl ToHex for ObjectId {
-    fn to_hex(&self) -> String {
-        self.id.to_hex()
-    }
-}
-
 impl fmt::Display for ObjectId {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(&self.to_hex())
@@ -320,12 +319,12 @@ fn count_generated_is_big_endian() {
 fn test_display() {
     let id = ObjectId::with_string("53e37d08776f724e42000000").unwrap();
 
-    assert_eq!(format!("{}", id), "53e37d08776f724e42000000")
+    assert_eq!(format!("{}", id), "53E37D08776F724E42000000")
 }
 
 #[test]
 fn test_debug() {
     let id = ObjectId::with_string("53e37d08776f724e42000000").unwrap();
 
-    assert_eq!(format!("{:?}", id), "ObjectId(53e37d08776f724e42000000)")
+    assert_eq!(format!("{:?}", id), "ObjectId(53E37D08776F724E42000000)")
 }

tests/lib.rs

@@ -1,15 +1,15 @@
 #[macro_use(bson, doc)]
 extern crate bson;
 extern crate chrono;
-extern crate rustc_serialize;
+extern crate data_encoding;
 
 mod modules;
 
 use bson::Bson;
 use bson::spec::BinarySubtype;
 use bson::oid::ObjectId;
 use chrono::offset::utc::UTC;
-use rustc_serialize::hex::ToHex;
+use data_encoding::hex;
 
 #[test]
 fn test_format() {
@@ -45,7 +45,7 @@ fn test_format() {
         "date" => (Bson::UtcDatetime(date))
     };
 
-    let expected = format!("{{ float: 2.4, string: \"hello\", array: [\"testing\", 1], doc: {{ fish: \"in\", a: \"barrel\", !: 1 }}, bool: true, null: null, regexp: /s[ao]d/i, code: function(x) {{ return x._id; }}, i32: 12, i64: -55, timestamp: Timestamp(0, 229999444), binary: BinData(5, 0x{}), _id: ObjectId(\"{}\"), date: Date(\"{}\") }}", "thingies".as_bytes().to_hex(), id_string.as_bytes().to_hex(), date);
+    let expected = format!("{{ float: 2.4, string: \"hello\", array: [\"testing\", 1], doc: {{ fish: \"in\", a: \"barrel\", !: 1 }}, bool: true, null: null, regexp: /s[ao]d/i, code: function(x) {{ return x._id; }}, i32: 12, i64: -55, timestamp: Timestamp(0, 229999444), binary: BinData(5, 0x{}), _id: ObjectId(\"{}\"), date: Date(\"{}\") }}", hex::encode("thingies".as_bytes()), hex::encode(id_string.as_bytes()), date);
 
     assert_eq!(expected, format!("{}", doc));
 }

tests/modules/oid.rs

@@ -1,5 +1,5 @@
 use bson::oid::ObjectId;
-use rustc_serialize::hex::ToHex;
+use data_encoding::hex;
 
 #[test]
 fn deserialize() {
@@ -48,7 +48,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);
 }
 
@@ -63,7 +63,7 @@ fn byte_string_oid() {
                            0x83u8, 0x2Bu8, 0x21u8, 0x8Eu8];
 
     assert_eq!(bytes, oid.bytes());
-    assert_eq!(s, oid.to_string());
+    assert_eq!(s.to_uppercase(), oid.to_string());
 }
 
 #[test]