Edition 2018, formatting, clippy fixes

Cargo.toml

@@ -10,6 +10,7 @@ homepage = "https://github.com/snapview/tungstenite-rs"
 documentation = "https://docs.rs/tungstenite/0.9.1"
 repository = "https://github.com/snapview/tungstenite-rs"
 version = "0.9.1"
+edition = "2018"
 
 [features]
 default = ["tls"]

examples/autobahn-client.rs

@@ -1,46 +1,43 @@
-#[macro_use] extern crate log;
-extern crate env_logger;
-extern crate tungstenite;
-extern crate url;
-
+use log::*;
 use url::Url;
 
-use tungstenite::{connect, Error, Result, Message};
+use tungstenite::{connect, Error, Message, Result};
 
 const AGENT: &'static str = "Tungstenite";
 
 fn get_case_count() -> Result<u32> {
-    let (mut socket, _) = connect(
-        Url::parse("ws://localhost:9001/getCaseCount").unwrap(),
-    )?;
+    let (mut socket, _) = connect(Url::parse("ws://localhost:9001/getCaseCount").unwrap())?;
     let msg = socket.read_message()?;
     socket.close(None)?;
     Ok(msg.into_text()?.parse::<u32>().unwrap())
 }
 
 fn update_reports() -> Result<()> {
     let (mut socket, _) = connect(
-        Url::parse(&format!("ws://localhost:9001/updateReports?agent={}", AGENT)).unwrap(),
+        Url::parse(&format!(
+            "ws://localhost:9001/updateReports?agent={}",
+            AGENT
+        ))
+        .unwrap(),
     )?;
     socket.close(None)?;
     Ok(())
 }
 
 fn run_test(case: u32) -> Result<()> {
     info!("Running test case {}", case);
-    let case_url = Url::parse(
-        &format!("ws://localhost:9001/runCase?case={}&agent={}", case, AGENT)
-    ).unwrap();
+    let case_url = Url::parse(&format!(
+        "ws://localhost:9001/runCase?case={}&agent={}",
+        case, AGENT
+    ))
+    .unwrap();
     let (mut socket, _) = connect(case_url)?;
     loop {
         match socket.read_message()? {
-            msg @ Message::Text(_) |
-            msg @ Message::Binary(_) => {
+            msg @ Message::Text(_) | msg @ Message::Binary(_) => {
                 socket.write_message(msg)?;
             }
-            Message::Ping(_) |
-            Message::Pong(_) |
-            Message::Close(_) => {}
+            Message::Ping(_) | Message::Pong(_) | Message::Close(_) => {}
         }
     }
 }
@@ -53,12 +50,13 @@ fn main() {
     for case in 1..(total + 1) {
         if let Err(e) = run_test(case) {
             match e {
-                Error::Protocol(_) => { }
-                err => { warn!("test: {}", err); }
+                Error::Protocol(_) => {}
+                err => {
+                    warn!("test: {}", err);
+                }
             }
         }
     }
 
     update_reports().unwrap();
 }
-

examples/autobahn-server.rs

@@ -1,12 +1,9 @@
-#[macro_use] extern crate log;
-extern crate env_logger;
-extern crate tungstenite;
-
 use std::net::{TcpListener, TcpStream};
 use std::thread::spawn;
 
-use tungstenite::{accept, HandshakeError, Error, Result, Message};
+use log::*;
 use tungstenite::handshake::HandshakeRole;
+use tungstenite::{accept, Error, HandshakeError, Message, Result};
 
 fn must_not_block<Role: HandshakeRole>(err: HandshakeError<Role>) -> Error {
     match err {
@@ -19,13 +16,10 @@ fn handle_client(stream: TcpStream) -> Result<()> {
     let mut socket = accept(stream).map_err(must_not_block)?;
     loop {
         match socket.read_message()? {
-            msg @ Message::Text(_) |
-            msg @ Message::Binary(_) => {
+            msg @ Message::Text(_) | msg @ Message::Binary(_) => {
                 socket.write_message(msg)?;
             }
-            Message::Ping(_) |
-            Message::Pong(_) |
-            Message::Close(_) => {}
+            Message::Ping(_) | Message::Pong(_) | Message::Close(_) => {}
         }
     }
 }
@@ -36,14 +30,12 @@ fn main() {
     let server = TcpListener::bind("127.0.0.1:9002").unwrap();
 
     for stream in server.incoming() {
-        spawn(move || {
-            match stream {
-                Ok(stream) => match handle_client(stream) {
-                    Ok(_) => (),
-                    Err(e) => warn!("Error in client: {}", e),
-                },
-                Err(e) => warn!("Error accepting stream: {}", e),
-            }
+        spawn(move || match stream {
+            Ok(stream) => match handle_client(stream) {
+                Ok(_) => (),
+                Err(e) => warn!("Error in client: {}", e),
+            },
+            Err(e) => warn!("Error accepting stream: {}", e),
         });
     }
 }

examples/callback-error.rs

@@ -1,10 +1,8 @@
-extern crate tungstenite;
-
-use std::thread::spawn;
 use std::net::TcpListener;
+use std::thread::spawn;
 
 use tungstenite::accept_hdr;
-use tungstenite::handshake::server::{Request, ErrorResponse};
+use tungstenite::handshake::server::{ErrorResponse, Request};
 use tungstenite::http::StatusCode;
 
 fn main() {

examples/client.rs

@@ -1,15 +1,11 @@
-extern crate tungstenite;
-extern crate url;
-extern crate env_logger;
-
+use tungstenite::{connect, Message};
 use url::Url;
-use tungstenite::{Message, connect};
 
 fn main() {
     env_logger::init();
 
-    let (mut socket, response) = connect(Url::parse("ws://localhost:3012/socket").unwrap())
-        .expect("Can't connect");
+    let (mut socket, response) =
+        connect(Url::parse("ws://localhost:3012/socket").unwrap()).expect("Can't connect");
 
     println!("Connected to the server");
     println!("Response HTTP code: {}", response.code);
@@ -18,11 +14,12 @@ fn main() {
         println!("* {}", header);
     }
 
-    socket.write_message(Message::Text("Hello WebSocket".into())).unwrap();
+    socket
+        .write_message(Message::Text("Hello WebSocket".into()))
+        .unwrap();
     loop {
         let msg = socket.read_message().expect("Error reading message");
         println!("Received: {}", msg);
     }
     // socket.close(None);
-
 }

examples/server.rs

@@ -1,8 +1,5 @@
-extern crate tungstenite;
-extern crate env_logger;
-
-use std::thread::spawn;
 use std::net::TcpListener;
+use std::thread::spawn;
 
 use tungstenite::accept_hdr;
 use tungstenite::handshake::server::Request;
@@ -23,7 +20,10 @@ fn main() {
                 // Let's add an additional header to our response to the client.
                 let extra_headers = vec![
                     (String::from("MyCustomHeader"), String::from(":)")),
-                    (String::from("SOME_TUNGSTENITE_HEADER"), String::from("header_value")),
+                    (
+                        String::from("SOME_TUNGSTENITE_HEADER"),
+                        String::from("header_value"),
+                    ),
                 ];
                 Ok(Some(extra_headers))
             };

fuzz/Cargo.toml

@@ -1,4 +1,3 @@
-
 [package]
 name = "tungstenite-fuzz"
 version = "0.0.1"

src/client.rs

@@ -1,49 +1,53 @@
 //! Methods to connect to an WebSocket as a client.
 
-use std::net::{TcpStream, SocketAddr, ToSocketAddrs};
-use std::result::Result as StdResult;
 use std::io::{Read, Write};
+use std::net::{SocketAddr, TcpStream, ToSocketAddrs};
+use std::result::Result as StdResult;
 
+use log::*;
 use url::Url;
 
-use handshake::client::Response;
-use protocol::WebSocketConfig;
+use crate::handshake::client::Response;
+use crate::protocol::WebSocketConfig;
 
-#[cfg(feature="tls")]
+#[cfg(feature = "tls")]
 mod encryption {
-    use std::net::TcpStream;
-    use native_tls::{TlsConnector, HandshakeError as TlsHandshakeError};
     pub use native_tls::TlsStream;
+    use native_tls::{HandshakeError as TlsHandshakeError, TlsConnector};
+    use std::net::TcpStream;
 
-    pub use stream::Stream as StreamSwitcher;
+    pub use crate::stream::Stream as StreamSwitcher;
     /// TCP stream switcher (plain/TLS).
     pub type AutoStream = StreamSwitcher<TcpStream, TlsStream<TcpStream>>;
 
-    use stream::Mode;
-    use error::Result;
+    use crate::error::Result;
+    use crate::stream::Mode;
 
     pub fn wrap_stream(stream: TcpStream, domain: &str, mode: Mode) -> Result<AutoStream> {
         match mode {
             Mode::Plain => Ok(StreamSwitcher::Plain(stream)),
             Mode::Tls => {
                 let connector = TlsConnector::builder().build()?;
-                connector.connect(domain, stream)
+                connector
+                    .connect(domain, stream)
                     .map_err(|e| match e {
                         TlsHandshakeError::Failure(f) => f.into(),
-                        TlsHandshakeError::WouldBlock(_) => panic!("Bug: TLS handshake not blocked"),
+                        TlsHandshakeError::WouldBlock(_) => {
+                            panic!("Bug: TLS handshake not blocked")
+                        }
                     })
                     .map(StreamSwitcher::Tls)
             }
         }
     }
 }
 
-#[cfg(not(feature="tls"))]
+#[cfg(not(feature = "tls"))]
 mod encryption {
     use std::net::TcpStream;
 
-    use stream::Mode;
     use error::{Error, Result};
+    use stream::Mode;
 
     /// TLS support is nod compiled in, this is just standard `TcpStream`.
     pub type AutoStream = TcpStream;
@@ -56,15 +60,14 @@ mod encryption {
     }
 }
 
-pub use self::encryption::AutoStream;
 use self::encryption::wrap_stream;
+pub use self::encryption::AutoStream;
 
-use protocol::WebSocket;
-use handshake::HandshakeError;
-use handshake::client::{ClientHandshake, Request};
-use stream::{NoDelay, Mode};
-use error::{Error, Result};
-
+use crate::error::{Error, Result};
+use crate::handshake::client::{ClientHandshake, Request};
+use crate::handshake::HandshakeError;
+use crate::protocol::WebSocket;
+use crate::stream::{Mode, NoDelay};
 
 /// Connect to the given WebSocket in blocking mode.
 ///
@@ -83,13 +86,17 @@ use error::{Error, Result};
 /// `connect` since it's the only function that uses native_tls.
 pub fn connect_with_config<'t, Req: Into<Request<'t>>>(
     request: Req,
-    config: Option<WebSocketConfig>
+    config: Option<WebSocketConfig>,
 ) -> Result<(WebSocket<AutoStream>, Response)> {
     let request: Request = request.into();
     let mode = url_mode(&request.url)?;
-    let host = request.url.host()
+    let host = request
+        .url
+        .host()
         .ok_or_else(|| Error::Url("No host name in the URL".into()))?;
-    let port = request.url.port_or_known_default()
+    let port = request
+        .url
+        .port_or_known_default()
         .ok_or_else(|| Error::Url("No port number in the URL".into()))?;
     let addrs;
     let addr;
@@ -109,11 +116,10 @@ pub fn connect_with_config<'t, Req: Into<Request<'t>>>(
     };
     let mut stream = connect_to_some(addrs, &request.url, mode)?;
     NoDelay::set_nodelay(&mut stream, true)?;
-    client_with_config(request, stream, config)
-        .map_err(|e| match e {
-            HandshakeError::Failure(f) => f,
-            HandshakeError::Interrupted(_) => panic!("Bug: blocking handshake not blocked"),
-        })
+    client_with_config(request, stream, config).map_err(|e| match e {
+        HandshakeError::Failure(f) => f,
+        HandshakeError::Interrupted(_) => panic!("Bug: blocking handshake not blocked"),
+    })
 }
 
 /// Connect to the given WebSocket in blocking mode.
@@ -128,19 +134,21 @@ pub fn connect_with_config<'t, Req: Into<Request<'t>>>(
 /// This function uses `native_tls` to do TLS. If you want to use other TLS libraries,
 /// use `client` instead. There is no need to enable the "tls" feature if you don't call
 /// `connect` since it's the only function that uses native_tls.
-pub fn connect<'t, Req: Into<Request<'t>>>(request: Req)
-    -> Result<(WebSocket<AutoStream>, Response)>
-{
+pub fn connect<'t, Req: Into<Request<'t>>>(
+    request: Req,
+) -> Result<(WebSocket<AutoStream>, Response)> {
     connect_with_config(request, None)
 }
 
 fn connect_to_some(addrs: &[SocketAddr], url: &Url, mode: Mode) -> Result<AutoStream> {
-    let domain = url.host_str().ok_or_else(|| Error::Url("No host name in the URL".into()))?;
+    let domain = url
+        .host_str()
+        .ok_or_else(|| Error::Url("No host name in the URL".into()))?;
     for addr in addrs {
         debug!("Trying to contact {} at {}...", url, addr);
         if let Ok(raw_stream) = TcpStream::connect(addr) {
             if let Ok(stream) = wrap_stream(raw_stream, domain, mode) {
-                return Ok(stream)
+                return Ok(stream);
             }
         }
     }
@@ -155,7 +163,7 @@ pub fn url_mode(url: &Url) -> Result<Mode> {
     match url.scheme() {
         "ws" => Ok(Mode::Plain),
         "wss" => Ok(Mode::Tls),
-        _ => Err(Error::Url("URL scheme not supported".into()))
+        _ => Err(Error::Url("URL scheme not supported".into())),
     }
 }
 
@@ -182,8 +190,10 @@ where
 /// Use this function if you need a nonblocking handshake support or if you
 /// want to use a custom stream like `mio::tcp::TcpStream` or `openssl::ssl::SslStream`.
 /// Any stream supporting `Read + Write` will do.
-pub fn client<'t, Stream, Req>(request: Req, stream: Stream)
-    -> StdResult<(WebSocket<Stream>, Response), HandshakeError<ClientHandshake<Stream>>>
+pub fn client<'t, Stream, Req>(
+    request: Req,
+    stream: Stream,
+) -> StdResult<(WebSocket<Stream>, Response), HandshakeError<ClientHandshake<Stream>>>
 where
     Stream: Read + Write,
     Req: Into<Request<'t>>,