Run rustfmt on bitreq to align it with workspace requirements

TheBlueMatt · TheBlueMatt · commit 5628c213dfae · 2026-01-07T01:09:54.000Z
It appears `bitreq` had fallen out of sync with the workspace
`rustfmt` requirements, so we run it here.

Best reviewed with `--word-diff`
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
@@ -8,11 +8,11 @@ use std::net::{TcpStream, ToSocketAddrs};
 use std::pin::Pin;
 use std::time::Instant;
 
-#[cfg(feature = "async")]
-use tokio::io::{AsyncRead, AsyncWriteExt};
 #[cfg(all(feature = "async", feature = "proxy"))]
 use tokio::io::AsyncReadExt;
 #[cfg(feature = "async")]
+use tokio::io::{AsyncRead, AsyncWriteExt};
+#[cfg(feature = "async")]
 use tokio::net::TcpStream as AsyncTcpStream;
 
 use crate::request::ParsedRequest;
@@ -481,7 +481,11 @@ macro_rules! redirect_utils {
             Destination($Connection),
         }
 
-        fn $get_redirect(mut connection: $Connection, status_code: i32, url: Option<&String>) -> $NextHop {
+        fn $get_redirect(
+            mut connection: $Connection,
+            status_code: i32,
+            url: Option<&String>,
+        ) -> $NextHop {
             match status_code {
                 301 | 302 | 303 | 307 => {
                     let url = match url {
@@ -510,8 +514,7 @@ macro_rules! redirect_utils {
                 _ => $NextHop::Destination(connection),
             }
         }
-
-    }
+    };
 }
 
 redirect_utils!(get_redirect, NextHop, Connection, ResponseLazy);
@@ -544,8 +547,9 @@ where
                     Ok(()) => thread.join().unwrap(),
                     Err(err) => match err {
                         RecvTimeoutError::Timeout => Err(Error::IoError(timeout_err())),
-                        RecvTimeoutError::Disconnected =>
-                            Err(Error::Other("request connection paniced")),
+                        RecvTimeoutError::Disconnected => {
+                            Err(Error::Other("request connection paniced"))
+                        }
                     },
                 }
             } else {
diff --git a/bitreq/src/connection/rustls_stream.rs b/bitreq/src/connection/rustls_stream.rs
@@ -14,7 +14,7 @@ use webpki_roots::TLS_SERVER_ROOTS;
 #[cfg(feature = "async-https")]
 use tokio::io::AsyncWriteExt;
 #[cfg(feature = "async-https")]
-use tokio_rustls::{TlsConnector, client::TlsStream};
+use tokio_rustls::{client::TlsStream, TlsConnector};
 
 #[cfg(feature = "async-https")]
 use super::{AsyncConnection, AsyncHttpStream};
@@ -89,7 +89,9 @@ pub(super) fn create_secured_stream(conn: &Connection) -> Result<HttpStream, Err
 pub type AsyncSecuredStream = TlsStream<tokio::net::TcpStream>;
 
 #[cfg(feature = "async-https")]
-pub(super) async fn create_async_secured_stream(conn: &AsyncConnection) -> Result<AsyncHttpStream, Error> {
+pub(super) async fn create_async_secured_stream(
+    conn: &AsyncConnection,
+) -> Result<AsyncHttpStream, Error> {
     // Rustls setup
     #[cfg(feature = "log")]
     log::trace!("Setting up TLS parameters for {}.", conn.request.url.host);
diff --git a/bitreq/src/error.rs b/bitreq/src/error.rs
@@ -133,5 +133,7 @@ impl error::Error for Error {
 
 #[cfg(feature = "std")]
 impl From<io::Error> for Error {
-    fn from(other: io::Error) -> Error { Error::IoError(other) }
+    fn from(other: io::Error) -> Error {
+        Error::IoError(other)
+    }
 }
diff --git a/bitreq/src/request.rs b/bitreq/src/request.rs
@@ -512,39 +512,57 @@ impl ParsedRequest {
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Get](enum.Method.html).
-pub fn get<T: Into<URL>>(url: T) -> Request { Request::new(Method::Get, url) }
+pub fn get<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Get, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Head](enum.Method.html).
-pub fn head<T: Into<URL>>(url: T) -> Request { Request::new(Method::Head, url) }
+pub fn head<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Head, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Post](enum.Method.html).
-pub fn post<T: Into<URL>>(url: T) -> Request { Request::new(Method::Post, url) }
+pub fn post<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Post, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Put](enum.Method.html).
-pub fn put<T: Into<URL>>(url: T) -> Request { Request::new(Method::Put, url) }
+pub fn put<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Put, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Delete](enum.Method.html).
-pub fn delete<T: Into<URL>>(url: T) -> Request { Request::new(Method::Delete, url) }
+pub fn delete<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Delete, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Connect](enum.Method.html).
-pub fn connect<T: Into<URL>>(url: T) -> Request { Request::new(Method::Connect, url) }
+pub fn connect<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Connect, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Options](enum.Method.html).
-pub fn options<T: Into<URL>>(url: T) -> Request { Request::new(Method::Options, url) }
+pub fn options<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Options, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Trace](enum.Method.html).
-pub fn trace<T: Into<URL>>(url: T) -> Request { Request::new(Method::Trace, url) }
+pub fn trace<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Trace, url)
+}
 
 /// Alias for [Request::new](struct.Request.html#method.new) with `method` set to
 /// [Method::Patch](enum.Method.html).
-pub fn patch<T: Into<URL>>(url: T) -> Request { Request::new(Method::Patch, url) }
+pub fn patch<T: Into<URL>>(url: T) -> Request {
+    Request::new(Method::Patch, url)
+}
 
 #[cfg(test)]
 #[cfg(feature = "std")]
diff --git a/bitreq/src/response.rs b/bitreq/src/response.rs
@@ -1,9 +1,9 @@
 use alloc::collections::BTreeMap;
 use core::str;
-#[cfg(feature = "std")]
-use std::io::{self, BufReader, Bytes, Read};
 #[cfg(feature = "async")]
 use std::future::Future;
+#[cfg(feature = "std")]
+use std::io::{self, BufReader, Bytes, Read};
 
 #[cfg(feature = "async")]
 use tokio::io::{AsyncRead, AsyncReadExt};
@@ -96,9 +96,7 @@ impl Response {
         if !is_head && status_code != 204 && status_code != 304 {
             match state {
                 EndOnClose => {
-                    while let Some(byte_result) =
-                        read_until_closed_async(&mut stream).await
-                    {
+                    while let Some(byte_result) = read_until_closed_async(&mut stream).await {
                         let (byte, length) = byte_result?;
                         body.reserve(length);
                         body.push(byte);
@@ -179,7 +177,9 @@ impl Response {
     /// # #[cfg(not(feature = "std"))]
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> { Ok(()) }
     /// ```
-    pub fn as_bytes(&self) -> &[u8] { &self.body }
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.body
+    }
 
     /// Turns the `Response` into the inner `Vec<u8>`, the bytes that
     /// make up the response's body. If you just need a `&[u8]`, use
@@ -199,7 +199,9 @@ impl Response {
     /// # #[cfg(not(feature = "std"))]
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> { Ok(()) }
     /// ```
-    pub fn into_bytes(self) -> Vec<u8> { self.body }
+    pub fn into_bytes(self) -> Vec<u8> {
+        self.body
+    }
 
     /// Converts JSON body to a `struct` using Serde.
     ///
@@ -349,15 +351,16 @@ impl Iterator for ResponseLazy {
         match self.state {
             EndOnClose => read_until_closed(&mut self.stream),
             ContentLength(ref mut length) => read_with_content_length(&mut self.stream, length),
-            Chunked(ref mut expecting_chunks, ref mut length, ref mut content_length) =>
+            Chunked(ref mut expecting_chunks, ref mut length, ref mut content_length) => {
                 read_chunked(
                     &mut self.stream,
                     &mut self.headers,
                     expecting_chunks,
                     length,
                     content_length,
                     self.max_trailing_headers_size,
-                ),
+                )
+            }
         }
     }
 }
@@ -435,9 +438,7 @@ trait AsyncIteratorReadExt {
 #[cfg(feature = "async")]
 impl<T: AsyncReadExt + Unpin> AsyncIteratorReadExt for T {
     fn next(&mut self) -> impl Future<Output = Option<Result<u8, io::Error>>> {
-        async {
-            Some(self.read_u8().await)
-        }
+        async { Some(self.read_u8().await) }
     }
 }
 
diff --git a/bitreq/tests/main.rs b/bitreq/tests/main.rs
@@ -24,7 +24,8 @@ async fn test_json_using_serde() {
 
     setup();
     let original_json: serde_json::Value = serde_json::from_str(JSON_SRC).unwrap();
-    let response = make_request(bitreq::post(url("/echo")).with_json(&original_json).unwrap()).await;
+    let response =
+        make_request(bitreq::post(url("/echo")).with_json(&original_json).unwrap()).await;
     let actual_json: serde_json::Value = response.json().unwrap();
     assert_eq!(actual_json, original_json);
 }
@@ -56,10 +57,9 @@ async fn test_headers() {
 async fn test_custom_method() {
     use bitreq::Method;
     setup();
-    let body = get_body(
-        bitreq::Request::new(Method::Custom("GET".to_string()), url("/a")).with_body("Q"),
-    )
-    .await;
+    let body =
+        get_body(bitreq::Request::new(Method::Custom("GET".to_string()), url("/a")).with_body("Q"))
+            .await;
     assert_eq!("j: Q", body);
 }
 
@@ -176,7 +176,8 @@ async fn test_patch() {
 #[tokio::test]
 async fn tcp_connect_timeout() {
     let _listener = std::net::TcpListener::bind("127.0.0.1:32162").unwrap();
-    let request = bitreq::Request::new(bitreq::Method::Get, "http://127.0.0.1:32162").with_timeout(1);
+    let request =
+        bitreq::Request::new(bitreq::Method::Get, "http://127.0.0.1:32162").with_timeout(1);
     let resp = maybe_make_request(request).await;
     assert!(resp.is_err());
     if let Some(bitreq::Error::IoError(err)) = resp.err() {
diff --git a/bitreq/tests/setup.rs b/bitreq/tests/setup.rs
@@ -175,9 +175,13 @@ pub fn setup() {
     });
 }
 
-pub fn url(req: &str) -> String { format!("http://localhost:35562{}", req) }
+pub fn url(req: &str) -> String {
+    format!("http://localhost:35562{}", req)
+}
 
-pub async fn maybe_make_request(request: bitreq::Request) -> Result<bitreq::Response, bitreq::Error> {
+pub async fn maybe_make_request(
+    request: bitreq::Request,
+) -> Result<bitreq::Response, bitreq::Error> {
     let response = request.clone().send();
     let lazy_response = request.clone().send_lazy();
     match (&response, lazy_response) {
@@ -187,7 +191,7 @@ pub async fn maybe_make_request(request: bitreq::Request) -> Result<bitreq::Resp
             let mut lazy_bytes = Vec::new();
             lazy_resp.read_to_end(&mut lazy_bytes).unwrap();
             assert_eq!(lazy_bytes, resp.as_bytes());
-        },
+        }
         (Err(e), Err(lazy_e)) => assert_eq!(format!("{e:?}"), format!("{lazy_e:?}")),
         (res, lazy_res) => panic!("{res:?} != {}", lazy_res.is_err()),
     }
@@ -208,7 +212,7 @@ pub async fn maybe_make_request(request: bitreq::Request) -> Result<bitreq::Resp
                 assert_eq!(async_resp.status_code, resp.status_code);
                 assert_eq!(async_resp.reason_phrase, resp.reason_phrase);
                 assert_eq!(async_resp.as_bytes(), resp.as_bytes());
-            },
+            }
             (Err(e), Err(async_e)) => assert_eq!(format!("{e:?}"), format!("{async_e:?}")),
             (res, async_res) => panic!("{res:?} != {async_res:?}"),
         }
@@ -219,7 +223,7 @@ pub async fn maybe_make_request(request: bitreq::Request) -> Result<bitreq::Resp
                 let mut lazy_bytes = Vec::new();
                 lazy_resp.read_to_end(&mut lazy_bytes).unwrap();
                 assert_eq!(lazy_bytes, resp.as_bytes());
-            },
+            }
             (Err(e), Err(lazy_e)) => assert_eq!(format!("{e:?}"), format!("{lazy_e:?}")),
             (res, lazy_res) => panic!("{res:?} != {}", lazy_res.is_err()),
         }

Original file line number	Diff line number	Diff line change
`@@ -133,5 +133,7 @@ impl error::Error for Error {`
`133`	`133`
`134`	`134`	`#[cfg(feature = "std")]`
`135`	`135`	`impl From<io::Error> for Error {`
`136`		`- fn from(other: io::Error) -> Error { Error::IoError(other) }`
	`136`	`+ fn from(other: io::Error) -> Error {`
	`137`	`+ Error::IoError(other)`
	`138`	`+ }`
`137`	`139`	`}`