cargo fmt

Author: vi

src/client/builder.rs

@@ -1,7 +1,9 @@
 //! Everything you need to create a client connection to a websocket.
 
 use crate::header::extensions::Extension;
-use crate::header::{Origin, WebSocketExtensions, WebSocketKey, WebSocketProtocol, WebSocketVersion};
+use crate::header::{
+	Origin, WebSocketExtensions, WebSocketKey, WebSocketProtocol, WebSocketVersion,
+};
 use hyper::header::{Authorization, Basic, Header, HeaderFormat, Headers};
 use hyper::version::HttpVersion;
 use std::borrow::Cow;
@@ -11,6 +13,8 @@ pub use url::{ParseError, Url};
 #[cfg(any(feature = "sync", feature = "async"))]
 mod common_imports {
 	pub use crate::header::WebSocketAccept;
+	pub use crate::result::{WSUrlErrorKind, WebSocketError, WebSocketOtherError, WebSocketResult};
+	pub use crate::stream::{self, Stream};
 	pub use hyper::buffer::BufReader;
 	pub use hyper::header::{Connection, ConnectionOption, Host, Protocol, ProtocolName, Upgrade};
 	pub use hyper::http::h1::parse_response;
@@ -19,10 +23,8 @@ mod common_imports {
 	pub use hyper::method::Method;
 	pub use hyper::status::StatusCode;
 	pub use hyper::uri::RequestUri;
-	pub use crate::result::{WSUrlErrorKind, WebSocketError, WebSocketOtherError, WebSocketResult};
 	pub use std::net::TcpStream;
 	pub use std::net::ToSocketAddrs;
-	pub use crate::stream::{self, Stream};
 	pub use unicase::UniCase;
 	pub use url::Position;
 }
@@ -44,6 +46,7 @@ use native_tls::TlsStream;
 mod async_imports {
 	pub use super::super::r#async;
 	pub use crate::codec::ws::{Context, MessageCodec};
+	pub use crate::ws::util::update_framed_codec;
 	pub use futures::future;
 	pub use futures::Stream as FutureStream;
 	pub use futures::{Future, IntoFuture, Sink};
@@ -53,7 +56,6 @@ mod async_imports {
 	pub use tokio_tcp::TcpStream as TcpStreamNew;
 	#[cfg(feature = "async-ssl")]
 	pub use tokio_tls::TlsConnector as TlsConnectorExt;
-	pub use crate::ws::util::update_framed_codec;
 }
 #[cfg(feature = "async")]
 use self::async_imports::*;

src/codec/http.rs

@@ -255,11 +255,11 @@ impl From<hyper::Error> for HttpCodecError {
 #[cfg(test)]
 mod tests {
 	use super::*;
+	use crate::stream::ReadWritePair;
 	use futures::{Future, Sink, Stream};
 	use hyper::header::Headers;
 	use hyper::version::HttpVersion;
 	use std::io::Cursor;
-	use crate::stream::ReadWritePair;
 	use tokio::runtime::current_thread::Builder;
 
 	#[test]

src/header/accept.rs

@@ -1,8 +1,8 @@
 use crate::header::WebSocketKey;
+use crate::result::{WebSocketError, WebSocketResult};
 use hyper;
 use hyper::header::parsing::from_one_raw_str;
 use hyper::header::{Header, HeaderFormat};
-use crate::result::{WebSocketError, WebSocketResult};
 use std::fmt::{self, Debug};
 use std::str::FromStr;
 

src/header/extensions.rs

@@ -1,9 +1,9 @@
 //! Provides the Sec-WebSocket-Extensions header.
 
+use crate::result::{WebSocketError, WebSocketResult};
 use hyper;
 use hyper::header::parsing::{fmt_comma_delimited, from_comma_delimited};
 use hyper::header::{Header, HeaderFormat};
-use crate::result::{WebSocketError, WebSocketResult};
 use std::fmt;
 use std::ops::Deref;
 use std::str::FromStr;

src/header/key.rs

@@ -1,7 +1,7 @@
+use crate::result::{WebSocketError, WebSocketResult};
 use hyper;
 use hyper::header::parsing::from_one_raw_str;
 use hyper::header::{Header, HeaderFormat};
-use crate::result::{WebSocketError, WebSocketResult};
 use std::fmt::{self, Debug};
 use std::str::FromStr;
 

src/lib.rs

@@ -4,7 +4,7 @@
 	clippy::write_with_newline,
 	clippy::type_complexity,
 	clippy::match_ref_pats,
-	clippy::needless_doctest_main,
+	clippy::needless_doctest_main
 )]
 #![deny(unused_mut)]
 
@@ -142,8 +142,8 @@ pub mod r#async {
 
 	/// A collection of handy asynchronous-only parts of the `client` module.
 	pub mod client {
-		pub use crate::client::r#async::*;
 		pub use crate::client::builder::ClientBuilder;
+		pub use crate::client::r#async::*;
 	}
 	pub use crate::client::r#async::Client;
 

src/result.rs

@@ -1,8 +1,8 @@
 //! The result type used within Rust-WebSocket
 
+use crate::server::upgrade::HyperIntoWsError;
 pub use hyper::status::StatusCode;
 use hyper::Error as HttpError;
-use crate::server::upgrade::HyperIntoWsError;
 use std::convert::From;
 use std::error::Error;
 use std::fmt;

src/sender.rs

@@ -1,13 +1,13 @@
 //! The default implementation of a WebSocket Sender.
 
 use crate::result::WebSocketResult;
-use std::io::Result as IoResult;
-use std::io::Write;
 use crate::stream::sync::AsTcpStream;
 pub use crate::stream::sync::Shutdown;
 use crate::ws;
 use crate::ws::dataframe::DataFrame;
 use crate::ws::sender::Sender as SenderTrait;
+use std::io::Result as IoResult;
+use std::io::Write;
 
 /// A writer that bundles a stream with a serializer to send the messages.
 /// This is used in the client's `.split()` function as the writing component.

src/server/async.rs

@@ -1,10 +1,10 @@
 //! The asynchronous implementation of a websocket server.
-use bytes::BytesMut;
-use futures;
-use futures::{Future, Stream};
 use crate::server::upgrade::r#async::{IntoWs, Upgrade};
 use crate::server::InvalidConnection;
 use crate::server::{NoTlsAcceptor, OptionalTlsAcceptor, WsServer};
+use bytes::BytesMut;
+use futures;
+use futures::{Future, Stream};
 use std;
 use std::io;
 use std::net::SocketAddr;

src/server/mod.rs

@@ -3,8 +3,8 @@
 use native_tls::TlsAcceptor;
 
 use self::upgrade::{HyperIntoWsError, Request};
-use std::fmt::{Debug, Formatter, Result as FmtResult};
 use crate::stream::Stream;
+use std::fmt::{Debug, Formatter, Result as FmtResult};
 
 pub mod upgrade;
 

src/server/sync.rs

@@ -1,9 +1,9 @@
 //! Provides an implementation of a WebSocket server
-#[cfg(feature = "sync-ssl")]
-use native_tls::{TlsAcceptor, TlsStream};
 use crate::server::upgrade::sync::{Buffer, IntoWs, Upgrade};
 pub use crate::server::upgrade::{HyperIntoWsError, Request};
 use crate::server::{InvalidConnection, NoTlsAcceptor, OptionalTlsAcceptor, WsServer};
+#[cfg(feature = "sync-ssl")]
+use native_tls::{TlsAcceptor, TlsStream};
 use std::convert::Into;
 use std::io;
 use std::net::{SocketAddr, TcpListener, TcpStream, ToSocketAddrs};

src/server/upgrade/async.rs

@@ -6,20 +6,20 @@
 //! The `Upgrade` struct is used to inspect details of the websocket connection
 //! (e.g. what protocols it wants to use) and decide whether to accept or reject it.
 use super::{validate, HyperIntoWsError, Request, WsUpgrade};
-use bytes::BytesMut;
 use crate::client::r#async::ClientNew;
 use crate::codec::http::HttpServerCodec;
 use crate::codec::ws::{Context, MessageCodec};
+use crate::stream::r#async::Stream;
+use crate::ws::util::update_framed_codec;
+use bytes::BytesMut;
 use futures::sink::Send as SinkSend;
 use futures::Stream as StreamTrait;
 use futures::{Future, Sink};
 use hyper::header::Headers;
 use hyper::http::h1::Incoming;
 use hyper::status::StatusCode;
 use std::io::{self, ErrorKind};
-use crate::stream::r#async::Stream;
 use tokio_codec::{Decoder, Framed, FramedParts};
-use crate::ws::util::update_framed_codec;
 
 /// An asynchronous websocket upgrade.
 ///

src/server/upgrade/mod.rs

@@ -4,10 +4,10 @@ use crate::header::extensions::Extension;
 use crate::header::{
 	Origin, WebSocketAccept, WebSocketExtensions, WebSocketKey, WebSocketProtocol, WebSocketVersion,
 };
+use crate::stream::Stream;
 use std::error::Error;
 use std::fmt::{self, Display, Formatter};
 use std::io;
-use crate::stream::Stream;
 
 use hyper::header::{Connection, ConnectionOption, Headers, Protocol, ProtocolName, Upgrade};
 use hyper::http::h1::Incoming;

src/server/upgrade/sync.rs

@@ -2,9 +2,9 @@
 //! WebSocket client.
 use crate::client::sync::Client;
 use crate::server::upgrade::{validate, HyperIntoWsError, Request, WsUpgrade};
+use crate::stream::sync::{AsTcpStream, Stream};
 use std::io;
 use std::net::TcpStream;
-use crate::stream::sync::{AsTcpStream, Stream};
 
 use hyper::buffer::BufReader;
 use hyper::header::Headers;

websocket-base/src/codec/ws.rs

@@ -304,11 +304,11 @@ where
 mod tests {
 	extern crate tokio;
 	use super::*;
-	use futures::{Future, Sink, Stream};
 	use crate::message::CloseData;
 	use crate::message::Message;
-	use std::io::Cursor;
 	use crate::stream::ReadWritePair;
+	use futures::{Future, Sink, Stream};
+	use std::io::Cursor;
 
 	#[test]
 	fn owned_message_predicts_size() {

websocket-base/src/dataframe.rs

@@ -1,10 +1,10 @@
 //! Module containing the default implementation of data frames.
 use crate::result::{WebSocketError, WebSocketResult};
-use std::io::{self, Read, Write};
 use crate::ws::dataframe::DataFrame as DataFrameable;
 use crate::ws::util::header as dfh;
 use crate::ws::util::header::DataFrameHeader;
 use crate::ws::util::mask;
+use std::io::{self, Read, Write};
 
 /// Represents a WebSocket data frame.
 ///

websocket-base/src/header.rs

@@ -2,7 +2,6 @@
 
 extern crate rand;
 
-
 /// WebSocket header names
 pub mod names {
 	pub const PROTOCOL: &str = "Sec-WebSocket-Protocol";

websocket-base/src/lib.rs

@@ -9,10 +9,7 @@
 //! Note that there is no normal example of usage so far. See usual `websocket` crate or
 //! alternative like `tungstenite`.
 
-#![allow(
-	clippy::match_ref_pats,
-	clippy::needless_doctest_main,
-)]
+#![allow(clippy::match_ref_pats, clippy::needless_doctest_main)]
 extern crate byteorder;
 
 #[cfg(feature = "async")]

websocket-base/src/message.rs

@@ -1,14 +1,14 @@
 //! Module containing the default implementation for messages.
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use crate::dataframe::Opcode;
 use crate::result::{WebSocketError, WebSocketResult};
+use crate::ws;
+use crate::ws::dataframe::DataFrame as DataFrameTrait;
+use crate::ws::util::bytes_to_string;
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use std::borrow::Cow;
 use std::io;
 use std::io::Write;
 use std::str::from_utf8;
-use crate::ws;
-use crate::ws::dataframe::DataFrame as DataFrameTrait;
-use crate::ws::util::bytes_to_string;
 
 const FALSE_RESERVED_BITS: &[bool; 3] = &[false; 3];
 

websocket-base/src/result.rs

@@ -59,7 +59,7 @@ impl Error for WebSocketError {
 		}
 	}
 
-    #[allow(deprecated)]
+	#[allow(deprecated)]
 	fn cause(&self) -> Option<&dyn Error> {
 		match *self {
 			WebSocketError::IoError(ref error) => Some(error),

websocket-base/src/ws/dataframe.rs

@@ -3,10 +3,10 @@
 //! optimize the memory footprint of a dataframe for their
 //! own needs, and be able to use custom dataframes quickly
 use crate::result::WebSocketResult;
-use std::io::Write;
 use crate::ws::util::header as dfh;
 use crate::ws::util::mask;
 use crate::ws::util::mask::Masker;
+use std::io::Write;
 
 /// A generic DataFrame. Every dataframe should be able to
 /// provide these methods. (If the payload is not known in advance then

websocket-base/src/ws/message.rs

@@ -3,8 +3,8 @@
 //! See the `ws` module documentation for more information.
 
 use crate::result::WebSocketResult;
-use std::io::Write;
 use crate::ws::dataframe::DataFrame as DataFrameable;
+use std::io::Write;
 
 /// A trait for WebSocket messages
 pub trait Message: Sized {

websocket-base/src/ws/receiver.rs

@@ -4,9 +4,9 @@
 //! See the `ws` module documentation for more information.
 
 use crate::result::WebSocketResult;
-use std::io::Read;
 use crate::ws::dataframe::DataFrame;
 use crate::ws::Message;
+use std::io::Read;
 
 /// A trait for receiving data frames and messages.
 pub trait Receiver: Sized {

websocket-base/src/ws/sender.rs

@@ -3,9 +3,9 @@
 //! See the `ws` module documentation for more information.
 
 use crate::result::WebSocketResult;
-use std::io::Write;
 use crate::ws::dataframe::DataFrame;
 use crate::ws::Message;
+use std::io::Write;
 
 /// A trait for sending data frames and messages.
 pub trait Sender {

websocket-base/src/ws/util/header.rs

@@ -1,7 +1,7 @@
 //! Utility functions for reading and writing data frame headers.
 
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use crate::result::{WebSocketError, WebSocketResult};
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use std::io::{Read, Write};
 
 bitflags! {