Fix up some issues indicated by clippy (#116)

Daniel Lockyer · Michael Eden · commit a27bca804bd6 · 2017-04-18T12:14:20.000-04:00
* Remove lifetimes

* Remove return keyword

* Switch match to if/if-let

* Remove unneeded borrowing

* Switch iterator call to direct reference

* Let WebSocketKey derive Default

* Remove simple closure

* Use helper function

* Switch Vec-ref to remove extra reference
diff --git a/examples/client.rs b/examples/client.rs
@@ -37,13 +37,10 @@ fn main() {
 					return;
 				}
 			};
-			match message.opcode {
-				Type::Close => {
-					let _ = sender.send_message(&message);
-					// If it's a close message, just send it and then return.
-					return;
-				}
-				_ => (),
+			if Type::Close == message.opcode {
+				let _ = sender.send_message(&message);
+				// If it's a close message, just send it and then return.
+				return;
 			}
 			// Send the message
 			match sender.send_message(&message) {
diff --git a/src/client/mod.rs b/src/client/mod.rs
@@ -157,7 +157,7 @@ impl<S> Client<S>
 	}
 
 	/// Returns an iterator over incoming data frames.
-	pub fn incoming_dataframes<'a>(&'a mut self) -> DataFrameIterator<'a, Receiver, BufReader<S>> {
+	pub fn incoming_dataframes(&mut self) -> DataFrameIterator<Receiver, BufReader<S>> {
 		self.receiver.incoming_dataframes(&mut self.stream)
 	}
 
diff --git a/src/dataframe.rs b/src/dataframe.rs
@@ -85,12 +85,12 @@ impl DataFrameable for DataFrame {
 	}
 
 	#[inline(always)]
-	fn reserved<'a>(&'a self) -> &'a [bool; 3] {
+	fn reserved(&self) -> &[bool; 3] {
 		&self.reserved
 	}
 
 	#[inline(always)]
-	fn payload<'a>(&'a self) -> Cow<'a, [u8]> {
+	fn payload(&self) -> Cow<[u8]> {
 		Cow::Borrowed(&self.data)
 	}
 }
diff --git a/src/header/accept.rs b/src/header/accept.rs
@@ -31,14 +31,12 @@ impl FromStr for WebSocketAccept {
 				}
 				let mut array = [0u8; 20];
 				let mut iter = vec.into_iter();
-				for i in array.iter_mut() {
+				for i in &mut array {
 					*i = iter.next().unwrap();
 				}
 				Ok(WebSocketAccept(array))
 			}
-			Err(_) => {
-				return Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept "));
-			}
+			Err(_) => Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept ")),
 		}
 	}
 }
diff --git a/src/header/extensions.rs b/src/header/extensions.rs
@@ -19,7 +19,7 @@ pub struct WebSocketExtensions(pub Vec<Extension>);
 impl Deref for WebSocketExtensions {
 	type Target = Vec<Extension>;
 
-	fn deref<'a>(&'a self) -> &'a Vec<Extension> {
+	fn deref(&self) -> &Vec<Extension> {
 		&self.0
 	}
 }
@@ -69,7 +69,7 @@ impl FromStr for Extension {
 impl fmt::Display for Extension {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		try!(write!(f, "{}", self.name));
-		for param in self.params.iter() {
+		for param in &self.params {
 			try!(write!(f, "; {}", param));
 		}
 		Ok(())
@@ -98,9 +98,8 @@ impl Parameter {
 impl fmt::Display for Parameter {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		try!(write!(f, "{}", self.name));
-		match self.value {
-			Some(ref x) => try!(write!(f, "={}", x)),
-			None => (),
+		if let Some(ref x) = self.value {
+			try!(write!(f, "={}", x));
 		}
 		Ok(())
 	}
@@ -112,7 +111,7 @@ impl Header for WebSocketExtensions {
 	}
 
 	fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<WebSocketExtensions> {
-		from_comma_delimited(raw).map(|vec| WebSocketExtensions(vec))
+		from_comma_delimited(raw).map(WebSocketExtensions)
 	}
 }
 
diff --git a/src/header/key.rs b/src/header/key.rs
@@ -9,7 +9,7 @@ use serialize::base64::{ToBase64, FromBase64, STANDARD};
 use result::{WebSocketResult, WebSocketError};
 
 /// Represents a Sec-WebSocket-Key header.
-#[derive(PartialEq, Clone, Copy)]
+#[derive(PartialEq, Clone, Copy, Default)]
 pub struct WebSocketKey(pub [u8; 16]);
 
 impl Debug for WebSocketKey {
@@ -29,15 +29,13 @@ impl FromStr for WebSocketKey {
 				}
 				let mut array = [0u8; 16];
 				let mut iter = vec.into_iter();
-				for i in array.iter_mut() {
+				for i in &mut array {
 					*i = iter.next().unwrap();
 				}
 
 				Ok(WebSocketKey(array))
 			}
-			Err(_) => {
-				return Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept"));
-			}
+			Err(_) => Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept")),
 		}
 	}
 }
diff --git a/src/header/origin.rs b/src/header/origin.rs
@@ -10,7 +10,7 @@ pub struct Origin(pub String);
 
 impl Deref for Origin {
 	type Target = String;
-	fn deref<'a>(&'a self) -> &'a String {
+	fn deref(&self) -> &String {
 		&self.0
 	}
 }
@@ -21,7 +21,7 @@ impl Header for Origin {
 	}
 
 	fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<Origin> {
-		from_one_raw_str(raw).map(|s| Origin(s))
+		from_one_raw_str(raw).map(Origin)
 	}
 }
 
diff --git a/src/header/protocol.rs b/src/header/protocol.rs
@@ -12,7 +12,7 @@ pub struct WebSocketProtocol(pub Vec<String>);
 
 impl Deref for WebSocketProtocol {
 	type Target = Vec<String>;
-	fn deref<'a>(&'a self) -> &'a Vec<String> {
+	fn deref(&self) -> &Vec<String> {
 		&self.0
 	}
 }
@@ -23,7 +23,7 @@ impl Header for WebSocketProtocol {
 	}
 
 	fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<WebSocketProtocol> {
-		from_comma_delimited(raw).map(|vec| WebSocketProtocol(vec))
+		from_comma_delimited(raw).map(WebSocketProtocol)
 	}
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -65,17 +65,13 @@ macro_rules! upsert_header {
         Some($pat:pat) => $some_match:expr,
         None => $default:expr
     }) => {{
-        match $headers.has::<$header>() {
-            true => {
-                match $headers.get_mut::<$header>() {
-                    Some($pat) => { $some_match; },
-                    None => (),
-                };
+        if $headers.has::<$header>() {
+            if let Some($pat) = $headers.get_mut::<$header>() {
+                $some_match
             }
-            false => {
-                $headers.set($default);
-            },
-        };
+        } else {
+            $headers.set($default);
+        }
     }}
 }
 
diff --git a/src/message.rs b/src/message.rs
@@ -132,11 +132,11 @@ impl<'a> ws::dataframe::DataFrame for Message<'a> {
 	}
 
 	#[inline(always)]
-	fn reserved<'b>(&'b self) -> &'b [bool; 3] {
+	fn reserved(&self) -> &[bool; 3] {
 		FALSE_RESERVED_BITS
 	}
 
-	fn payload<'b>(&'b self) -> Cow<'b, [u8]> {
+	fn payload(&self) -> Cow<[u8]> {
 		let mut buf = Vec::with_capacity(self.size());
 		self.write_payload(&mut buf).ok();
 		Cow::Owned(buf)
@@ -188,7 +188,7 @@ impl<'a, 'b> ws::Message<'b, &'b Message<'a>> for Message<'a> {
 		       Some(Opcode::Text) => Message::text(try!(bytes_to_string(&data[..]))),
 		       Some(Opcode::Binary) => Message::binary(data),
 		       Some(Opcode::Close) => {
-			       if data.len() > 0 {
+			       if !data.is_empty() {
 			           let status_code = try!((&data[..]).read_u16::<BigEndian>());
 			           let reason = try!(bytes_to_string(&data[2..]));
 			           Message::close_because(status_code, reason)
diff --git a/src/receiver.rs b/src/receiver.rs
@@ -34,7 +34,7 @@ impl<R> Reader<R>
 	}
 
 	/// Returns an iterator over incoming data frames.
-	pub fn incoming_dataframes<'a>(&'a mut self) -> DataFrameIterator<'a, Receiver, BufReader<R>> {
+	pub fn incoming_dataframes(&mut self) -> DataFrameIterator<Receiver, BufReader<R>> {
 		self.receiver.incoming_dataframes(&mut self.stream)
 	}
 
diff --git a/src/server/upgrade/mod.rs b/src/server/upgrade/mod.rs
@@ -346,17 +346,17 @@ impl Display for HyperIntoWsError {
 impl Error for HyperIntoWsError {
 	fn description(&self) -> &str {
 		use self::HyperIntoWsError::*;
-		match self {
-			&MethodNotGet => "Request method must be GET",
-			&UnsupportedHttpVersion => "Unsupported request HTTP version",
-			&UnsupportedWebsocketVersion => "Unsupported WebSocket version",
-			&NoSecWsKeyHeader => "Missing Sec-WebSocket-Key header",
-			&NoWsUpgradeHeader => "Invalid Upgrade WebSocket header",
-			&NoUpgradeHeader => "Missing Upgrade WebSocket header",
-			&NoWsConnectionHeader => "Invalid Connection WebSocket header",
-			&NoConnectionHeader => "Missing Connection WebSocket header",
-			&Io(ref e) => e.description(),
-			&Parsing(ref e) => e.description(),
+		match *self {
+			MethodNotGet => "Request method must be GET",
+			UnsupportedHttpVersion => "Unsupported request HTTP version",
+			UnsupportedWebsocketVersion => "Unsupported WebSocket version",
+			NoSecWsKeyHeader => "Missing Sec-WebSocket-Key header",
+			NoWsUpgradeHeader => "Invalid Upgrade WebSocket header",
+			NoUpgradeHeader => "Missing Upgrade WebSocket header",
+			NoWsConnectionHeader => "Invalid Connection WebSocket header",
+			NoConnectionHeader => "Missing Connection WebSocket header",
+			Io(ref e) => e.description(),
+			Parsing(ref e) => e.description(),
 		}
 	}
 
@@ -413,9 +413,9 @@ fn validate(
 		None => return Err(HyperIntoWsError::NoUpgradeHeader),
 	};
 
-	fn check_connection_header(headers: &Vec<ConnectionOption>) -> bool {
+	fn check_connection_header(headers: &[ConnectionOption]) -> bool {
 		for header in headers {
-			if let &ConnectionOption::ConnectionHeader(ref h) = header {
+			if let ConnectionOption::ConnectionHeader(ref h) = *header {
 				if UniCase(h as &str) == UniCase("upgrade") {
 					return true;
 				}
diff --git a/src/stream.rs b/src/stream.rs
@@ -67,7 +67,7 @@ pub trait AsTcpStream {
 
 impl AsTcpStream for TcpStream {
 	fn as_tcp(&self) -> &TcpStream {
-		&self
+		self
 	}
 }
 
diff --git a/src/ws/dataframe.rs b/src/ws/dataframe.rs
@@ -18,11 +18,11 @@ pub trait DataFrame {
 	/// What type of data does this dataframe contain?
 	fn opcode(&self) -> u8;
 	/// Reserved bits of this dataframe
-	fn reserved<'a>(&'a self) -> &'a [bool; 3];
+	fn reserved(&self) -> &[bool; 3];
 	/// Entire payload of the dataframe. If not known then implement
 	/// write_payload as that is the actual method used when sending the
 	/// dataframe over the wire.
-	fn payload<'a>(&'a self) -> Cow<'a, [u8]>;
+	fn payload(&self) -> Cow<[u8]>;
 
 	/// How long (in bytes) is this dataframe's payload
 	fn size(&self) -> usize {
@@ -95,12 +95,12 @@ impl<'a, D> DataFrame for &'a D
 	}
 
 	#[inline(always)]
-	fn reserved<'b>(&'b self) -> &'b [bool; 3] {
+	fn reserved(&self) -> &[bool; 3] {
 		D::reserved(self)
 	}
 
 	#[inline(always)]
-	fn payload<'b>(&'b self) -> Cow<'b, [u8]> {
+	fn payload(&self) -> Cow<[u8]> {
 		D::payload(self)
 	}
 
diff --git a/src/ws/util/header.rs b/src/ws/util/header.rs
@@ -61,9 +61,8 @@ pub fn write_header<W>(writer: &mut W, header: DataFrameHeader) -> WebSocketResu
 	}
 
 	// Write 'Masking-key'
-	match header.mask {
-		Some(mask) => try!(writer.write_all(&mask)),
-		None => (),
+	if let Some(mask) = header.mask {
+		try!(writer.write_all(&mask))
 	}
 
 	Ok(())

Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ impl<S> Client<S>`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`/// Returns an iterator over incoming data frames.`
`160`		`- pub fn incoming_dataframes<'a>(&'a mut self) -> DataFrameIterator<'a, Receiver, BufReader<S>> {`
	`160`	`+ pub fn incoming_dataframes(&mut self) -> DataFrameIterator<Receiver, BufReader<S>> {`
`161`	`161`	`self.receiver.incoming_dataframes(&mut self.stream)`
`162`	`162`	`}`
`163`	`163`
Original file line number	Diff line number	Diff line change
`@@ -85,12 +85,12 @@ impl DataFrameable for DataFrame {`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`#[inline(always)]`
`88`		`- fn reserved<'a>(&'a self) -> &'a [bool; 3] {`
	`88`	`+ fn reserved(&self) -> &[bool; 3] {`
`89`	`89`	`&self.reserved`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`#[inline(always)]`
`93`		`- fn payload<'a>(&'a self) -> Cow<'a, [u8]> {`
	`93`	`+ fn payload(&self) -> Cow<[u8]> {`
`94`	`94`	`Cow::Borrowed(&self.data)`
`95`	`95`	`}`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,14 +31,12 @@ impl FromStr for WebSocketAccept {`
`31`	`31`	`}`
`32`	`32`	`let mut array = [0u8; 20];`
`33`	`33`	`let mut iter = vec.into_iter();`
`34`		`- for i in array.iter_mut() {`
	`34`	`+ for i in &mut array {`
`35`	`35`	`*i = iter.next().unwrap();`
`36`	`36`	`}`
`37`	`37`	`Ok(WebSocketAccept(array))`
`38`	`38`	`}`
`39`		`- Err(_) => {`
`40`		`- return Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept "));`
`41`		`- }`
	`39`	`+ Err(_) => Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept ")),`
`42`	`40`	`}`
`43`	`41`	`}`
`44`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ pub struct WebSocketExtensions(pub Vec<Extension>);`
`19`	`19`	`impl Deref for WebSocketExtensions {`
`20`	`20`	`type Target = Vec<Extension>;`
`21`	`21`
`22`		`- fn deref<'a>(&'a self) -> &'a Vec<Extension> {`
	`22`	`+ fn deref(&self) -> &Vec<Extension> {`
`23`	`23`	`&self.0`
`24`	`24`	`}`
`25`	`25`	`}`
`@@ -69,7 +69,7 @@ impl FromStr for Extension {`
`69`	`69`	`impl fmt::Display for Extension {`
`70`	`70`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`71`	`71`	`try!(write!(f, "{}", self.name));`
`72`		`- for param in self.params.iter() {`
	`72`	`+ for param in &self.params {`
`73`	`73`	`try!(write!(f, "; {}", param));`
`74`	`74`	`}`
`75`	`75`	`Ok(())`
`@@ -98,9 +98,8 @@ impl Parameter {`
`98`	`98`	`impl fmt::Display for Parameter {`
`99`	`99`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`100`	`100`	`try!(write!(f, "{}", self.name));`
`101`		`- match self.value {`
`102`		`- Some(ref x) => try!(write!(f, "={}", x)),`
`103`		`- None => (),`
	`101`	`+ if let Some(ref x) = self.value {`
	`102`	`+ try!(write!(f, "={}", x));`
`104`	`103`	`}`
`105`	`104`	`Ok(())`
`106`	`105`	`}`
`@@ -112,7 +111,7 @@ impl Header for WebSocketExtensions {`
`112`	`111`	`}`
`113`	`112`
`114`	`113`	`fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<WebSocketExtensions> {`
`115`		`- from_comma_delimited(raw).map(\|vec\| WebSocketExtensions(vec))`
	`114`	`+ from_comma_delimited(raw).map(WebSocketExtensions)`
`116`	`115`	`}`
`117`	`116`	`}`
`118`	`117`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ use serialize::base64::{ToBase64, FromBase64, STANDARD};`
`9`	`9`	`use result::{WebSocketResult, WebSocketError};`
`10`	`10`
`11`	`11`	`/// Represents a Sec-WebSocket-Key header.`
`12`		`-#[derive(PartialEq, Clone, Copy)]`
	`12`	`+#[derive(PartialEq, Clone, Copy, Default)]`
`13`	`13`	`pub struct WebSocketKey(pub [u8; 16]);`
`14`	`14`
`15`	`15`	`impl Debug for WebSocketKey {`
`@@ -29,15 +29,13 @@ impl FromStr for WebSocketKey {`
`29`	`29`	`}`
`30`	`30`	`let mut array = [0u8; 16];`
`31`	`31`	`let mut iter = vec.into_iter();`
`32`		`- for i in array.iter_mut() {`
	`32`	`+ for i in &mut array {`
`33`	`33`	`*i = iter.next().unwrap();`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`Ok(WebSocketKey(array))`
`37`	`37`	`}`
`38`		`- Err(_) => {`
`39`		`- return Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept"));`
`40`		`- }`
	`38`	`+ Err(_) => Err(WebSocketError::ProtocolError("Invalid Sec-WebSocket-Accept")),`
`41`	`39`	`}`
`42`	`40`	`}`
`43`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ pub struct Origin(pub String);`
`10`	`10`
`11`	`11`	`impl Deref for Origin {`
`12`	`12`	`type Target = String;`
`13`		`- fn deref<'a>(&'a self) -> &'a String {`
	`13`	`+ fn deref(&self) -> &String {`
`14`	`14`	`&self.0`
`15`	`15`	`}`
`16`	`16`	`}`
`@@ -21,7 +21,7 @@ impl Header for Origin {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<Origin> {`
`24`		`- from_one_raw_str(raw).map(\|s\| Origin(s))`
	`24`	`+ from_one_raw_str(raw).map(Origin)`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ pub struct WebSocketProtocol(pub Vec<String>);`
`12`	`12`
`13`	`13`	`impl Deref for WebSocketProtocol {`
`14`	`14`	`type Target = Vec<String>;`
`15`		`- fn deref<'a>(&'a self) -> &'a Vec<String> {`
	`15`	`+ fn deref(&self) -> &Vec<String> {`
`16`	`16`	`&self.0`
`17`	`17`	`}`
`18`	`18`	`}`
`@@ -23,7 +23,7 @@ impl Header for WebSocketProtocol {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<WebSocketProtocol> {`
`26`		`- from_comma_delimited(raw).map(\|vec\| WebSocketProtocol(vec))`
	`26`	`+ from_comma_delimited(raw).map(WebSocketProtocol)`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`