chore: apply rustfmt to all crates (#917)

tokio-codec/src/bytes_codec.rs

@@ -1,6 +1,6 @@
-use bytes::{Bytes, BufMut, BytesMut};
-use tokio_io::_tokio_codec::{Encoder, Decoder};
+use bytes::{BufMut, Bytes, BytesMut};
 use std::io;
+use tokio_io::_tokio_codec::{Decoder, Encoder};
 
 /// A simple `Codec` implementation that just ships bytes around.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -8,7 +8,9 @@ pub struct BytesCodec(());
 
 impl BytesCodec {
     /// Creates a new `BytesCodec` for shipping around raw bytes.
-    pub fn new() -> BytesCodec { BytesCodec(())  }
+    pub fn new() -> BytesCodec {
+        BytesCodec(())
+    }
 }
 
 impl Decoder for BytesCodec {

tokio-codec/src/lib.rs

@@ -19,14 +19,7 @@ extern crate tokio_io;
 mod bytes_codec;
 mod lines_codec;
 
-pub use tokio_io::_tokio_codec::{
-    Decoder,
-    Encoder,
-    Framed,
-    FramedParts,
-    FramedRead,
-    FramedWrite,
-};
+pub use tokio_io::_tokio_codec::{Decoder, Encoder, Framed, FramedParts, FramedRead, FramedWrite};
 
 pub use bytes_codec::BytesCodec;
 pub use lines_codec::LinesCodec;

tokio-codec/src/lines_codec.rs

@@ -1,6 +1,6 @@
 use bytes::{BufMut, BytesMut};
-use tokio_io::_tokio_codec::{Encoder, Decoder};
 use std::{cmp, io, str, usize};
+use tokio_io::_tokio_codec::{Decoder, Encoder};
 
 /// A simple `Codec` implementation that splits up data into lines.
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -103,10 +103,8 @@ impl LinesCodec {
 }
 
 fn utf8(buf: &[u8]) -> Result<&str, io::Error> {
-    str::from_utf8(buf).map_err(|_|
-        io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Unable to decode input as UTF8"))
+    str::from_utf8(buf)
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Unable to decode input as UTF8"))
 }
 
 fn without_carriage_return(s: &[u8]) -> &[u8] {
@@ -153,7 +151,7 @@ impl Decoder for LinesCodec {
                     self.is_discarding = true;
                     Err(io::Error::new(
                         io::ErrorKind::Other,
-                        "line length limit exceeded"
+                        "line length limit exceeded",
                     ))
                 } else {
                     // We didn't find a line or reach the length limit, so the next

tokio-codec/tests/codecs.rs

@@ -1,8 +1,8 @@
-extern crate tokio_codec;
 extern crate bytes;
+extern crate tokio_codec;
 
-use bytes::{BytesMut, Bytes, BufMut};
-use tokio_codec::{BytesCodec, LinesCodec, Decoder, Encoder};
+use bytes::{BufMut, Bytes, BytesMut};
+use tokio_codec::{BytesCodec, Decoder, Encoder, LinesCodec};
 
 #[test]
 fn bytes_decoder() {
@@ -27,13 +27,17 @@ fn bytes_encoder() {
     const INLINE_CAP: usize = 4 * 4 - 1;
 
     let mut buf = BytesMut::new();
-    codec.encode(Bytes::from_static(&[0; INLINE_CAP + 1]), &mut buf).unwrap();
+    codec
+        .encode(Bytes::from_static(&[0; INLINE_CAP + 1]), &mut buf)
+        .unwrap();
 
     // Default capacity of Framed Read
     const INITIAL_CAPACITY: usize = 8 * 1024;
 
     let mut buf = BytesMut::with_capacity(INITIAL_CAPACITY);
-    codec.encode(Bytes::from_static(&[0; INITIAL_CAPACITY + 1]), &mut buf).unwrap();
+    codec
+        .encode(Bytes::from_static(&[0; INITIAL_CAPACITY + 1]), &mut buf)
+        .unwrap();
 }
 
 #[test]
@@ -68,17 +72,32 @@ fn lines_decoder_max_length() {
     assert!(codec.decode(buf).is_err());
 
     let line = codec.decode(buf).unwrap().unwrap();
-    assert!(line.len() <= MAX_LENGTH, "{:?}.len() <= {:?}", line, MAX_LENGTH);
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
     assert_eq!("line 2", line);
 
     assert!(codec.decode(buf).is_err());
 
     let line = codec.decode(buf).unwrap().unwrap();
-    assert!(line.len() <= MAX_LENGTH, "{:?}.len() <= {:?}", line, MAX_LENGTH);
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
     assert_eq!("line 4", line);
 
     let line = codec.decode(buf).unwrap().unwrap();
-    assert!(line.len() <= MAX_LENGTH, "{:?}.len() <= {:?}", line, MAX_LENGTH);
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
     assert_eq!("", line);
 
     assert_eq!(None, codec.decode(buf).unwrap());
@@ -87,7 +106,12 @@ fn lines_decoder_max_length() {
     assert_eq!(None, codec.decode(buf).unwrap());
 
     let line = codec.decode_eof(buf).unwrap().unwrap();
-    assert!(line.len() <= MAX_LENGTH, "{:?}.len() <= {:?}", line, MAX_LENGTH);
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
     assert_eq!("\rk", line);
 
     assert_eq!(None, codec.decode(buf).unwrap());

tokio-codec/tests/framed.rs

@@ -1,13 +1,13 @@
-extern crate tokio_codec;
-extern crate tokio_io;
 extern crate bytes;
 extern crate futures;
+extern crate tokio_codec;
+extern crate tokio_io;
 
-use futures::{Stream, Future};
+use bytes::{Buf, BufMut, BytesMut, IntoBuf};
+use futures::{Future, Stream};
 use std::io::{self, Read};
-use tokio_codec::{Framed, FramedParts, Decoder, Encoder};
+use tokio_codec::{Decoder, Encoder, Framed, FramedParts};
 use tokio_io::AsyncRead;
-use bytes::{BytesMut, Buf, BufMut, IntoBuf};
 
 const INITIAL_CAPACITY: usize = 8 * 1024;
 
@@ -45,8 +45,10 @@ struct DontReadIntoThis;
 
 impl Read for DontReadIntoThis {
     fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
-        Err(io::Error::new(io::ErrorKind::Other,
-                           "Read into something you weren't supposed to."))
+        Err(io::Error::new(
+            io::ErrorKind::Other,
+            "Read into something you weren't supposed to.",
+        ))
     }
 }
 
@@ -61,9 +63,7 @@ fn can_read_from_existing_buf() {
 
     let num = framed
         .into_future()
-        .map(|(first_num, _)| {
-            first_num.unwrap()
-        })
+        .map(|(first_num, _)| first_num.unwrap())
         .wait()
         .map_err(|e| e.0)
         .unwrap();

tokio-codec/tests/framed_read.rs

@@ -1,17 +1,17 @@
-extern crate tokio_codec;
-extern crate tokio_io;
 extern crate bytes;
 extern crate futures;
+extern crate tokio_codec;
+extern crate tokio_io;
 
+use tokio_codec::{Decoder, FramedRead};
 use tokio_io::AsyncRead;
-use tokio_codec::{FramedRead, Decoder};
 
-use bytes::{BytesMut, Buf, IntoBuf};
+use bytes::{Buf, BytesMut, IntoBuf};
+use futures::Async::{NotReady, Ready};
 use futures::Stream;
-use futures::Async::{Ready, NotReady};
 
-use std::io::{self, Read};
 use std::collections::VecDeque;
+use std::io::{self, Read};
 
 macro_rules! mock {
     ($($x:expr,)*) => {{
@@ -212,5 +212,4 @@ impl Read for Mock {
     }
 }
 
-impl AsyncRead for Mock {
-}
+impl AsyncRead for Mock {}

tokio-codec/tests/framed_write.rs

@@ -1,16 +1,16 @@
-extern crate tokio_codec;
-extern crate tokio_io;
 extern crate bytes;
 extern crate futures;
+extern crate tokio_codec;
+extern crate tokio_io;
 
-use tokio_io::AsyncWrite;
 use tokio_codec::{Encoder, FramedWrite};
+use tokio_io::AsyncWrite;
 
-use futures::{Sink, Poll};
-use bytes::{BytesMut, BufMut};
+use bytes::{BufMut, BytesMut};
+use futures::{Poll, Sink};
 
-use std::io::{self, Write};
 use std::collections::VecDeque;
+use std::io::{self, Write};
 
 macro_rules! mock {
     ($($x:expr,)*) => {{