fix formatting

examples/autobahn-client.rs

@@ -1,8 +1,8 @@
 /// WebSocket client used for testing against the Autobahn Test Suite
 extern crate ws;
 
-use std::rc::Rc;
 use std::cell::Cell;
+use std::rc::Rc;
 use ws::{connect, CloseCode, Message, Result};
 
 #[cfg(feature = "permessage-deflate")]

examples/channel.rs

@@ -10,11 +10,11 @@ extern crate env_logger;
 /// complex system from simple, composable parts.
 extern crate ws;
 
+use std::sync::mpsc::Sender as ThreadOut;
+use std::sync::mpsc::channel;
 use std::thread;
 use std::thread::sleep;
 use std::time::Duration;
-use std::sync::mpsc::channel;
-use std::sync::mpsc::Sender as ThreadOut;
 
 use ws::{connect, listen, CloseCode, Handler, Handshake, Message, Result, Sender};
 

examples/cli.rs

@@ -8,9 +8,9 @@ extern crate ws;
 
 use std::io;
 use std::io::prelude::*;
-use std::thread;
-use std::sync::mpsc::channel;
 use std::sync::mpsc::Sender as TSender;
+use std::sync::mpsc::channel;
+use std::thread;
 
 use clap::{App, Arg};
 use ws::{connect, CloseCode, Error, ErrorKind, Handler, Handshake, Message, Result, Sender};

examples/external_shutdown.rs

@@ -1,8 +1,8 @@
 extern crate ws;
 
+use std::sync::mpsc::channel;
 use std::thread;
 use std::time::Duration;
-use std::sync::mpsc::channel;
 
 fn main() {
     let (tx, rx) = channel();

examples/pong.rs

@@ -8,9 +8,9 @@ use std::str::from_utf8;
 
 use mio_extras::timer::Timeout;
 
+use ws::util::Token;
 use ws::{listen, CloseCode, Error, ErrorKind, Frame, Handler, Handshake, Message, OpCode, Result,
          Sender};
-use ws::util::Token;
 
 const PING: Token = Token(1);
 const EXPIRE: Token = Token(2);

examples/ssl-server.rs

@@ -13,17 +13,17 @@ extern crate openssl;
 extern crate ws;
 
 #[cfg(feature = "ssl")]
-use std::rc::Rc;
+use std::fs::File;
 #[cfg(feature = "ssl")]
 use std::io::Read;
 #[cfg(feature = "ssl")]
-use std::fs::File;
+use std::rc::Rc;
 
-#[cfg(feature = "ssl")]
-use openssl::ssl::{SslAcceptor, SslAcceptorBuilder, SslMethod, SslStream};
 #[cfg(feature = "ssl")]
 use openssl::pkey::PKey;
 #[cfg(feature = "ssl")]
+use openssl::ssl::{SslAcceptor, SslAcceptorBuilder, SslMethod, SslStream};
+#[cfg(feature = "ssl")]
 use openssl::x509::{X509, X509Ref};
 
 #[cfg(feature = "ssl")]

src/communication.rs

@@ -1,16 +1,16 @@
-use std::convert::Into;
 use std::borrow::Cow;
+use std::convert::Into;
 
-use url;
 use mio;
 use mio::Token;
 use mio_extras::timer::Timeout;
+use url;
 
+use io::ALL;
 use message;
-use result::{Error, Result};
 use protocol::CloseCode;
+use result::{Error, Result};
 use std::cmp::PartialEq;
-use io::ALL;
 
 #[derive(Debug, Clone)]
 pub enum Signal {

src/connection.rs

@@ -1,28 +1,28 @@
-use std::mem::replace;
 use std::borrow::Borrow;
+use std::collections::VecDeque;
 use std::io::{Cursor, Read, Seek, SeekFrom, Write};
+use std::mem::replace;
 use std::net::SocketAddr;
-use std::collections::VecDeque;
 use std::str::from_utf8;
 
-use url;
+use mio::tcp::TcpStream;
 use mio::{Ready, Token};
 use mio_extras::timer::Timeout;
-use mio::tcp::TcpStream;
+use url;
 
 #[cfg(feature = "ssl")]
 use openssl::ssl::HandshakeError;
 
-use message::Message;
-use handshake::{Handshake, Request, Response};
 use frame::Frame;
+use handler::Handler;
+use handshake::{Handshake, Request, Response};
+use message::Message;
 use protocol::{CloseCode, OpCode};
 use result::{Error, Kind, Result};
-use handler::Handler;
 use stream::{Stream, TryReadBuf, TryWriteBuf};
 
-use self::State::*;
 use self::Endpoint::*;
+use self::State::*;
 
 use super::Settings;
 

src/deflate/extension.rs

@@ -4,15 +4,15 @@ use std::mem::replace;
 use openssl::ssl::SslStream;
 use url;
 
+use frame::Frame;
 use handler::Handler;
+use handshake::{Handshake, Request, Response};
 use message::Message;
-use frame::Frame;
 use protocol::{CloseCode, OpCode};
-use handshake::{Handshake, Request, Response};
 use result::{Error, Kind, Result};
-use util::{Timeout, Token};
 #[cfg(feature = "ssl")]
 use util::TcpStream;
+use util::{Timeout, Token};
 
 use super::context::{Compressor, Decompressor};
 

src/factory.rs

@@ -1,5 +1,5 @@
-use handler::Handler;
 use communication::Sender;
+use handler::Handler;
 
 /// A trait for creating new WebSocket handlers.
 pub trait Factory {
@@ -116,13 +116,13 @@ where
 mod test {
     #![allow(unused_imports, unused_variables, dead_code)]
     use super::*;
-    use mio;
     use communication::{Command, Sender};
-    use handshake::{Handshake, Request, Response};
-    use protocol::CloseCode;
     use frame;
-    use message;
     use handler::Handler;
+    use handshake::{Handshake, Request, Response};
+    use message;
+    use mio;
+    use protocol::CloseCode;
     use result::Result;
 
     #[derive(Debug, Eq, PartialEq)]

src/frame.rs

@@ -1,12 +1,12 @@
+use std::default::Default;
 use std::fmt;
 use std::io::{Cursor, ErrorKind, Read, Write};
-use std::default::Default;
 
-use rand;
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use rand;
 
-use result::{Error, Kind, Result};
 use protocol::{CloseCode, OpCode};
+use result::{Error, Kind, Result};
 use stream::TryReadBuf;
 
 fn apply_mask(buf: &mut [u8], mask: &[u8; 4]) {

src/handler.rs

@@ -1,12 +1,12 @@
-use url;
 use log::Level::Error as ErrorLevel;
 #[cfg(feature = "ssl")]
 use openssl::ssl::{SslConnectorBuilder, SslMethod, SslStream};
+use url;
 
-use message::Message;
 use frame::Frame;
-use protocol::CloseCode;
 use handshake::{Handshake, Request, Response};
+use message::Message;
+use protocol::CloseCode;
 use result::{Error, Kind, Result};
 use util::{Timeout, Token};
 
@@ -327,13 +327,13 @@ where
 mod test {
     #![allow(unused_imports, unused_variables, dead_code)]
     use super::*;
-    use url;
-    use mio;
-    use handshake::{Handshake, Request, Response};
-    use protocol::CloseCode;
     use frame;
+    use handshake::{Handshake, Request, Response};
     use message;
+    use mio;
+    use protocol::CloseCode;
     use result::Result;
+    use url;
 
     #[derive(Debug, Eq, PartialEq)]
     struct M;

src/handshake.rs

@@ -1,12 +1,12 @@
 use std::fmt;
 use std::io::Write;
-use std::str::from_utf8;
 use std::net::SocketAddr;
+use std::str::from_utf8;
 
-use sha1;
+use httparse;
 use rand;
+use sha1;
 use url;
-use httparse;
 
 use result::{Error, Kind, Result};
 
@@ -656,10 +656,10 @@ impl fmt::Display for Response {
 
 mod test {
     #![allow(unused_imports, unused_variables, dead_code)]
+    use super::*;
     use std::io::Write;
     use std::net::SocketAddr;
     use std::str::FromStr;
-    use super::*;
 
     #[test]
     fn remote_addr() {

src/io.rs

@@ -1,25 +1,25 @@
-use std::net::{SocketAddr, ToSocketAddrs};
 use std::borrow::Borrow;
+use std::io::{Error as IoError, ErrorKind};
+use std::net::{SocketAddr, ToSocketAddrs};
 use std::time::Duration;
 use std::usize;
-use std::io::{Error as IoError, ErrorKind};
 
 use mio;
-use mio::{Poll, PollOpt, Ready, Token};
 use mio::tcp::{TcpListener, TcpStream};
+use mio::{Poll, PollOpt, Ready, Token};
 use mio_extras;
 
 use url::Url;
 
 #[cfg(feature = "ssl")]
 use openssl::ssl::Error as SslError;
 
+use super::Settings;
 use communication::{Command, Sender, Signal};
-use result::{Error, Kind, Result};
 use connection::Connection;
 use factory::Factory;
+use result::{Error, Kind, Result};
 use util::Slab;
-use super::Settings;
 
 const QUEUE: Token = Token(usize::MAX - 3);
 const TIMER: Token = Token(usize::MAX - 4);
@@ -930,9 +930,9 @@ mod test {
 
     use url::Url;
 
-    use result::{Error, Kind};
-    use super::*;
     use super::url_to_addrs;
+    use super::*;
+    use result::{Error, Kind};
 
     #[test]
     fn test_url_to_addrs() {

src/lib.rs

@@ -17,16 +17,16 @@ extern crate url;
 #[macro_use]
 extern crate log;
 
-mod result;
+mod communication;
 mod connection;
-mod handler;
 mod factory;
 mod frame;
-mod message;
+mod handler;
 mod handshake;
-mod protocol;
-mod communication;
 mod io;
+mod message;
+mod protocol;
+mod result;
 mod stream;
 
 #[cfg(feature = "permessage-deflate")]
@@ -37,18 +37,18 @@ pub mod util;
 pub use factory::Factory;
 pub use handler::Handler;
 
-pub use result::{Error, Result};
-pub use result::Kind as ErrorKind;
-pub use message::Message;
 pub use communication::Sender;
 pub use frame::Frame;
-pub use protocol::{CloseCode, OpCode};
 pub use handshake::{Handshake, Request, Response};
+pub use message::Message;
+pub use protocol::{CloseCode, OpCode};
+pub use result::Kind as ErrorKind;
+pub use result::{Error, Result};
 
-use std::fmt;
+use std::borrow::Borrow;
 use std::default::Default;
+use std::fmt;
 use std::net::{SocketAddr, ToSocketAddrs};
-use std::borrow::Borrow;
 
 use mio::Poll;
 

src/message.rs

@@ -1,7 +1,7 @@
-use std::fmt;
 use std::convert::{From, Into};
-use std::str::from_utf8;
+use std::fmt;
 use std::result::Result as StdResult;
+use std::str::from_utf8;
 
 use protocol::OpCode;
 use result::Result;

src/protocol.rs

@@ -1,5 +1,5 @@
-use std::fmt;
 use std::convert::{From, Into};
+use std::fmt;
 
 use self::OpCode::*;
 /// Operation codes as part of rfc6455.

src/result.rs

@@ -1,10 +1,10 @@
+use std::borrow::Cow;
+use std::convert::{From, Into};
+use std::error::Error as StdError;
 use std::fmt;
 use std::io;
-use std::borrow::Cow;
-use std::str::Utf8Error;
 use std::result::Result as StdResult;
-use std::error::Error as StdError;
-use std::convert::{From, Into};
+use std::str::Utf8Error;
 
 use httparse;
 use mio;