tests pass without warnings

Author: illegalprime

examples/hyper.rs

@@ -3,11 +3,9 @@ extern crate hyper;
 
 use std::thread;
 use std::io::Write;
-use websocket::{Server, Message, Sender, Receiver};
-use websocket::header::WebSocketProtocol;
+use websocket::{Server, Message};
 use websocket::message::Type;
 use hyper::Server as HttpServer;
-use hyper::server::Handler;
 use hyper::net::Fresh;
 use hyper::server::request::Request;
 use hyper::server::response::Response;

examples/server.rs

@@ -3,7 +3,6 @@ extern crate websocket;
 use std::thread;
 use websocket::{Server, Message};
 use websocket::message::Type;
-use websocket::header::WebSocketProtocol;
 
 // TODO: I think the .reject() call is only for malformed packets
 // there should be an easy way to accept the socket with the given protocols

src/client/mod.rs

@@ -1,9 +1,6 @@
 //! Contains the WebSocket client.
 extern crate url;
 
-use std::borrow::{
-    Cow,
-};
 use std::net::TcpStream;
 use std::net::SocketAddr;
 use std::io::Result as IoResult;

src/header/accept.rs

@@ -88,7 +88,8 @@ mod tests {
 	  use test;
 	  use std::str::FromStr;
 	  use header::{Headers, WebSocketKey};
-	  use hyper::header::{Header, HeaderFormatter};
+	  use hyper::header::Header;
+
 	  #[test]
 	  fn test_header_accept() {
 		    let key = FromStr::from_str("dGhlIHNhbXBsZSBub25jZQ==").unwrap();
@@ -118,9 +119,8 @@ mod tests {
 	  fn bench_header_accept_format(b: &mut test::Bencher) {
 		    let value = vec![b"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=".to_vec()];
 		    let val: WebSocketAccept = Header::parse_header(&value[..]).unwrap();
-		    let fmt = HeaderFormatter(&val);
 		    b.iter(|| {
-			      format!("{}", fmt);
+			      format!("{}", val.serialize());
 		    });
 	  }
 }

src/header/extensions.rs

@@ -120,10 +120,16 @@ impl HeaderFormat for WebSocketExtensions {
 	}
 }
 
+impl fmt::Display for WebSocketExtensions {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self.fmt_header(fmt)
+	  }
+}
+
 #[cfg(all(feature = "nightly", test))]
 mod tests {
 	use super::*;
-	use hyper::header::{Header, HeaderFormatter};
+	use hyper::header::Header;
 	use test;
 	#[test]
 	fn test_header_extensions() {
@@ -148,9 +154,8 @@ mod tests {
 	fn bench_header_extensions_format(b: &mut test::Bencher) {
 		let value = vec![b"foo, bar; baz; qux=quux".to_vec()];
 		let val: WebSocketExtensions = Header::parse_header(&value[..]).unwrap();
-		let fmt = HeaderFormatter(&val);
 		b.iter(|| {
-			format!("{}", fmt);
+			format!("{}", val);
 		});
 	}
-}
+}

src/header/key.rs

@@ -83,7 +83,7 @@ impl HeaderFormat for WebSocketKey {
 #[cfg(all(feature = "nightly", test))]
 mod tests {
 	use super::*;
-	use hyper::header::{Header, HeaderFormatter};
+	use hyper::header::Header;
 	use test;
 	#[test]
 	fn test_header_key() {
@@ -114,9 +114,8 @@ mod tests {
 	fn bench_header_key_format(b: &mut test::Bencher) {
 		let value = vec![b"QUFBQUFBQUFBQUFBQUFBQQ==".to_vec()];
 		let val: WebSocketKey = Header::parse_header(&value[..]).unwrap();
-		let fmt = HeaderFormatter(&val);
 		b.iter(|| {
-			format!("{}", fmt);
+			format!("{}", val.serialize());
 		});
 	}
-}
+}

src/header/origin.rs

@@ -32,10 +32,16 @@ impl HeaderFormat for Origin {
 	}
 }
 
+impl fmt::Display for Origin {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self.fmt_header(fmt)
+	  }
+}
+
 #[cfg(all(feature = "nightly", test))]
 mod tests {
 	use super::*;
-	use hyper::header::{Header, HeaderFormatter};
+	use hyper::header::Header;
 	use test;
 	#[test]
 	fn test_header_origin() {
@@ -59,9 +65,8 @@ mod tests {
 	fn bench_header_origin_format(b: &mut test::Bencher) {
 		let value = vec![b"foobar".to_vec()];
 		let val: Origin = Header::parse_header(&value[..]).unwrap();
-		let fmt = HeaderFormatter(&val);
 		b.iter(|| {
-			format!("{}", fmt);
+			format!("{}", val);
 		});
 	}
-}
+}

src/header/protocol.rs

@@ -32,10 +32,16 @@ impl HeaderFormat for WebSocketProtocol {
 	}
 }
 
+impl fmt::Display for WebSocketProtocol {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self.fmt_header(fmt)
+	  }
+}
+
 #[cfg(all(feature = "nightly", test))]
 mod tests {
 	use super::*;
-	use hyper::header::{Header, HeaderFormatter};
+	use hyper::header::Header;
 	use test;
 	#[test]
 	fn test_header_protocol() {
@@ -59,9 +65,8 @@ mod tests {
 	fn bench_header_protocol_format(b: &mut test::Bencher) {
 		let value = vec![b"foo, bar".to_vec()];
 		let val: WebSocketProtocol = Header::parse_header(&value[..]).unwrap();
-		let fmt = HeaderFormatter(&val);
 		b.iter(|| {
-			format!("{}", fmt);
+			format!("{}", val);
 		});
 	}
-}
+}

src/header/version.rs

@@ -46,10 +46,16 @@ impl HeaderFormat for WebSocketVersion {
 	}
 }
 
+impl fmt::Display for WebSocketVersion {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self.fmt_header(fmt)
+	  }
+}
+
 #[cfg(all(feature = "nightly", test))]
 mod tests {
 	use super::*;
-	use hyper::header::{Header, HeaderFormatter};
+	use hyper::header::Header;
 	use test;
 	#[test]
 	fn test_websocket_version() {
@@ -73,9 +79,8 @@ mod tests {
 	fn bench_header_version_format(b: &mut test::Bencher) {
 		let value = vec![b"13".to_vec()];
 		let val: WebSocketVersion = Header::parse_header(&value[..]).unwrap();
-		let fmt = HeaderFormatter(&val);
 		b.iter(|| {
-			format!("{}", fmt);
+			format!("{}", val);
 		});
 	}
-}
+}

src/server/upgrade/mod.rs

@@ -110,8 +110,10 @@ impl<S> WsUpgrade<S>
             .unwrap_or(&[])
     }
 
-    pub fn extensions(&self) -> Option<&[Extension]> {
-        self.request.headers.get::<WebSocketExtensions>().map(|e| e.0.as_slice())
+    pub fn extensions(&self) -> &[Extension] {
+        self.request.headers.get::<WebSocketExtensions>()
+            .map(|e| e.0.as_slice())
+            .unwrap_or(&[])
     }
 
     pub fn key(&self) -> Option<&[u8; 16]> {