[#43] Support Symbol, rustfmt format

Author: zonyitoo

src/bson.rs

@@ -50,6 +50,7 @@ pub enum Bson {
     Binary(BinarySubtype, Vec<u8>),
     ObjectId(oid::ObjectId),
     UtcDatetime(DateTime<UTC>),
+    Symbol(String),
 }
 
 /// Alias for `Vec<Bson>`.
@@ -94,7 +95,8 @@ impl Display for Bson {
             &Bson::Binary(t, ref vec) =>
                 write!(fmt, "BinData({}, 0x{})", u8::from(t), vec.to_hex()),
             &Bson::ObjectId(ref id) => write!(fmt, "ObjectId(\"{}\")", id),
-            &Bson::UtcDatetime(date_time) => write!(fmt, "Date(\"{}\")", date_time)
+            &Bson::UtcDatetime(date_time) => write!(fmt, "Date(\"{}\")", date_time),
+            &Bson::Symbol(ref sym) => write!(fmt, "Symbol(\"{}\")", sym),
         }
     }
 }
@@ -229,6 +231,7 @@ impl Bson {
             &Bson::Binary(..) => ElementType::Binary,
             &Bson::ObjectId(..) => ElementType::ObjectId,
             &Bson::UtcDatetime(..) => ElementType::UtcDatetime,
+            &Bson::Symbol(..) => ElementType::Symbol,
         }
     }
 
@@ -295,10 +298,16 @@ impl Bson {
             &Bson::UtcDatetime(ref v) => {
                 let mut obj = json::Object::new();
                 let mut inner = json::Object::new();
-                inner.insert("$numberLong".to_owned(), json::Json::I64((v.timestamp() * 1000) + 
+                inner.insert("$numberLong".to_owned(), json::Json::I64((v.timestamp() * 1000) +
                                                                        (v.nanosecond() / 1000000) as i64));
                 obj.insert("$date".to_owned(), json::Json::Object(inner));
                 json::Json::Object(obj)
+            },
+            &Bson::Symbol(ref v) => {
+                // FIXME: Don't know what is the best way to encode Symbol type
+                let mut obj = json::Object::new();
+                obj.insert("$symbol".to_owned(), json::Json::String(v.to_owned()));
+                json::Json::Object(obj)
             }
         }
     }
@@ -365,13 +374,18 @@ impl Bson {
                     }
                 }
             }
+            Bson::Symbol(ref v) => {
+                doc! {
+                    "$symbol" => (v.to_owned())
+                }
+            }
             _ => panic!("Attempted conversion of invalid data type: {}", self),
         }
     }
 
     pub fn from_extended_document(values: Document) -> Bson {
         if values.len() == 2 {
-            if let (Ok(pat), Ok(opt)) = (values.get_str("$regex"), 
+            if let (Ok(pat), Ok(opt)) = (values.get_str("$regex"),
                                          values.get_str("$options")) {
                 return Bson::RegExp(pat.to_owned(), opt.to_owned());
 
@@ -405,9 +419,11 @@ impl Bson {
             } 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));
+            } else if let Ok(sym) = values.get_str("$symbol") {
+                return Bson::Symbol(sym.to_owned());
             }
         }
-        
+
         Bson::Document(values)
     }
 }

src/decoder/error.rs

@@ -78,7 +78,7 @@ impl error::Error for DecoderError {
         match *self {
             DecoderError::IoError(ref inner) => Some(inner),
             DecoderError::Utf8Error(ref inner) => Some(inner),
-            _ => None
+            _ => None,
         }
     }
 }

src/decoder/mod.rs

@@ -31,7 +31,7 @@ use std::io::Read;
 use std::str;
 
 use byteorder::{LittleEndian, ReadBytesExt};
-use chrono::{UTC};
+use chrono::UTC;
 use chrono::offset::TimeZone;
 
 use spec::{self, BinarySubtype};
@@ -55,7 +55,9 @@ fn read_cstring<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<String> {
 
     loop {
         let c = try!(reader.read_u8());
-        if c == 0 { break; }
+        if c == 0 {
+            break;
+        }
         v.push(c);
     }
 
@@ -123,9 +125,7 @@ fn decode_array<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<Array> {
 fn decode_bson<R: Read + ?Sized>(reader: &mut R, tag: u8) -> DecoderResult<Bson> {
     use spec::ElementType::*;
     match spec::ElementType::from(tag) {
-        Some(FloatingPoint) => {
-            Ok(Bson::FloatingPoint(try!(reader.read_f64::<LittleEndian>())))
-        },
+        Some(FloatingPoint) => Ok(Bson::FloatingPoint(try!(reader.read_f64::<LittleEndian>()))),
         Some(Utf8String) => read_string(reader).map(Bson::String),
         Some(EmbeddedDocument) => decode_document(reader).map(Bson::Document),
         Some(Array) => decode_array(reader).map(Bson::Array),
@@ -149,7 +149,7 @@ fn decode_bson<R: Read + ?Sized>(reader: &mut R, tag: u8) -> DecoderResult<Bson>
             let pat = try!(read_cstring(reader));
             let opt = try!(read_cstring(reader));
             Ok(Bson::RegExp(pat, opt))
-        },
+        }
         Some(JavaScriptCode) => read_string(reader).map(Bson::JavaScriptCode),
         Some(JavaScriptCodeWithScope) => {
             // disregard the length:
@@ -159,20 +159,18 @@ fn decode_bson<R: Read + ?Sized>(reader: &mut R, tag: u8) -> DecoderResult<Bson>
             let code = try!(read_string(reader));
             let scope = try!(decode_document(reader));
             Ok(Bson::JavaScriptCodeWithScope(code, scope))
-        },
+        }
         Some(Integer32Bit) => read_i32(reader).map(Bson::I32),
         Some(Integer64Bit) => read_i64(reader).map(Bson::I64),
         Some(TimeStamp) => read_i64(reader).map(Bson::TimeStamp),
         Some(UtcDatetime) => {
             let time = try!(read_i64(reader));
             Ok(Bson::UtcDatetime(UTC.timestamp(time / 1000, (time % 1000) as u32 * 1000000)))
-        },
-	Some(Deprecated) |
-        Some(Undefined) |
-        Some(DbPointer) |
-        Some(MaxKey) |
-        Some(MinKey) |
-        None => Err(DecoderError::UnrecognizedElementType(tag))
+        }
+        Some(Symbol) => read_string(reader).map(Bson::Symbol),
+        Some(Undefined) | Some(DbPointer) | Some(MaxKey) | Some(MinKey) | None => {
+            Err(DecoderError::UnrecognizedElementType(tag))
+        }
     }
 }