apply clippy suggestions

PeterW-LWL · PeterW-LWL · commit 8d70eff2d5e9 · 2019-12-17T15:50:26.000+01:00
diff --git a/examples/bench.rs b/examples/bench.rs
@@ -16,7 +16,7 @@ use ws::{Builder, CloseCode, Handler, Handshake, Message, Result, Sender, Settin
 
 const CONNECTIONS: usize = 10_000; // simultaneous
 const MESSAGES: u32 = 10;
-static MESSAGE: &'static str = "TEST TEST TEST TEST TEST TEST TEST TEST";
+static MESSAGE: &str = "TEST TEST TEST TEST TEST TEST TEST TEST";
 
 fn main() {
     env_logger::init();
diff --git a/examples/html_chat.rs b/examples/html_chat.rs
@@ -3,7 +3,7 @@ extern crate ws;
 use ws::{listen, Handler, Message, Request, Response, Result, Sender};
 
 // This can be read from a file
-static INDEX_HTML: &'static [u8] = br#"
+static INDEX_HTML: &[u8] = br#"
 <!DOCTYPE html>
 <html>
 	<head>
diff --git a/examples/ssl-server.rs b/examples/ssl-server.rs
@@ -100,7 +100,7 @@ fn main() {
             ..ws::Settings::default()
         })
         .build(|out: ws::Sender| Server {
-            out: out,
+            out,
             ssl: acceptor.clone(),
         })
         .unwrap()
diff --git a/examples/unsafe-ssl-client.rs b/examples/unsafe-ssl-client.rs
@@ -51,7 +51,7 @@ fn main() {
     env_logger::init();
 
     if let Err(error) = ws::connect("wss://localhost:3443/api/websocket", |out| {
-        if let Err(_) = out.send("Hello WebSocket") {
+        if out.send("Hello WebSocket").is_err() {
             println!("Websocket couldn't queue an initial message.")
         } else {
             println!("Client sent message 'Hello WebSocket'. ")
diff --git a/src/connection.rs b/src/connection.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::cognitive_complexity, clippy::collapsible_if)]
+
 use std::borrow::Borrow;
 use std::collections::VecDeque;
 use std::io::{Cursor, Read, Seek, SeekFrom, Write};
@@ -553,7 +555,7 @@ where
 
             if response.status() != 101 {
                 self.events = Ready::empty();
-                return Ok(());
+                Ok(())
             } else {
                 self.handler.on_open(Handshake {
                     request,
@@ -564,7 +566,7 @@ where
                 debug!("Connection to {} is now open.", self.peer_addr());
                 self.events.insert(Ready::readable());
                 self.check_events();
-                return Ok(());
+                Ok(())
             }
         } else {
             Err(Error::new(
diff --git a/src/deflate/context.rs b/src/deflate/context.rs
@@ -1,3 +1,5 @@
+#![allow(invalid_value, clippy::ptr_offset_with_cast, clippy::cast_lossless)]
+
 use std::mem;
 use std::slice;
 
@@ -6,7 +8,7 @@ use super::libc::{c_char, c_int, c_uint};
 
 use result::{Error, Kind, Result};
 
-const ZLIB_VERSION: &'static str = "1.2.8\0";
+const ZLIB_VERSION: &str = "1.2.8\0";
 
 trait Context {
     fn stream(&mut self) -> &mut ffi::z_stream;
@@ -15,7 +17,7 @@ trait Context {
     where
         F: Fn(&mut ffi::z_stream) -> Option<Result<()>>,
     {
-        debug_assert!(output.len() == 0, "Output vector is not empty.");
+        debug_assert!(output.is_empty(), "Output vector is not empty.");
 
         let stream = self.stream();
 
@@ -79,7 +81,7 @@ impl Compressor {
                 mem::size_of::<ffi::z_stream>() as c_int,
             );
             assert!(result == ffi::Z_OK, "Failed to initialize compresser.");
-            Compressor { stream: stream }
+            Compressor { stream }
         }
     }
 
@@ -147,7 +149,7 @@ impl Decompressor {
                 mem::size_of::<ffi::z_stream>() as c_int,
             );
             assert!(result == ffi::Z_OK, "Failed to initialize decompresser.");
-            Decompressor { stream: stream }
+            Decompressor { stream }
         }
     }
 
@@ -196,15 +198,16 @@ impl Drop for Decompressor {
     }
 }
 
+#[cfg(test)]
 mod test {
-    #![allow(unused_imports, unused_variables, dead_code)]
     use super::*;
 
+    #[allow(dead_code)]
     fn as_hex(s: &[u8]) {
         for byte in s {
             print!("0x{:x} ", byte);
         }
-        print!("\n");
+        println!();
     }
 
     #[test]
diff --git a/src/deflate/extension.rs b/src/deflate/extension.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::collapsible_if)]
+
 use std::mem::replace;
 
 #[cfg(feature = "nativetls")]
@@ -59,17 +61,15 @@ impl Default for DeflateSettings {
 
 /// Utility for applying the permessage-deflate extension to a handler with particular deflate
 /// settings.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct DeflateBuilder {
     settings: DeflateSettings,
 }
 
 impl DeflateBuilder {
     /// Create a new DeflateBuilder with the default settings.
     pub fn new() -> DeflateBuilder {
-        DeflateBuilder {
-            settings: DeflateSettings::default(),
-        }
+        Default::default()
     }
 
     /// Configure the DeflateBuilder with the given deflate settings.
@@ -122,7 +122,7 @@ impl<H: Handler> DeflateHandler<H> {
             compress_reset: false,
             decompress_reset: false,
             pass: false,
-            settings: settings,
+            settings,
             inner: handler,
         }
     }
@@ -300,7 +300,7 @@ impl<H: Handler> Handler for DeflateHandler<H> {
                         if name {
                             return Err(Error::new(
                                 Kind::Protocol,
-                                format!("Duplicate extension name permessage-deflate"),
+                                "Duplicate extension name permessage-deflate".to_owned(),
                             ));
                         } else {
                             name = true;
@@ -310,7 +310,8 @@ impl<H: Handler> Handler for DeflateHandler<H> {
                         if s_takeover {
                             return Err(Error::new(
                                 Kind::Protocol,
-                                format!("Duplicate extension parameter server_no_context_takeover"),
+                                "Duplicate extension parameter server_no_context_takeover"
+                                    .to_owned(),
                             ));
                         } else {
                             s_takeover = true;
@@ -321,7 +322,8 @@ impl<H: Handler> Handler for DeflateHandler<H> {
                         if c_takeover {
                             return Err(Error::new(
                                 Kind::Protocol,
-                                format!("Duplicate extension parameter client_no_context_takeover"),
+                                "Duplicate extension parameter client_no_context_takeover"
+                                    .to_owned(),
                             ));
                         } else {
                             c_takeover = true;
@@ -330,7 +332,7 @@ impl<H: Handler> Handler for DeflateHandler<H> {
                             } else {
                                 return Err(Error::new(
                                     Kind::Protocol,
-                                    format!("The client requires context takeover."),
+                                    "The client requires context takeover.".to_owned(),
                                 ));
                             }
                         }
@@ -339,7 +341,7 @@ impl<H: Handler> Handler for DeflateHandler<H> {
                         if s_max {
                             return Err(Error::new(
                                 Kind::Protocol,
-                                format!("Duplicate extension parameter server_max_window_bits"),
+                                "Duplicate extension parameter server_max_window_bits".to_owned(),
                             ));
                         } else {
                             s_max = true;
@@ -376,7 +378,7 @@ impl<H: Handler> Handler for DeflateHandler<H> {
                         if c_max {
                             return Err(Error::new(
                                 Kind::Protocol,
-                                format!("Duplicate extension parameter client_max_window_bits"),
+                                "Duplicate extension parameter client_max_window_bits".to_owned(),
                             ));
                         } else {
                             c_max = true;
diff --git a/src/frame.rs b/src/frame.rs
@@ -9,7 +9,7 @@ use protocol::{CloseCode, OpCode};
 use result::{Error, Kind, Result};
 use stream::TryReadBuf;
 
-fn apply_mask(buf: &mut [u8], mask: &[u8; 4]) {
+fn apply_mask(buf: &mut [u8], mask: [u8; 4]) {
     let iter = buf.iter_mut().zip(mask.iter().cycle());
     for (byte, &key) in iter {
         *byte ^= key
@@ -176,9 +176,9 @@ impl Frame {
     #[doc(hidden)]
     #[inline]
     pub fn remove_mask(&mut self) -> &mut Frame {
-        self.mask
-            .take()
-            .map(|mask| apply_mask(&mut self.payload, &mask));
+        if let Some(mask) = self.mask.take() {
+            apply_mask(&mut self.payload, mask);
+        }
         self
     }
 
@@ -429,7 +429,7 @@ impl Frame {
 
         if self.is_masked() {
             let mask = self.mask.take().unwrap();
-            apply_mask(&mut self.payload, &mask);
+            apply_mask(&mut self.payload, mask);
             w.write_all(&mask)?;
         }
 
diff --git a/src/handler.rs b/src/handler.rs
@@ -291,10 +291,12 @@ pub trait Handler {
         stream: TcpStream,
         url: &url::Url,
     ) -> Result<SslStream<TcpStream>> {
-        let domain = url.domain().ok_or(Error::new(
-            Kind::Protocol,
-            format!("Unable to parse domain from {}. Needed for SSL.", url),
-        ))?;
+        let domain = url.domain().ok_or_else(|| {
+            Error::new(
+                Kind::Protocol,
+                format!("Unable to parse domain from {}. Needed for SSL.", url),
+            )
+        })?;
         let connector = SslConnector::builder(SslMethod::tls())
             .map_err(|e| {
                 Error::new(
@@ -313,10 +315,12 @@ pub trait Handler {
         stream: TcpStream,
         url: &url::Url,
     ) -> Result<SslStream<TcpStream>> {
-        let domain = url.domain().ok_or(Error::new(
-            Kind::Protocol,
-            format!("Unable to parse domain from {}. Needed for SSL.", url),
-        ))?;
+        let domain = url.domain().ok_or_else(|| {
+            Error::new(
+                Kind::Protocol,
+                format!("Unable to parse domain from {}. Needed for SSL.", url),
+            )
+        })?;
 
         let connector = TlsConnector::new().map_err(|e| {
             Error::new(
@@ -383,10 +387,8 @@ mod test {
             }
 
             fn on_message(&mut self, msg: message::Message) -> Result<()> {
-                Ok(assert_eq!(
-                    msg,
-                    message::Message::Text(String::from("testme"))
-                ))
+                assert_eq!(msg, message::Message::Text(String::from("testme")));
+                Ok(())
             }
 
             fn on_close(&mut self, code: CloseCode, _: &str) {
diff --git a/src/handshake.rs b/src/handshake.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::write_with_newline)]
+
 use std::fmt;
 use std::io::Write;
 use std::net::SocketAddr;
@@ -10,8 +12,8 @@ use url;
 
 use result::{Error, Kind, Result};
 
-static WS_GUID: &'static str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-static BASE64: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static WS_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+static BASE64: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 const MAX_HEADERS: usize = 124;
 
 fn generate_key() -> String {
@@ -381,7 +383,7 @@ impl Request {
         let req = Request {
             path: format!("{}{}", url.path(), query),
             method: "GET".to_owned(),
-            headers: headers,
+            headers,
         };
 
         debug!("Built request from URL:\n{}", req);
diff --git a/src/io.rs b/src/io.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::cognitive_complexity)]
+
 use std::borrow::Borrow;
 use std::io::{Error as IoError, ErrorKind};
 use std::net::{SocketAddr, ToSocketAddrs};
@@ -209,6 +211,7 @@ where
 
         if will_encrypt {
             while let Err(ssl_error) = self.connections[tok.into()].encrypt() {
+                #[allow(clippy::single_match)]
                 match ssl_error.kind {
                     #[cfg(feature = "ssl")]
                     Kind::Ssl(ref inner_ssl_error) => {
@@ -969,24 +972,23 @@ mod test {
         let no_resolve = Url::from_str("ws://bad.elucitrans.com").unwrap();
 
         assert!(url_to_addrs(&ws_url).is_ok());
-        assert!(url_to_addrs(&ws_url).unwrap().len() > 0);
+        assert!(!url_to_addrs(&ws_url).unwrap().is_empty());
         assert!(url_to_addrs(&wss_url).is_ok());
-        assert!(url_to_addrs(&wss_url).unwrap().len() > 0);
+        assert!(!url_to_addrs(&wss_url).unwrap().is_empty());
 
         match url_to_addrs(&bad_url) {
             Ok(_) => panic!("url_to_addrs accepts http urls."),
             Err(Error {
                 kind: Kind::Internal,
-                details: _,
+                ..
             }) => (), // pass
             err => panic!("{:?}", err),
         }
 
         match url_to_addrs(&no_resolve) {
             Ok(_) => panic!("url_to_addrs creates addresses for non-existent domains."),
             Err(Error {
-                kind: Kind::Io(_),
-                details: _,
+                kind: Kind::Io(_), ..
             }) => (), // pass
             err => panic!("{:?}", err),
         }
diff --git a/src/message.rs b/src/message.rs
@@ -141,7 +141,7 @@ mod test {
 
     #[test]
     fn display() {
-        let t = Message::text(format!("test"));
+        let t = Message::text("test".to_owned());
         assert_eq!(t.to_string(), "test".to_owned());
 
         let bin = Message::binary(vec![0, 1, 3, 4, 241]);
diff --git a/src/protocol.rs b/src/protocol.rs
@@ -23,8 +23,8 @@ pub enum OpCode {
 
 impl OpCode {
     /// Test whether the opcode indicates a control frame.
-    pub fn is_control(&self) -> bool {
-        match *self {
+    pub fn is_control(self) -> bool {
+        match self {
             Text | Binary | Continue => false,
             _ => true,
         }
diff --git a/src/result.rs b/src/result.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::large_enum_variant)]
+
 use std::borrow::Cow;
 use std::convert::{From, Into};
 use std::error::Error as StdError;
diff --git a/src/stream.rs b/src/stream.rs
diff --git a/tests/deflate.rs b/tests/deflate.rs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+#![allow(invalid_value, clippy::ptr_offset_with_cast, clippy::cast_lossless)]`
	`2`	`+`
`1`	`3`	`use std::mem;`
`2`	`4`	`use std::slice;`
`3`	`5`
`@@ -6,7 +8,7 @@ use super::libc::{c_char, c_int, c_uint};`
`6`	`8`
`7`	`9`	`use result::{Error, Kind, Result};`
`8`	`10`
`9`		`-const ZLIB_VERSION: &'static str = "1.2.8\0";`
	`11`	`+const ZLIB_VERSION: &str = "1.2.8\0";`
`10`	`12`
`11`	`13`	`trait Context {`
`12`	`14`	`fn stream(&mut self) -> &mut ffi::z_stream;`
`@@ -15,7 +17,7 @@ trait Context {`
`15`	`17`	`where`
`16`	`18`	`F: Fn(&mut ffi::z_stream) -> Option<Result<()>>,`
`17`	`19`	`{`
`18`		`- debug_assert!(output.len() == 0, "Output vector is not empty.");`
	`20`	`+ debug_assert!(output.is_empty(), "Output vector is not empty.");`
`19`	`21`
`20`	`22`	`let stream = self.stream();`
`21`	`23`
`@@ -79,7 +81,7 @@ impl Compressor {`
`79`	`81`	`mem::size_of::<ffi::z_stream>() as c_int,`
`80`	`82`	`);`
`81`	`83`	`assert!(result == ffi::Z_OK, "Failed to initialize compresser.");`
`82`		`- Compressor { stream: stream }`
	`84`	`+ Compressor { stream }`
`83`	`85`	`}`
`84`	`86`	`}`
`85`	`87`
`@@ -147,7 +149,7 @@ impl Decompressor {`
`147`	`149`	`mem::size_of::<ffi::z_stream>() as c_int,`
`148`	`150`	`);`
`149`	`151`	`assert!(result == ffi::Z_OK, "Failed to initialize decompresser.");`
`150`		`- Decompressor { stream: stream }`
	`152`	`+ Decompressor { stream }`
`151`	`153`	`}`
`152`	`154`	`}`
`153`	`155`
`@@ -196,15 +198,16 @@ impl Drop for Decompressor {`
`196`	`198`	`}`
`197`	`199`	`}`
`198`	`200`
	`201`	`+#[cfg(test)]`
`199`	`202`	`mod test {`
`200`		`- #![allow(unused_imports, unused_variables, dead_code)]`
`201`	`203`	`use super::*;`
`202`	`204`
	`205`	`+ #[allow(dead_code)]`
`203`	`206`	`fn as_hex(s: &[u8]) {`
`204`	`207`	`for byte in s {`
`205`	`208`	`print!("0x{:x} ", byte);`
`206`	`209`	`}`
`207`		`- print!("\n");`
	`210`	`+ println!();`
`208`	`211`	`}`
`209`	`212`
`210`	`213`	`#[test]`