Fix clippy and fmt

Author: krishvishal

compio-ws/examples/autobahn-server.rs

@@ -1,7 +1,8 @@
+use std::net::SocketAddr;
+
 use compio_net::{TcpListener, TcpStream};
-use compio_ws::{accept_async_with_config, WebSocketConfig};
+use compio_ws::{WebSocketConfig, accept_async_with_config};
 use log::*;
-use std::net::SocketAddr;
 use tungstenite::{Error, Result};
 
 async fn accept_connection(peer: SocketAddr, stream: TcpStream) {

compio-ws/examples/client_tls.rs

@@ -1,6 +1,7 @@
-use compio_ws::{connect_async_with_tls_connector, Connector};
-use rustls::ClientConfig;
 use std::sync::Arc;
+
+use compio_ws::{Connector, connect_async_with_tls_connector};
+use rustls::ClientConfig;
 use tungstenite::Message;
 
 async fn create_insecure_tls_connector() -> Result<Connector, Box<dyn std::error::Error>> {

compio-ws/examples/echo_server_tls.rs

@@ -1,15 +1,16 @@
+use std::{fs, sync::Arc};
+
 use compio_net::{TcpListener, TcpStream};
 use compio_tls::TlsAcceptor;
 use compio_ws::accept_async;
 use rustls::ServerConfig;
-use std::fs;
-use std::sync::Arc;
 use tungstenite::Message;
 
 async fn create_tls_acceptor() -> Result<TlsAcceptor, Box<dyn std::error::Error>> {
     // Load certificate and key from files
     // Generate these files with:
-    // openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.crt -days 365 -nodes -subj "/CN=localhost"
+    // openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.crt
+    // -days 365 -nodes -subj "/CN=localhost"
 
     let cert_file = fs::read_to_string("localhost.crt")?;
     let key_file = fs::read_to_string("localhost.key")?;
@@ -42,7 +43,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     {
         eprintln!("Error: Certificate files not found!");
         eprintln!("Please generate them with:");
-        eprintln!("openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.crt -days 365 -nodes -subj \"/CN=localhost\"");
+        eprintln!(
+            "openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.crt -days \
+             365 -nodes -subj \"/CN=localhost\""
+        );
         return Err("Missing certificate files".into());
     }
 

compio-ws/src/growable_sync_stream.rs

@@ -5,28 +5,33 @@ use compio_io::{AsyncRead, AsyncWrite};
 
 /// A growable buffered stream adapter that bridges async I/O with sync traits.
 ///
-/// This is similar to `compio_io::compat::SyncStream` but with dynamically growing
-/// buffers that can expand beyond the initial capacity up to a configurable maximum.
+/// This is similar to `compio_io::compat::SyncStream` but with dynamically
+/// growing buffers that can expand beyond the initial capacity up to a
+/// configurable maximum.
 ///
 /// # Buffer Growth Strategy
 ///
-/// - **Read buffer**: Grows as needed to accommodate incoming data, up to `max_buffer_size`
-/// - **Write buffer**: Grows as needed for outgoing data, up to `max_buffer_size`
-/// - Both buffers shrink back to `base_capacity` when fully consumed and capacity exceeds 4x base
+/// - **Read buffer**: Grows as needed to accommodate incoming data, up to
+///   `max_buffer_size`
+/// - **Write buffer**: Grows as needed for outgoing data, up to
+///   `max_buffer_size`
+/// - Both buffers shrink back to `base_capacity` when fully consumed and
+///   capacity exceeds 4x base
 ///
 /// # Usage Pattern
 ///
-/// The sync `Read` and `Write` implementations will return `WouldBlock` errors when
-/// buffers need servicing via the async methods:
+/// The sync `Read` and `Write` implementations will return `WouldBlock` errors
+/// when buffers need servicing via the async methods:
 ///
 /// - Call `fill_read_buf()` when `Read::read()` returns `WouldBlock`
 /// - Call `flush_write_buf()` when `Write::write()` returns `WouldBlock`
 ///
 /// # Note on flush()
 ///
-/// The `Write::flush()` method intentionally returns `Ok(())` without checking if there's
-/// buffered data. This is for compatibility with libraries like tungstenite that call
-/// `flush()` after every write. Actual flushing happens via the async `flush_write_buf()` method.
+/// The `Write::flush()` method intentionally returns `Ok(())` without checking
+/// if there's buffered data. This is for compatibility with libraries like
+/// tungstenite that call `flush()` after every write. Actual flushing happens
+/// via the async `flush_write_buf()` method.
 #[derive(Debug)]
 pub struct GrowableSyncStream<S> {
     inner: S,
@@ -39,8 +44,11 @@ pub struct GrowableSyncStream<S> {
 }
 
 impl<S> GrowableSyncStream<S> {
-    const DEFAULT_BASE_CAPACITY: usize = 8 * 1024; // 8KB base
-    const DEFAULT_MAX_BUFFER: usize = 64 * 1024 * 1024; // 64MB max
+    const DEFAULT_BASE_CAPACITY: usize = 8 * 1024;
+    // 8KB base
+    const DEFAULT_MAX_BUFFER: usize = 64 * 1024 * 1024;
+
+    // 64MB max
 
     /// Creates a new `GrowableSyncStream` with default buffer sizes.
     ///
@@ -65,7 +73,8 @@ impl<S> GrowableSyncStream<S> {
         }
     }
 
-    /// Creates a new `GrowableSyncStream` with custom base capacity and maximum buffer size.
+    /// Creates a new `GrowableSyncStream` with custom base capacity and maximum
+    /// buffer size.
     pub fn with_limits(base_capacity: usize, max_buffer_size: usize, stream: S) -> Self {
         Self {
             inner: stream,
@@ -149,8 +158,9 @@ impl<S> Read for GrowableSyncStream<S> {
 impl<S> Write for GrowableSyncStream<S> {
     /// Writes data to the internal buffer.
     ///
-    /// Returns `WouldBlock` if the buffer needs flushing or has reached max capacity.
-    /// In the latter case, it may write partial data before returning `WouldBlock`.
+    /// Returns `WouldBlock` if the buffer needs flushing or has reached max
+    /// capacity. In the latter case, it may write partial data before
+    /// returning `WouldBlock`.
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         // Check if we should flush first
         if self.write_buf.len() > self.base_capacity * 2 / 3 && !self.write_buf.is_empty() {
@@ -179,13 +189,14 @@ impl<S> Write for GrowableSyncStream<S> {
 
     /// Returns `Ok(())` without checking for buffered data.
     ///
-    /// **Important**: This does NOT actually flush data to the underlying stream.
-    /// This behavior is intentional for compatibility with libraries like tungstenite
-    /// that call `flush()` after every write operation. The actual async flush
-    /// happens when `flush_write_buf()` is called.
+    /// **Important**: This does NOT actually flush data to the underlying
+    /// stream. This behavior is intentional for compatibility with
+    /// libraries like tungstenite that call `flush()` after every write
+    /// operation. The actual async flush happens when `flush_write_buf()`
+    /// is called.
     ///
-    /// This prevents spurious errors in sync code that expects `flush()` to succeed
-    /// after successfully buffering data.
+    /// This prevents spurious errors in sync code that expects `flush()` to
+    /// succeed after successfully buffering data.
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
@@ -307,7 +318,8 @@ impl<S: AsyncWrite> GrowableSyncStream<S> {
     /// # Errors
     ///
     /// Returns an error if the underlying stream returns an error.
-    /// In this case, the buffer retains any data that wasn't successfully written.
+    /// In this case, the buffer retains any data that wasn't successfully
+    /// written.
     pub async fn flush_write_buf(&mut self) -> io::Result<usize> {
         if self.write_buf.is_empty() {
             return Ok(0);

compio-ws/src/lib.rs

@@ -1,8 +1,9 @@
 //! Async WebSocket support for compio.
 //!
-//! This library is an implementation of WebSocket handshakes and streams for compio.
-//! It is based on the tungstenite crate which implements all required WebSocket protocol
-//! logic. This crate brings compio support / compio integration to it.
+//! This library is an implementation of WebSocket handshakes and streams for
+//! compio. It is based on the tungstenite crate which implements all required
+//! WebSocket protocol logic. This crate brings compio support / compio
+//! integration to it.
 //!
 //! Each WebSocket stream implements message reading and writing.
 
@@ -16,21 +17,16 @@ use std::io::ErrorKind;
 
 use compio_io::{AsyncRead, AsyncWrite};
 use growable_sync_stream::GrowableSyncStream;
-
 use tungstenite::{
     Error as WsError, HandshakeError, Message, WebSocket,
     client::IntoClientRequest,
     handshake::server::{Callback, NoCallback},
     protocol::CloseFrame,
 };
-
-pub use crate::stream::MaybeTlsStream;
-
-pub use tungstenite::{Message as WebSocketMessage, handshake::client::Response};
-
-pub use tungstenite::protocol::WebSocketConfig;
-
-pub use tungstenite::error::Error as TungsteniteError;
+pub use tungstenite::{
+    Message as WebSocketMessage, error::Error as TungsteniteError, handshake::client::Response,
+    protocol::WebSocketConfig,
+};
 
 #[cfg(feature = "rustls")]
 pub use crate::rustls::{
@@ -39,6 +35,7 @@ pub use crate::rustls::{
     connect_async_with_config, connect_async_with_tls_connector,
     connect_async_with_tls_connector_and_config,
 };
+pub use crate::stream::MaybeTlsStream;
 
 pub struct WebSocketStream<S> {
     inner: WebSocket<GrowableSyncStream<S>>,
@@ -140,8 +137,8 @@ where
     accept_hdr_async(stream, NoCallback).await
 }
 
-/// The same as `accept_async()` but the one can specify a websocket configuration.
-/// Please refer to `accept_async()` for more details.
+/// The same as `accept_async()` but the one can specify a websocket
+/// configuration. Please refer to `accept_async()` for more details.
 pub async fn accept_async_with_config<S>(
     stream: S,
     config: Option<WebSocketConfig>,
@@ -153,9 +150,9 @@ where
 }
 /// Accepts a new WebSocket connection with the provided stream.
 ///
-/// This function does the same as `accept_async()` but accepts an extra callback
-/// for header processing. The callback receives headers of the incoming
-/// requests and is able to add extra headers to the reply.
+/// This function does the same as `accept_async()` but accepts an extra
+/// callback for header processing. The callback receives headers of the
+/// incoming requests and is able to add extra headers to the reply.
 pub async fn accept_hdr_async<S, C>(stream: S, callback: C) -> Result<WebSocketStream<S>, WsError>
 where
     S: AsyncRead + AsyncWrite + Unpin + std::fmt::Debug,
@@ -164,8 +161,8 @@ where
     accept_hdr_with_config_async(stream, callback, None).await
 }
 
-/// The same as `accept_hdr_async()` but the one can specify a websocket configuration.
-/// Please refer to `accept_hdr_async()` for more details.
+/// The same as `accept_hdr_async()` but the one can specify a websocket
+/// configuration. Please refer to `accept_hdr_async()` for more details.
 pub async fn accept_hdr_with_config_async<S, C>(
     stream: S,
     callback: C,
@@ -228,8 +225,8 @@ where
     client_async_with_config(request, stream, None).await
 }
 
-/// The same as `client_async()` but the one can specify a websocket configuration.
-/// Please refer to `client_async()` for more details.
+/// The same as `client_async()` but the one can specify a websocket
+/// configuration. Please refer to `client_async()` for more details.
 pub async fn client_async_with_config<R, S>(
     request: R,
     stream: S,
@@ -281,11 +278,12 @@ pub(crate) fn domain(
         .uri()
         .host()
         .map(|host| {
-            // If host is an IPv6 address, it might be surrounded by brackets. These brackets are
-            // *not* part of a valid IP, so they must be stripped out.
+            // If host is an IPv6 address, it might be surrounded by brackets. These
+            // brackets are *not* part of a valid IP, so they must be stripped
+            // out.
             //
-            // The URI from the request is guaranteed to be valid, so we don't need a separate
-            // check for the closing bracket.
+            // The URI from the request is guaranteed to be valid, so we don't need a
+            // separate check for the closing bracket.
             let host = if host.starts_with('[') {
                 &host[1..host.len() - 1]
             } else {

compio-ws/src/rustls.rs

@@ -1,17 +1,19 @@
+use std::sync::Arc;
+
 use compio_io::{AsyncRead, AsyncWrite};
 use compio_net::TcpStream;
 use compio_tls::TlsConnector;
 use rustls::{ClientConfig, RootCertStore};
+use tungstenite::{
+    Error,
+    client::{IntoClientRequest, uri_mode},
+    handshake::client::{Request, Response},
+    stream::Mode,
+};
 
-use tungstenite::Error;
-use tungstenite::client::{IntoClientRequest, uri_mode};
-use tungstenite::handshake::client::{Request, Response};
-use tungstenite::stream::Mode;
-
-use std::sync::Arc;
-
-use crate::stream::MaybeTlsStream;
-use crate::{WebSocketConfig, WebSocketStream, client_async_with_config, domain};
+use crate::{
+    WebSocketConfig, WebSocketStream, client_async_with_config, domain, stream::MaybeTlsStream,
+};
 
 pub type AutoStream<S> = MaybeTlsStream<S>;
 
@@ -35,7 +37,7 @@ where
                 } else {
                     // Only create root_store when we actually have certificate features enabled
                     #[cfg(any(feature = "rustls-native-certs", feature = "webpki-roots"))]
-                    let mut root_store = {
+                    let root_store = {
                         let mut store = RootCertStore::empty();
 
                         #[cfg(feature = "rustls-native-certs")]
@@ -80,8 +82,7 @@ where
                         {
                             use log::debug;
 
-                            let webpki_certs: Vec<_> =
-                                webpki_roots::TLS_SERVER_ROOTS.iter().cloned().collect();
+                            let webpki_certs = webpki_roots::TLS_SERVER_ROOTS.to_vec();
                             store.extend(webpki_certs);
                             debug!(
                                 "Added {} webpki root certificates",
@@ -97,7 +98,8 @@ where
                     {
                         return Err(Error::Io(std::io::Error::new(
                             std::io::ErrorKind::NotFound,
-                            "No root certificate features enabled. Enable either 'rustls-native-certs' or 'webpki-roots'",
+                            "No root certificate features enabled. Enable either \
+                             'rustls-native-certs' or 'webpki-roots'",
                         )));
                     }
 
@@ -145,7 +147,8 @@ where
     client_async_tls_with_connector_and_config(request, stream, None, None).await
 }
 
-/// The same as `client_async_tls()` but the one can specify a websocket configuration.
+/// The same as `client_async_tls()` but the one can specify a websocket
+/// configuration.
 pub async fn client_async_tls_with_config<R, S>(
     request: R,
     stream: S,
@@ -173,8 +176,8 @@ where
     client_async_tls_with_connector_and_config(request, stream, connector, None).await
 }
 
-/// The same as `client_async_tls()` but the one can specify a websocket configuration,
-/// and an optional connector.
+/// The same as `client_async_tls()` but the one can specify a websocket
+/// configuration, and an optional connector.
 pub async fn client_async_tls_with_connector_and_config<R, S>(
     request: R,
     stream: S,
@@ -208,9 +211,10 @@ where
     connect_async_with_config(request, None, false).await
 }
 
-/// The same as `connect_async()` but the one can specify a websocket configuration.
-/// `disable_nagle` specifies if the Nagle's algorithm must be disabled, i.e. `set_nodelay(true)`.
-/// If you don't know what the Nagle's algorithm is, better leave it to `false`.
+/// The same as `connect_async()` but the one can specify a websocket
+/// configuration. `disable_nagle` specifies if the Nagle's algorithm must be
+/// disabled, i.e. `set_nodelay(true)`. If you don't know what the Nagle's
+/// algorithm is, better leave it to `false`.
 pub async fn connect_async_with_config<R>(
     request: R,
     config: Option<WebSocketConfig>,
@@ -246,8 +250,8 @@ where
     connect_async_with_tls_connector_and_config(request, connector, None).await
 }
 
-/// The same as `connect_async()` but the one can specify a websocket configuration,
-/// a TLS connector, and whether to disable Nagle's algorithm.
+/// The same as `connect_async()` but the one can specify a websocket
+/// configuration, a TLS connector, and whether to disable Nagle's algorithm.
 pub async fn connect_async_with_tls_connector_and_config<R>(
     request: R,
     connector: Option<Connector>,

compio-ws/src/stream.rs

@@ -1,8 +1,9 @@
+use std::io::Result as IoResult;
+
 use compio_buf::{BufResult, IoBuf, IoBufMut};
 use compio_io::{AsyncRead, AsyncWrite};
 #[cfg(feature = "rustls")]
 use compio_tls::TlsStream;
-use std::io::Result as IoResult;
 
 /// Stream that can be either plain TCP or TLS-encrypted
 #[derive(Debug)]