Make clippy happy

Author: zonyitoo

src/bson.rs

@@ -106,7 +106,7 @@ impl Debug for Bson {
             Bson::I64(v) => write!(f, "I64({:?})", v),
             Bson::TimeStamp(i) => {
                 let time = (i >> 32) as i32;
-                let inc = (i & 0xFFFFFFFF) as i32;
+                let inc = (i & 0xFFFF_FFFF) as i32;
 
                 write!(f, "TimeStamp({}, {})", time, inc)
             }
@@ -296,19 +296,19 @@ impl From<Bson> for Value {
             Bson::Boolean(v) => json!(v),
             Bson::Null => Value::Null,
             Bson::RegExp(pat, opt) => json!({
-                    "$regex": pat,
-                    "$options": opt
-                }),
+                "$regex": pat,
+                "$options": opt
+            }),
             Bson::JavaScriptCode(code) => json!({ "$code": code }),
             Bson::JavaScriptCodeWithScope(code, scope) => json!({
-                    "$code": code,
-                    "scope": scope
-                }),
+                "$code": code,
+                "scope": scope
+            }),
             Bson::I32(v) => v.into(),
             Bson::I64(v) => v.into(),
             Bson::TimeStamp(v) => {
                 let time = v >> 32;
-                let inc = v & 0x0000FFFF;
+                let inc = v & 0x0000_FFFF;
                 json!({
                     "t": time,
                     "i": inc
@@ -323,10 +323,10 @@ impl From<Bson> for Value {
             }
             Bson::ObjectId(v) => json!({"$oid": v.to_string()}),
             Bson::UtcDatetime(v) => json!({
-                    "$date": {
-                        "$numberLong": (v.timestamp() * 1000) + ((v.nanosecond() / 1000000) as i64)
-                    }
-                }),
+                "$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 }),
             Bson::Decimal128(ref v) => json!({ "$numberDecimal": v.to_string() }),
@@ -403,7 +403,7 @@ impl Bson {
             }
             Bson::TimeStamp(v) => {
                 let time = (v >> 32) as i32;
-                let inc = (v & 0xFFFFFFFF) as i32;
+                let inc = (v & 0xFFFF_FFFF) as i32;
 
                 doc! {
                     "t": time,
@@ -470,7 +470,7 @@ 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) * 1000000) as u32));
+                return Bson::UtcDatetime(Utc.timestamp(long / 1000, ((long % 1000) * 1_000_000) as u32));
             } else if let Ok(sym) = values.get_str("$symbol") {
                 return Bson::Symbol(sym.to_owned());
             } else if let Ok(dec) = values.get_str("$numberDecimal") {

src/encoder/error.rs

@@ -1,7 +1,7 @@
 use bson::Bson;
 use serde::ser;
-use std::{error, fmt, io};
 use std::fmt::Display;
+use std::{error, fmt, io};
 
 /// Possible errors that can arise during encoding.
 #[derive(Debug)]
@@ -27,10 +27,10 @@ impl fmt::Display for EncoderError {
             EncoderError::Unknown(ref inner) => inner.fmt(fmt),
             EncoderError::UnsupportedUnsignedType => fmt.write_str("BSON does not support unsigned type"),
             EncoderError::UnsignedTypesValueExceedsRange(value) => write!(
-                fmt,
-                "BSON does not support unsigned types.
+                                                                          fmt,
+                                                                          "BSON does not support unsigned types.
                  An attempt to encode the value: {} in a signed type failed due to the value's size.",
-                value
+                                                                          value
             ),
         }
     }
@@ -43,14 +43,16 @@ impl error::Error for EncoderError {
             EncoderError::InvalidMapKeyType(_) => "Invalid map key type",
             EncoderError::Unknown(ref inner) => inner,
             EncoderError::UnsupportedUnsignedType => "BSON does not support unsigned type",
-            EncoderError::UnsignedTypesValueExceedsRange(_) => "BSON does not support unsigned types.
+            EncoderError::UnsignedTypesValueExceedsRange(_) => {
+                "BSON does not support unsigned types.
                  An attempt to encode the value: {} in a signed type failed due to the values size."
+            }
         }
     }
 
     fn cause(&self) -> Option<&error::Error> {
-        match self {
-            &EncoderError::IoError(ref inner) => Some(inner),
+        match *self {
+            EncoderError::IoError(ref inner) => Some(inner),
             _ => None,
         }
     }

src/encoder/serde.rs

@@ -229,17 +229,17 @@ impl Serializer for Encoder {
 
     #[inline]
     fn serialize_seq(self, len: Option<usize>) -> EncoderResult<Self::SerializeSeq> {
-        Ok(ArraySerializer { inner: Array::with_capacity(len.unwrap_or(0)), })
+        Ok(ArraySerializer { inner: Array::with_capacity(len.unwrap_or(0)) })
     }
 
     #[inline]
     fn serialize_tuple(self, len: usize) -> EncoderResult<Self::SerializeTuple> {
-        Ok(TupleSerializer { inner: Array::with_capacity(len), })
+        Ok(TupleSerializer { inner: Array::with_capacity(len) })
     }
 
     #[inline]
     fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> EncoderResult<Self::SerializeTupleStruct> {
-        Ok(TupleStructSerializer { inner: Array::with_capacity(len), })
+        Ok(TupleStructSerializer { inner: Array::with_capacity(len) })
     }
 
     #[inline]
@@ -250,13 +250,13 @@ impl Serializer for Encoder {
                                len: usize)
                                -> EncoderResult<Self::SerializeTupleVariant> {
         Ok(TupleVariantSerializer { inner: Array::with_capacity(len),
-                                    name: variant, })
+                                    name: variant })
     }
 
     #[inline]
     fn serialize_map(self, _len: Option<usize>) -> EncoderResult<Self::SerializeMap> {
         Ok(MapSerializer { inner: Document::new(),
-                           next_key: None, })
+                           next_key: None })
     }
 
     #[inline]
@@ -272,7 +272,7 @@ impl Serializer for Encoder {
                                 _len: usize)
                                 -> EncoderResult<Self::SerializeStructVariant> {
         Ok(StructVariantSerializer { name: variant,
-                                     inner: Document::new(), })
+                                     inner: Document::new() })
     }
 }
 

src/oid.rs

@@ -2,7 +2,7 @@
 
 use libc;
 
-use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{error, fmt, io, result};
 
 use byteorder::{BigEndian, ByteOrder, LittleEndian};
@@ -25,9 +25,9 @@ const MACHINE_ID_OFFSET: usize = TIMESTAMP_OFFSET + TIMESTAMP_SIZE;
 const PROCESS_ID_OFFSET: usize = MACHINE_ID_OFFSET + MACHINE_ID_SIZE;
 const COUNTER_OFFSET: usize = PROCESS_ID_OFFSET + PROCESS_ID_SIZE;
 
-const MAX_U24: usize = 0xFFFFFF;
+const MAX_U24: usize = 0xFF_FFFF;
 
-static OID_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
+static OID_COUNTER: AtomicUsize = AtomicUsize::new(0);
 static mut MACHINE_BYTES: Option<[u8; 3]> = None;
 
 /// Errors that can occur during OID construction and generation.
@@ -130,9 +130,7 @@ impl ObjectId {
             Err(Error::ArgumentError("Provided string must be a 12-byte hexadecimal string.".to_owned()))
         } else {
             let mut byte_array: [u8; 12] = [0; 12];
-            for i in 0..12 {
-                byte_array[i] = bytes[i];
-            }
+            byte_array[..].copy_from_slice(&bytes[..]);
             Ok(ObjectId::with_bytes(byte_array))
         }
     }
@@ -203,7 +201,7 @@ impl ObjectId {
         // will have the same MACHINE_BYTES result.
         unsafe {
             if let Some(bytes) = MACHINE_BYTES.as_ref() {
-                return Ok(bytes.clone());
+                return Ok(*bytes);
             }
         }
 
@@ -219,9 +217,9 @@ impl ObjectId {
         // Re-convert string to bytes and grab first three
         let mut bytes = hash.bytes();
         let mut vec: [u8; 3] = [0; 3];
-        for i in 0..MACHINE_ID_SIZE {
+        for v in &mut vec {
             match bytes.next() {
-                Some(b) => vec[i] = b,
+                Some(b) => *v = b,
                 None => break,
             }
         }
@@ -287,7 +285,7 @@ fn pid_generation() {
 
 #[test]
 fn count_generated_is_big_endian() {
-    let start = 1122866;
+    let start = 1_122_866;
     OID_COUNTER.store(start, Ordering::SeqCst);
 
     // Test count generates correct value 1122866